Remove references to PATH_MAX macro

Since the macro PATH_MAX is not defined on every system (GNU/Hurd being
one of those who do not define it), we remove all references to this
macro. Instead, we use a buffer of arbitraty size and grow it when
needed to contain paths.

diff --git a/i3-nagbar/main.c b/i3-nagbar/main.c
index 0fa75f8e0550dc9b00dd78b84c8826179b7d69ad..952270e78e51b5502a819ba9627b0c6faab1d620 100644 (file)
--- a/i3-nagbar/main.c
+++ b/i3-nagbar/main.c
@@ -159,8 +159,9 @@ static void handle_button_release(xcb_connection_t *conn, xcb_button_release_eve
     fclose(script);
 
     char *link_path;
+    char *exe_path = get_exe_path(argv0);
     sasprintf(&link_path, "%s.nagbar_cmd", script_path);
-    symlink(get_exe_path(argv0), link_path);
+    symlink(exe_path, link_path);
 
     char *terminal_cmd;
     sasprintf(&terminal_cmd, "i3-sensible-terminal -e %s", link_path);
@@ -172,6 +173,7 @@ static void handle_button_release(xcb_connection_t *conn, xcb_button_release_eve
     free(link_path);
     free(terminal_cmd);
     free(script_path);
+    free(exe_path);
 
     /* TODO: unset flag, re-render */
 }

diff --git a/include/libi3.h b/include/libi3.h
index 9ba780042310128c0530674028cb9520f7779cc9..18c64690fef407b643f96f17c6120a55ce2ed888 100644 (file)
--- a/include/libi3.h
+++ b/include/libi3.h
@@ -372,7 +372,8 @@ char *get_process_filename(const char *prefix);
  *
  * The implementation follows http://stackoverflow.com/a/933996/712014
  *
+ * Returned value must be freed by the caller.
  */
-const char *get_exe_path(const char *argv0);
+char *get_exe_path(const char *argv0);
 
 #endif

diff --git a/libi3/get_exe_path.c b/libi3/get_exe_path.c
index fca7ba02cf5a5f3fa2787c55062b89b76ab4c0d5..e0437e5e501a727e9e26ebf8f9f4f537e12bd4b8 100644 (file)
--- a/libi3/get_exe_path.c
+++ b/libi3/get_exe_path.c
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <limits.h>
 #include <stdlib.h>
+#include <errno.h>
 
 #include "libi3.h"
 
@@ -11,10 +12,14 @@
  *
  * The implementation follows http://stackoverflow.com/a/933996/712014
  *
+ * Returned value must be freed by the caller.
  */
-const char *get_exe_path(const char *argv0) {
-       static char destpath[PATH_MAX];
-       char tmp[PATH_MAX];
+char *get_exe_path(const char *argv0) {
+       size_t destpath_size = 1024;
+       size_t tmp_size = 1024;
+       char *destpath = smalloc(destpath_size);
+       char *tmp = smalloc(tmp_size);
+
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
        /* Linux and Debian/kFreeBSD provide /proc/self/exe */
@@ -25,30 +30,48 @@ const char *get_exe_path(const char *argv0) {
 #endif
        ssize_t linksize;
 
-       if ((linksize = readlink(exepath, destpath, sizeof(destpath) - 1)) != -1) {
+       while ((linksize = readlink(exepath, destpath, destpath_size)) == destpath_size) {
+               destpath_size = destpath_size * 2;
+               destpath = srealloc(destpath, destpath_size);
+       }
+       if (linksize != -1) {
                /* readlink() does not NULL-terminate strings, so we have to. */
                destpath[linksize] = '\0';
-
+               free(tmp);
                return destpath;
        }
 #endif
 
        /* argv[0] is most likely a full path if it starts with a slash. */
-       if (argv0[0] == '/')
-               return argv0;
+       if (argv0[0] == '/') {
+               free(tmp);
+               free(destpath);
+               return sstrdup(argv0);
+       }
 
        /* if argv[0] contains a /, prepend the working directory */
-       if (strchr(argv0, '/') != NULL &&
-               getcwd(tmp, sizeof(tmp)) != NULL) {
-               snprintf(destpath, sizeof(destpath), "%s/%s", tmp, argv0);
-               return destpath;
+       if (strchr(argv0, '/') != NULL) {
+               char *retgcwd;
+               while ((retgcwd = getcwd(tmp, tmp_size)) == NULL && errno == ERANGE) {
+                       tmp_size = tmp_size * 2;
+                       tmp = srealloc(tmp, tmp_size);
+               }
+               if (retgcwd != NULL) {
+                       free(destpath);
+                       sasprintf(&destpath, "%s/%s", tmp, argv0);
+                       free(tmp);
+                       return destpath;
+               }
        }
 
        /* Fall back to searching $PATH (or _CS_PATH in absence of $PATH). */
        char *path = getenv("PATH");
        if (path == NULL) {
                /* _CS_PATH is typically something like "/bin:/usr/bin" */
-               confstr(_CS_PATH, tmp, sizeof(tmp));
+               while (confstr(_CS_PATH, tmp, tmp_size) > tmp_size) {
+                       tmp_size = tmp_size * 2;
+                       tmp = srealloc(tmp, tmp_size);
+               }
                sasprintf(&path, ":%s", tmp);
        } else {
                path = strdup(path);
@@ -59,16 +82,20 @@ const char *get_exe_path(const char *argv0) {
                if ((component = strtok(str, ":")) == NULL)
                        break;
                str = NULL;
-               snprintf(destpath, sizeof(destpath), "%s/%s", component, argv0);
+               free(destpath);
+               sasprintf(&destpath, "%s/%s", component, argv0);
                /* Of course this is not 100% equivalent to actually exec()ing the
                 * binary, but meh. */
                if (access(destpath, X_OK) == 0) {
                        free(path);
+                       free(tmp);
                        return destpath;
                }
        }
+       free(destpath);
        free(path);
+       free(tmp);
 
        /* Last resort: maybe it’s in /usr/bin? */
-       return "/usr/bin/i3-nagbar";
+       return sstrdup("/usr/bin/i3-nagbar");
 }

diff --git a/src/display_version.c b/src/display_version.c
index 5fa4f8e2234945831776b36be875b444e177de15..427c4ff7d69a52139cd755fbd1355290bd26d5c8 100644 (file)
--- a/src/display_version.c
+++ b/src/display_version.c
@@ -128,13 +128,18 @@ void display_running_version(void) {
     printf("\rRunning i3 version: %s (pid %s)\n", human_readable_version, pid_from_atom);
 
 #ifdef __linux__
-    char exepath[PATH_MAX],
-         destpath[PATH_MAX];
+    size_t destpath_size = 1024;
     ssize_t linksize;
+    char *exepath;
+    char *destpath = smalloc(destpath_size);
 
-    snprintf(exepath, sizeof(exepath), "/proc/%d/exe", getpid());
+    sasprintf(&exepath, "/proc/%d/exe", getpid());
 
-    if ((linksize = readlink(exepath, destpath, sizeof(destpath))) == -1)
+    while ((linksize = readlink(exepath, destpath, destpath_size)) == destpath_size) {
+            destpath_size = destpath_size * 2;
+            destpath = srealloc(destpath, destpath_size);
+    }
+    if (linksize == -1)
         err(EXIT_FAILURE, "readlink(%s)", exepath);
 
     /* readlink() does not NULL-terminate strings, so we have to. */
@@ -143,9 +148,14 @@ void display_running_version(void) {
     printf("\n");
     printf("The i3 binary you just called: %s\n", destpath);
 
-    snprintf(exepath, sizeof(exepath), "/proc/%s/exe", pid_from_atom);
+    free(exepath);
+    sasprintf(&exepath, "/proc/%s/exe", pid_from_atom);
 
-    if ((linksize = readlink(exepath, destpath, sizeof(destpath))) == -1)
+    while ((linksize = readlink(exepath, destpath, destpath_size)) == destpath_size) {
+        destpath_size = destpath_size * 2;
+        destpath = srealloc(destpath, destpath_size);
+    }
+    if (linksize == -1)
         err(EXIT_FAILURE, "readlink(%s)", exepath);
 
     /* readlink() does not NULL-terminate strings, so we have to. */
@@ -159,7 +169,8 @@ void display_running_version(void) {
     /* Since readlink() might put a "(deleted)" somewhere in the buffer and
      * stripping that out seems hackish and ugly, we read the process’s argv[0]
      * instead. */
-    snprintf(exepath, sizeof(exepath), "/proc/%s/cmdline", pid_from_atom);
+    free(exepath);
+    sasprintf(&exepath, "/proc/%s/cmdline", pid_from_atom);
 
     int fd;
     if ((fd = open(exepath, O_RDONLY)) == -1)
@@ -169,6 +180,9 @@ void display_running_version(void) {
     close(fd);
 
     printf("The i3 binary you are running: %s\n", destpath);
+
+    free(exepath);
+    free(destpath);
 #endif
 
     yajl_free(handle);

diff --git a/src/main.c b/src/main.c
index a20fe31b0d750515564dd33689a0e1052e0a4af1..6028e1ddf92aab87168f3f156b1967c97b78281e 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -488,18 +488,25 @@ int main(int argc, char *argv[]) {
 
         /* The following code is helpful, but not required. We thus don’t pay
          * much attention to error handling, non-linux or other edge cases. */
-        char cwd[PATH_MAX];
         LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
-        if (getcwd(cwd, sizeof(cwd)) != NULL)
+        size_t cwd_size = 1024;
+        char *cwd = smalloc(cwd_size);
+        char *cwd_ret;
+        while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
+            cwd_size = cwd_size * 2;
+            cwd = srealloc(cwd, cwd_size);
+        }
+        if (cwd_ret != NULL)
             LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
         int patternfd;
         if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
-            memset(cwd, '\0', sizeof(cwd));
-            if (read(patternfd, cwd, sizeof(cwd)) > 0)
+            memset(cwd, '\0', cwd_size);
+            if (read(patternfd, cwd, cwd_size) > 0)
                 /* a trailing newline is included in cwd */
                 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
             close(patternfd);
         }
+        free(cwd);
     }
 
     LOG("i3 " I3_VERSION " starting\n");