summaryrefslogtreecommitdiff
path: root/libc/sysdeps/linux/common/getcwd.c
diff options
context:
space:
mode:
Diffstat (limited to 'libc/sysdeps/linux/common/getcwd.c')
-rw-r--r--libc/sysdeps/linux/common/getcwd.c172
1 files changed, 172 insertions, 0 deletions
diff --git a/libc/sysdeps/linux/common/getcwd.c b/libc/sysdeps/linux/common/getcwd.c
new file mode 100644
index 000000000..1ec00a36e
--- /dev/null
+++ b/libc/sysdeps/linux/common/getcwd.c
@@ -0,0 +1,172 @@
+/* These functions find the absolute path to the current working directory. */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <string.h>
+#include <sys/syscall.h>
+
+#ifdef __NR_getcwd
+#define __NR___getcwd __NR_getcwd
+static inline _syscall2(int, __getcwd, char *, buf, unsigned long, size);
+
+char *getcwd(char *buf, int size)
+{
+ int olderrno, ret;
+ char *allocbuf;
+
+ if (size == 0) {
+ __set_errno(EINVAL);
+ return NULL;
+ }
+ if (size < 3) {
+ __set_errno(ERANGE);
+ return NULL;
+ }
+ allocbuf=NULL;
+ olderrno = errno;
+ if (buf == NULL) {
+ buf = allocbuf = malloc (size);
+ if (buf == NULL)
+ return NULL;
+ }
+ ret = __getcwd(buf, size);
+ if (ret < 0) {
+ if (allocbuf) {
+ free(allocbuf);
+ }
+ return NULL;
+ }
+ __set_errno(olderrno);
+ return buf;
+}
+#else
+
+/* If the syscall is not present, we have to walk up the
+ * directory tree till we hit the root. Now we _could_
+ * use /proc/self/cwd if /proc is mounted... That approach
+ * is left an an exercise for the reader... */
+
+
+/* Seems a few broken filesystems (like coda) don't like this */
+/* #undef FAST_DIR_SEARCH_POSSIBLE on Linux */
+
+
+/* Routine to find the step back down */
+static char *search_dir(dev_t this_dev, ino_t this_ino, char *path_buf, int path_size)
+{
+ DIR *dp;
+ struct dirent *d;
+ char *ptr;
+ int slen;
+ struct stat st;
+
+#ifdef FAST_DIR_SEARCH_POSSIBLE
+ /* The test is for ELKS lib 0.0.9, this should be fixed in the real kernel */
+ int slow_search = (sizeof(ino_t) != sizeof(d->d_ino));
+#endif
+
+ if (stat(path_buf, &st) < 0)
+ return 0;
+#ifdef FAST_DIR_SEARCH_POSSIBLE
+ if (this_dev != st.st_dev)
+ slow_search = 1;
+#endif
+
+ slen = strlen(path_buf);
+ ptr = path_buf + slen - 1;
+ if (*ptr != '/') {
+ if (slen + 2 > path_size) {
+ __set_errno(ERANGE);
+ return 0;
+ }
+ strcpy(++ptr, "/");
+ slen++;
+ }
+ slen++;
+
+ dp = opendir(path_buf);
+ if (dp == 0)
+ return 0;
+
+ while ((d = readdir(dp)) != 0) {
+#ifdef FAST_DIR_SEARCH_POSSIBLE
+ if (slow_search || this_ino == d->d_ino) {
+#endif
+ if (slen + strlen(d->d_name) > path_size) {
+ __set_errno(ERANGE);
+ return 0;
+ }
+ strcpy(ptr + 1, d->d_name);
+ if (stat(path_buf, &st) < 0)
+ continue;
+ if (st.st_ino == this_ino && st.st_dev == this_dev) {
+ closedir(dp);
+ return path_buf;
+ }
+#ifdef FAST_DIR_SEARCH_POSSIBLE
+ }
+#endif
+ }
+
+ closedir(dp);
+ __set_errno(ENOENT);
+ return 0;
+}
+
+/* Routine to go up tree */
+static char *recurser(char *path_buf, int path_size, dev_t root_dev, ino_t root_ino)
+{
+ struct stat st;
+ dev_t this_dev;
+ ino_t this_ino;
+
+ if (stat(path_buf, &st) < 0)
+ return 0;
+ this_dev = st.st_dev;
+ this_ino = st.st_ino;
+ if (this_dev == root_dev && this_ino == root_ino) {
+ strcpy(path_buf, "/");
+ return path_buf;
+ }
+ if (strlen(path_buf) + 4 > path_size) {
+ __set_errno(ERANGE);
+ return 0;
+ }
+ strcat(path_buf, "/..");
+ if (recurser(path_buf, path_size, root_dev, root_ino) == 0)
+ return 0;
+
+ return search_dir(this_dev, this_ino, path_buf, path_size);
+}
+
+
+char *getcwd(char *buf, int size)
+{
+ struct stat st;
+
+ if (size == 0) {
+ __set_errno(EINVAL);
+ return NULL;
+ }
+ if (size < 3) {
+ __set_errno(ERANGE);
+ return NULL;
+ }
+
+ if (buf == NULL) {
+ buf = malloc (size);
+ if (buf == NULL)
+ return NULL;
+ }
+
+ strcpy(buf, ".");
+ if (stat("/", &st) < 0) {
+ return NULL;
+ }
+
+ return recurser(buf, size, st.st_dev, st.st_ino);
+}
+
+#endif