xargs/argmax.c

   1 /*
   2  * TODO:
   3  *      * should probably use execve() for portability
   4  */
   5
   6 #include <stdio.h>
   7
   8 #include <sys/types.h>
   9 #include <sys/wait.h>
  10 #include <unistd.h>
  11 #include <stdlib.h> /* malloc */
  12 #include <limits.h>
  13 #include <errno.h>
  14
  15
  16 #define STEPS_DEFAULT   10
  17 #define SAFETY_MARGIN   2048
  18 #define TEST_PROGRAM    "/bin/true"
  19
  20
  21 /*
  22  *
  23  * ``It is implementation‐defined whether null terminators, pointers, and/or any
  24  * alignment bytes are included in this total.''
  25  *      -- IEEE Std 1003.1‐2003 on ARG_MAX
  26  *
  27  * http://www.in-ulm.de/~mascheck/various/argmax/
  28  *
  29  */
  30
  31 #define FUZZ 4
  32
  33 #include <string.h> /* temp: strnlen */
  34
  35 static int test_maxsize_binary()
  36 {
  37     const long sys_arg_max = sysconf(_SC_ARG_MAX);
  38     char* testarg = malloc(sys_arg_max);
  39     int n = (sys_arg_max-1)/2;
  40     int i;
  41
  42     for (i=sys_arg_max; i>=0; --i)
  43         testarg[i] = 1;
  44     testarg[n] = 0;
  45
  46     i=0;
  47
  48     //printf("ARG_MAX: %d\n", sys_arg_max);
  49     //printf("testarg@%p\n", testarg);
  50
  51     while (n > 0)
  52     {
  53         printf("strlen: %d\n", strnlen(testarg, sys_arg_max));
  54         ++i;
  55
  56         if (fork() == 0)
  57         {
  58             /* child */
  59             execl("/bin/true", testarg, (char*)NULL);
  60
  61             exit(errno);
  62         }
  63         else
  64         {
  65             /* parent */
  66             int status;
  67
  68             wait(&status);
  69
  70             switch (WEXITSTATUS(status))
  71             {
  72                 case 0:         /* worked */
  73                     printf("current fuzz: %d\n", n*0.5);
  74                     if (n*0.5 < FUZZ)
  75                     {
  76                         printf("%d iterations\n", i);
  77                         return(n);
  78                     }
  79                     printf("worked, n=%d/%f\n", n, n*1.5);
  80                     testarg[n] = 1;
  81 #define MIN(x,y) (x<y?x:y)
  82                     n = MIN(1.5*n, sys_arg_max-1);
  83                     testarg[n] = 0;
  84                     break;
  85
  86                 case E2BIG:     /* argument list too long */
  87                     printf("E2BIG, n=%d/%d\n", n, n*0.5);
  88                     n *= 0.5;
  89                     testarg[n] = 0;
  90                     break;
  91
  92                 default:        /* other error */
  93                     fprintf(stderr, "WARNING: child encountered unexpected error: %s\n",
  94                             strerror(WEXITSTATUS(status)));
  95             }
  96         }
  97     }
  98
  99     return 0; /* NEVER REACHED */
 100 }
 101
 102 static int test_maxsize_linear()
 103 {
 104     const long sys_arg_max = sysconf(_SC_ARG_MAX);
 105     char* testarg = malloc(sys_arg_max);
 106     int n = sys_arg_max-1;
 107     int i;
 108
 109     for (i=n; i>=0; --i)
 110         testarg[i] = 1;
 111     testarg[n] = 0;
 112
 113     while (n > 0)
 114     {
 115         if (fork() == 0)
 116         {
 117             /* child */
 118             execl("/bin/true", testarg, (char*)NULL);
 119
 120             exit(errno);
 121         }
 122         else
 123         {
 124             /* parent */
 125             int status;
 126
 127             wait(&status);
 128
 129             switch (WEXITSTATUS(status))
 130             {
 131                 case 0:         /* worked */
 132                     printf("%d iterations\n", sys_arg_max-n);
 133                     return(n);
 134                     break;
 135
 136                 case E2BIG:     /* argument list too long */
 137                     testarg[--n] = 0;
 138                     break;
 139
 140                 default:        /* other error */
 141                     fprintf(stderr, "WARNING: child encountered unexpected error: %s\n",
 142                             strerror(WEXITSTATUS(status)));
 143             }
 144         }
 145     }
 146
 147     return 0; /* NEVER REACHED */
 148 }
 149
 150
 151 /* binary search */
 152 static int
 153 argmax_binary(int steps)
 154 {
 155     if (steps == 0)
 156         steps = STEPS_DEFAULT;
 157
 158     return 0;
 159 }
 160
 161
 162 static int
 163 argmax_calc()
 164 {
 165     return 0;
 166 }
 167
 168
 169 static int
 170 argnum_binary()
 171 {
 172     return 0;
 173 }
 174
 175
 176 int
 177 main(int ac, char** av, char** env)
 178 {
 179 //    printf("maximum size of args (linear search): %d\n", test_maxsize_linear());
 180     printf("maximum size of args (binary search): %d\n", test_maxsize_binary());
 181     //printf("maximum size of args: %d\n", test_maxsize_linear());
 182 //printf("maximum number of args: %d\n", test_maxnum_linear());
 183     return 0;
 184 }
 185