Get ARG_MAX/PATH_MAX from sysconf/pathconf instead of linux/limits.h

To avoid depending on kernel-related headers when it can be avoided.

Note: This means that the values are obtained at run-time rather than at
compile-time, but they should not change during runtime.  From
POSIX.1-2017's sysconf(3p):

> This runtime facility is not meant to provide ever-changing values
> that applications have to check multiple times.  The values are seen
> as changing no more frequently than once per system initialization,
> such as by a system administrator or operator with an automatic
> configuration program.  This volume of POSIX.1‐2017 specifies that
> they shall not change within the lifetime of the process.
>
> Some values apply to the system overall and others vary at the file
> system or directory level.  The latter are described in fpathconf().

Also, use (f)pathconf because (as noted above) PATH_MAX depends on the
filesystem of the path in question.  From POSIX.1-2017's
fpathconf(3p)[2]:

> The pathconf() function was proposed immediately after the sysconf()
> function when it was realized that some configurable values may differ
> across file system, directory, or de‐ vice boundaries.
>
> For example, {NAME_MAX} frequently changes between System V and
> BSD-based file systems; System V uses a maximum of 14, BSD 255.  On an
> implementation that provides both types of file systems, an
> application would be forced to limit all pathname components to 14
> bytes, as this would be the value specified in <limits.h> on such a
> system.
>
> Therefore, various useful values can be queried on any pathname or
> file descriptor, assuming that appropriate privileges are in place.

Note2: This is not done for all files, as on libtrace.c the macro value
is used to define an array size and on firejail.h the value is used in
another macro.

[1] https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html
[2] https://pubs.opengroup.org/onlinepubs/9699919799/functions/fpathconf.html

src/firejail/cmdline.c

@@ -22,9 +22,9 @@
 #include <string.h>
 #include <stdbool.h>
 #include <stdio.h>
-#include <linux/limits.h>
 #include <assert.h>
 #include <errno.h>
+#include <unistd.h>
 
 static int cmdline_length(int argc, char **argv, int index, bool want_extra_quotes) {
  assert(index != -1);
@@ -140,9 +140,13 @@ void build_cmdline(char **command_line, char **window_title, int argc, char **ar
  // index == -1 could happen if we have --shell=none and no program was specified
  // the program should exit with an error before entering this function
  assert(index != -1);
+ errno = 0;
+ long arg_max = sysconf(_SC_ARG_MAX);
+ if (arg_max == -1 && errno != 0)
+ errExit("sysconf ARG_MAX");
 
  int len = cmdline_length(argc, argv, index, want_extra_quotes);
- if (len > ARG_MAX) {
+ if (len > arg_max) {
  errno = E2BIG;
  errExit("cmdline_length");
  }
@@ -167,6 +171,10 @@ void build_appimage_cmdline(char **command_line, char **window_title, int argc,
  // index == -1 could happen if we have --shell=none and no program was specified
  // the program should exit with an error before entering this function
  assert(index != -1);
+ errno = 0;
+ long arg_max = sysconf(_SC_ARG_MAX);
+ if (arg_max == -1 && errno != 0)
+ errExit("sysconf ARG_MAX");
 
  char *apprun_path = RUN_FIREJAIL_APPIMAGE_DIR "/AppRun";
 
@@ -175,7 +183,7 @@ void build_appimage_cmdline(char **command_line, char **window_title, int argc,
  int len3 = cmdline_length(1, &apprun_path, 0, want_extra_quotes); // /run/firejail/appimage/AppRun
  int len4 = (len1 - len2 + len3) + 1; // apptest.AppImage is replaced by /path/to/AppRun
 
- if (len4 > ARG_MAX) {
+ if (len4 > arg_max) {
  errno = E2BIG;
  errExit("cmdline_length");
  }

src/libtracelog/libtracelog.c

@@ -31,7 +31,7 @@
 #include <sys/stat.h>
 #include <syslog.h>
 #include <dirent.h>
-#include <linux/limits.h>
+#include <errno.h>
 #include "../include/rundefs.h"
 
 //#define DEBUG
@@ -114,12 +114,18 @@ static char *storage_find(const char *str) {
 
  if (strstr(str, "..") || strstr(str, "/./") || strstr(str, "//") || str[0] != '/') {
  if (cwd != NULL && str[0] != '/') {
- char *fullpath=malloc(PATH_MAX);
+ errno = 0;
+ long path_max = pathconf(cwd, _PC_PATH_MAX);
+ if (path_max == -1 && errno != 0) {
+ fprintf(stderr, "Error: cannot get PATH_MAX for %s\n", cwd);
+ return NULL;
+ }
+ char *fullpath = malloc(path_max);
  if (!fullpath) {
  fprintf(stderr, "Error: cannot allocate memory\n");
  return NULL;
  }
- if (snprintf(fullpath, PATH_MAX, "%s/%s", cwd, str)<3) {
+ if (snprintf(fullpath, path_max, "%s/%s", cwd, str) < 3) {
  fprintf(stderr, "Error: snprintf failed\n");
  free(fullpath);
  return NULL;
@@ -689,20 +695,32 @@ int fchdir(int fd) {
  orig_fchdir = (orig_fchdir_t)dlsym(RTLD_NEXT, "fchdir");
 
  free(cwd);
- char *pathname=malloc(PATH_MAX);
- if (pathname) {
- if (snprintf(pathname,PATH_MAX,"/proc/self/fd/%d", fd)>0) {
- cwd = realpath(pathname, NULL);
- } else {
- cwd = NULL;
- fprintf(stderr, "Error: snprintf failed\n");
- }
- free(pathname);
- } else {
+
+ const char *fddir = "/proc/self/fd";
+ errno = 0;
+ long path_max = pathconf(fddir, _PC_PATH_MAX);
+ if (path_max == -1 && errno != 0) {
+ fprintf(stderr, "Error: cannot get PATH_MAX for %s\n", fddir);
+ cwd = NULL;
+ goto ret;
+ }
+
+ char *pathname = malloc(path_max);
+ if (!pathname) {
  fprintf(stderr, "Error: cannot allocate memory\n");
  cwd = NULL;
+ goto ret;
+ }
+
+ if (snprintf(pathname, path_max, "%s/%d", fddir, fd) > 0) {
+ cwd = realpath(pathname, NULL);
+ } else {
+ cwd = NULL;
+ fprintf(stderr, "Error: snprintf failed\n");
  }
+ free(pathname);
 
+ret:;
  int rv = orig_fchdir(fd);
  return rv;
 }