aboutsummaryrefslogtreecommitdiff
path: root/bin/ksh/path.c
diff options
context:
space:
mode:
Diffstat (limited to 'bin/ksh/path.c')
-rw-r--r--bin/ksh/path.c266
1 files changed, 266 insertions, 0 deletions
diff --git a/bin/ksh/path.c b/bin/ksh/path.c
new file mode 100644
index 0000000..e2b2c00
--- /dev/null
+++ b/bin/ksh/path.c
@@ -0,0 +1,266 @@
+/* $OpenBSD: path.c,v 1.18 2015/12/14 13:59:42 tb Exp $ */
+
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "sh.h"
+
+/*
+ * Contains a routine to search a : separated list of
+ * paths (a la CDPATH) and make appropriate file names.
+ * Also contains a routine to simplify .'s and ..'s out of
+ * a path name.
+ *
+ * Larry Bouzane (larry@cs.mun.ca)
+ */
+
+static char *do_phys_path(XString *, char *, const char *);
+
+/*
+ * Makes a filename into result using the following algorithm.
+ * - make result NULL
+ * - if file starts with '/', append file to result & set cdpathp to NULL
+ * - if file starts with ./ or ../ append cwd and file to result
+ * and set cdpathp to NULL
+ * - if the first element of cdpathp doesnt start with a '/' xx or '.' xx
+ * then cwd is appended to result.
+ * - the first element of cdpathp is appended to result
+ * - file is appended to result
+ * - cdpathp is set to the start of the next element in cdpathp (or NULL
+ * if there are no more elements.
+ * The return value indicates whether a non-null element from cdpathp
+ * was appended to result.
+ */
+int
+make_path(const char *cwd, const char *file,
+ char **cdpathp, /* & of : separated list */
+ XString *xsp,
+ int *phys_pathp)
+{
+ int rval = 0;
+ int use_cdpath = 1;
+ char *plist;
+ int len;
+ int plen = 0;
+ char *xp = Xstring(*xsp, xp);
+
+ if (!file)
+ file = null;
+
+ if (file[0] == '/') {
+ *phys_pathp = 0;
+ use_cdpath = 0;
+ } else {
+ if (file[0] == '.') {
+ char c = file[1];
+
+ if (c == '.')
+ c = file[2];
+ if (c == '/' || c == '\0')
+ use_cdpath = 0;
+ }
+
+ plist = *cdpathp;
+ if (!plist)
+ use_cdpath = 0;
+ else if (use_cdpath) {
+ char *pend;
+
+ for (pend = plist; *pend && *pend != ':'; pend++)
+ ;
+ plen = pend - plist;
+ *cdpathp = *pend ? ++pend : NULL;
+ }
+
+ if ((use_cdpath == 0 || !plen || plist[0] != '/') &&
+ (cwd && *cwd)) {
+ len = strlen(cwd);
+ XcheckN(*xsp, xp, len);
+ memcpy(xp, cwd, len);
+ xp += len;
+ if (cwd[len - 1] != '/')
+ Xput(*xsp, xp, '/');
+ }
+ *phys_pathp = Xlength(*xsp, xp);
+ if (use_cdpath && plen) {
+ XcheckN(*xsp, xp, plen);
+ memcpy(xp, plist, plen);
+ xp += plen;
+ if (plist[plen - 1] != '/')
+ Xput(*xsp, xp, '/');
+ rval = 1;
+ }
+ }
+
+ len = strlen(file) + 1;
+ XcheckN(*xsp, xp, len);
+ memcpy(xp, file, len);
+
+ if (!use_cdpath)
+ *cdpathp = NULL;
+
+ return rval;
+}
+
+/*
+ * Simplify pathnames containing "." and ".." entries.
+ * ie, simplify_path("/a/b/c/./../d/..") returns "/a/b"
+ */
+void
+simplify_path(char *path)
+{
+ char *cur;
+ char *t;
+ int isrooted;
+ char *very_start = path;
+ char *start;
+
+ if (!*path)
+ return;
+
+ if ((isrooted = (path[0] == '/')))
+ very_start++;
+
+ /* Before After
+ * /foo/ /foo
+ * /foo/../../bar /bar
+ * /foo/./blah/.. /foo
+ * . .
+ * .. ..
+ * ./foo foo
+ * foo/../../../bar ../../bar
+ */
+
+ for (cur = t = start = very_start; ; ) {
+ /* treat multiple '/'s as one '/' */
+ while (*t == '/')
+ t++;
+
+ if (*t == '\0') {
+ if (cur == path)
+ /* convert empty path to dot */
+ *cur++ = '.';
+ *cur = '\0';
+ break;
+ }
+
+ if (t[0] == '.') {
+ if (!t[1] || t[1] == '/') {
+ t += 1;
+ continue;
+ } else if (t[1] == '.' && (!t[2] || t[2] == '/')) {
+ if (!isrooted && cur == start) {
+ if (cur != very_start)
+ *cur++ = '/';
+ *cur++ = '.';
+ *cur++ = '.';
+ start = cur;
+ } else if (cur != start)
+ while (--cur > start && *cur != '/')
+ ;
+ t += 2;
+ continue;
+ }
+ }
+
+ if (cur != very_start)
+ *cur++ = '/';
+
+ /* find/copy next component of pathname */
+ while (*t && *t != '/')
+ *cur++ = *t++;
+ }
+}
+
+
+void
+set_current_wd(char *path)
+{
+ int len;
+ char *p = path;
+
+ if (!p && !(p = ksh_get_wd(NULL, 0)))
+ p = null;
+
+ len = strlen(p) + 1;
+
+ if (len > current_wd_size)
+ current_wd = aresize(current_wd, current_wd_size = len, APERM);
+ memcpy(current_wd, p, len);
+ if (p != path && p != null)
+ afree(p, ATEMP);
+}
+
+char *
+get_phys_path(const char *path)
+{
+ XString xs;
+ char *xp;
+
+ Xinit(xs, xp, strlen(path) + 1, ATEMP);
+
+ xp = do_phys_path(&xs, xp, path);
+
+ if (!xp)
+ return NULL;
+
+ if (Xlength(xs, xp) == 0)
+ Xput(xs, xp, '/');
+ Xput(xs, xp, '\0');
+
+ return Xclose(xs, xp);
+}
+
+static char *
+do_phys_path(XString *xsp, char *xp, const char *path)
+{
+ const char *p, *q;
+ int len, llen;
+ int savepos;
+ char lbuf[PATH];
+
+ Xcheck(*xsp, xp);
+ for (p = path; p; p = q) {
+ while (*p == '/')
+ p++;
+ if (!*p)
+ break;
+ len = (q = strchr(p, '/')) ? q - p : strlen(p);
+ if (len == 1 && p[0] == '.')
+ continue;
+ if (len == 2 && p[0] == '.' && p[1] == '.') {
+ while (xp > Xstring(*xsp, xp)) {
+ xp--;
+ if (*xp == '/')
+ break;
+ }
+ continue;
+ }
+
+ savepos = Xsavepos(*xsp, xp);
+ Xput(*xsp, xp, '/');
+ XcheckN(*xsp, xp, len + 1);
+ memcpy(xp, p, len);
+ xp += len;
+ *xp = '\0';
+
+ llen = readlink(Xstring(*xsp, xp), lbuf, sizeof(lbuf) - 1);
+ if (llen < 0) {
+ /* EINVAL means it wasn't a symlink... */
+ if (errno != EINVAL)
+ return NULL;
+ continue;
+ }
+ lbuf[llen] = '\0';
+
+ /* If absolute path, start from scratch.. */
+ xp = lbuf[0] == '/' ? Xstring(*xsp, xp) :
+ Xrestpos(*xsp, xp, savepos);
+ if (!(xp = do_phys_path(xsp, xp, lbuf)))
+ return NULL;
+ }
+ return xp;
+}