fcgi_config.c

   1 /*
   2  * $Id: fcgi_config.c,v 1.41 2002/10/18 02:20:09 robs Exp $
   3  */
   4
   5 #define CORE_PRIVATE
   6 #include "fcgi.h"
   7
   8 #ifdef APACHE2
   9
  10 #include <limits.h>
  11 #include "mpm_common.h"     /* ap_uname2id, ap_gname2id */
  12
  13 #ifdef WIN32
  14 #include <direct.h>
  15 #else
  16 #include <unistd.h>
  17 #include "unixd.h"
  18 #endif
  19
  20 #endif
  21
  22 #ifdef WIN32
  23 /* warning C4100: unreferenced formal parameter */
  24 /* warning C4706: assignment within conditional expression */
  25 #pragma warning( disable : 4100 4706 )
  26 #endif
  27
  28 /*******************************************************************************
  29  * Get the next configuration directive argument, & return an in_addr and port.
  30  * The arg must be in the form "host:port" where host can be an IP or hostname.
  31  * The pool arg should be persistant storage.
  32  */
  33 static const char *get_host_n_port(pool *p, const char **arg,
  34         const char **host, u_short *port)
  35 {
  36     char *cvptr, *portStr;
  37     long tmp;
  38
  39     *host = ap_getword_conf(p, arg);
  40     if (**host == '\0')
  41         return "\"\"";
  42
  43     portStr = strchr(*host, ':');
  44     if (portStr == NULL)
  45         return "missing port specification";
  46
  47     /* Split the host and port portions */
  48     *portStr++ = '\0';
  49
  50     /* Convert port number */
  51     tmp = (u_short) strtol(portStr, &cvptr, 10);
  52     if (*cvptr != '\0' || tmp < 1 || tmp > USHRT_MAX)
  53         return ap_pstrcat(p, "bad port number \"", portStr, "\"", NULL);
  54
  55     *port = (unsigned short) tmp;
  56
  57     return NULL;
  58 }
  59 \f
  60 /*******************************************************************************
  61  * Get the next configuration directive argument, & return an u_short.
  62  * The pool arg should be temporary storage.
  63  */
  64 static const char *get_u_short(pool *p, const char **arg,
  65         u_short *num, u_short min)
  66 {
  67     char *ptr;
  68         long tmp;
  69     const char *txt = ap_getword_conf(p, arg);
  70
  71     if (*txt == '\0') {
  72                 return "\"\"";
  73         }
  74
  75     tmp = strtol(txt, &ptr, 10);
  76
  77     if (*ptr != '\0') {
  78         return ap_pstrcat(p, "\"", txt, "\" must be a positive integer", NULL);
  79         }
  80
  81         if (tmp < min || tmp > USHRT_MAX) {
  82         return ap_psprintf(p, "\"%u\" must be >= %u and < %u", *num, min, USHRT_MAX);
  83         }
  84
  85         *num = (u_short) tmp;
  86
  87     return NULL;
  88 }
  89
  90 static const char *get_int(pool *p, const char **arg, int *num, int min)
  91 {
  92     char *cp;
  93     const char *val = ap_getword_conf(p, arg);
  94
  95     if (*val == '\0')
  96     {
  97         return "\"\"";
  98     }
  99
 100     *num = (int) strtol(val, &cp, 10);
 101
 102     if (*cp != '\0')
 103     {
 104         return ap_pstrcat(p, "can't parse ", "\"", val, "\"", NULL);
 105     }
 106     else if (*num < min)
 107     {
 108         return ap_psprintf(p, "\"%d\" must be >= %d", *num, min);
 109     }
 110
 111     return NULL;
 112 }
 113
 114 /*******************************************************************************
 115  * Get the next configuration directive argument, & return an u_int.
 116  * The pool arg should be temporary storage.
 117  */
 118 static const char *get_u_int(pool *p, const char **arg,
 119         u_int *num, u_int min)
 120 {
 121     char *ptr;
 122     const char *val = ap_getword_conf(p, arg);
 123
 124     if (*val == '\0')
 125         return "\"\"";
 126     *num = (u_int)strtol(val, &ptr, 10);
 127
 128     if (*ptr != '\0')
 129         return ap_pstrcat(p, "\"", val, "\" must be a positive integer", NULL);
 130     else if (*num < min)
 131         return ap_psprintf(p, "\"%u\" must be >= %u", *num, min);
 132     return NULL;
 133 }
 134
 135 /*******************************************************************************
 136  * Get the next configuration directive argument, & return a float.
 137  * The pool arg should be temporary storage.
 138  */
 139 static const char *get_float(pool *p, const char **arg,
 140         float *num, float min, float max)
 141 {
 142     char *ptr;
 143     const char *val = ap_getword_conf(p, arg);
 144
 145     if (*val == '\0')
 146         return "\"\"";
 147     *num = (float) strtod(val, &ptr);
 148
 149     if (*ptr != '\0')
 150         return ap_pstrcat(p, "\"", val, "\" is not a floating point number", NULL);
 151     if (*num < min || *num > max)
 152         return ap_psprintf(p, "\"%f\" is not between %f and %f", *num, min, max);
 153     return NULL;
 154 }
 155
 156 const char *fcgi_config_set_env_var(pool *p, char **envp, unsigned int *envc, char * var)
 157 {
 158     if (*envc >= MAX_INIT_ENV_VARS) {
 159         return "too many variables, must be <= MAX_INIT_ENV_VARS";
 160     }
 161
 162     if (strchr(var, '=') == NULL) {
 163         *(envp + *envc) = ap_pstrcat(p, var, "=", getenv(var), NULL);
 164     }
 165     else {
 166         *(envp + *envc) = var;
 167     }
 168
 169     (*envc)++;
 170
 171     return NULL;
 172 }
 173
 174 /*******************************************************************************
 175  * Get the next configuration directive argument, & add it to an env array.
 176  * The pool arg should be permanent storage.
 177  */
 178 static const char *get_env_var(pool *p, const char **arg, char **envp, unsigned int *envc)
 179 {
 180     char * const val = ap_getword_conf(p, arg);
 181
 182     if (*val == '\0') {
 183         return "\"\"";
 184     }
 185
 186     return fcgi_config_set_env_var(p, envp, envc, val);
 187 }
 188
 189 static const char *get_pass_header(pool *p, const char **arg, array_header **array)
 190 {
 191     const char **header;
 192
 193     if (!*array) {
 194         *array = ap_make_array(p, 10, sizeof(char*));
 195     }
 196
 197     header = (const char **)ap_push_array(*array);
 198     *header = ap_getword_conf(p, arg);
 199
 200     return header ? NULL : "\"\"";
 201 }
 202
 203 /*******************************************************************************
 204  * Return a "standard" message for common configuration errors.
 205  */
 206 static const char *invalid_value(pool *p, const char *cmd, const char *id,
 207         const char *opt, const char *err)
 208 {
 209     return ap_psprintf(p, "%s%s%s: invalid value for %s: %s",
 210                     cmd, id ? " " : "", id ? id : "",  opt, err);
 211 }
 212
 213 /*******************************************************************************
 214  * Set/Reset the uid/gid that Apache and the PM will run as.  This is ap_user_id
 215  * and ap_group_id if we're started as root, and euid/egid otherwise.  Also try
 216  * to check that the config files don't set the User/Group after a FastCGI
 217  * directive is used that depends on it.
 218  */
 219 /*@@@ To be complete, we should save a handle to the server each AppClass is
 220  * configured in and at init() check that the user/group is still what we
 221  * thought it was.  Also the other directives should only be allowed in the
 222  * parent Apache server.
 223  */
 224 const char *fcgi_config_set_fcgi_uid_n_gid(int set)
 225 {
 226     static int isSet = 0;
 227
 228 #ifndef WIN32
 229
 230     uid_t uid = geteuid();
 231     gid_t gid = getegid();
 232
 233     if (set == 0) {
 234         isSet = 0;
 235         fcgi_user_id = (uid_t)-1;
 236         fcgi_group_id = (gid_t)-1;
 237         return NULL;
 238     }
 239
 240     if (uid == 0) {
 241         uid = ap_user_id;
 242     }
 243
 244     if (gid == 0) {
 245         gid = ap_group_id;
 246     }
 247
 248     if (isSet && (uid != fcgi_user_id || gid != fcgi_group_id)) {
 249         return "User/Group commands must preceed FastCGI server definitions";
 250     }
 251
 252     isSet = 1;
 253     fcgi_user_id = uid;
 254     fcgi_group_id = gid;
 255
 256 #endif /* !WIN32 */
 257
 258     return NULL;
 259 }
 260
 261 apcb_t fcgi_config_reset_globals(void* dummy)
 262 {
 263     fcgi_config_pool = NULL;
 264     fcgi_servers = NULL;
 265     fcgi_config_set_fcgi_uid_n_gid(0);
 266     fcgi_wrapper = NULL;
 267     fcgi_socket_dir = NULL;
 268
 269     fcgi_dynamic_total_proc_count = 0;
 270     fcgi_dynamic_epoch = 0;
 271     fcgi_dynamic_last_analyzed = 0;
 272
 273     dynamicMaxProcs = FCGI_DEFAULT_MAX_PROCS;
 274     dynamicMinProcs = FCGI_DEFAULT_MIN_PROCS;
 275     dynamicMaxClassProcs = FCGI_DEFAULT_MAX_CLASS_PROCS;
 276     dynamicKillInterval = FCGI_DEFAULT_KILL_INTERVAL;
 277     dynamicUpdateInterval = FCGI_DEFAULT_UPDATE_INTERVAL;
 278     dynamicGain = FCGI_DEFAULT_GAIN;
 279     dynamicThreshold1 = FCGI_DEFAULT_THRESHOLD_1;
 280     dynamicThresholdN = FCGI_DEFAULT_THRESHOLD_N;
 281     dynamicPleaseStartDelay = FCGI_DEFAULT_START_PROCESS_DELAY;
 282     dynamicAppConnectTimeout = FCGI_DEFAULT_APP_CONN_TIMEOUT;
 283     dynamicEnvp = &fcgi_empty_env;
 284     dynamicProcessSlack = FCGI_DEFAULT_PROCESS_SLACK;
 285     dynamicAutoRestart = FCGI_DEFAULT_RESTART_DYNAMIC;
 286     dynamicAutoUpdate = FCGI_DEFAULT_AUTOUPDATE;
 287     dynamicListenQueueDepth = FCGI_DEFAULT_LISTEN_Q;
 288     dynamicInitStartDelay = DEFAULT_INIT_START_DELAY;
 289     dynamicRestartDelay = FCGI_DEFAULT_RESTART_DELAY;
 290     dynamic_pass_headers = NULL;
 291     dynamic_idle_timeout = FCGI_DEFAULT_IDLE_TIMEOUT;
 292         dynamicFlush = FCGI_FLUSH;
 293
 294 #ifndef WIN32
 295         /* Close any old pipe (HUP/USR1) */
 296         if (fcgi_pm_pipe[0] != -1) {
 297                 close(fcgi_pm_pipe[0]);
 298                 fcgi_pm_pipe[0] = -1;
 299         }
 300         if (fcgi_pm_pipe[1] != -1) {
 301                 close(fcgi_pm_pipe[1]);
 302                 fcgi_pm_pipe[1] = -1;
 303         }
 304 #endif
 305
 306     return APCB_OK;
 307 }
 308
 309 /*******************************************************************************
 310  * Create a directory to hold Unix/Domain sockets.
 311  */
 312 const char *fcgi_config_make_dir(pool *tp, char *path)
 313 {
 314     struct stat finfo;
 315     const char *err = NULL;
 316
 317     /* Is the directory spec'd correctly */
 318     if (*path != '/') {
 319         return "path is not absolute (it must start with a \"/\")";
 320     }
 321     else {
 322         int i = strlen(path) - 1;
 323
 324         /* Strip trailing "/"s */
 325         while(i > 0 && path[i] == '/') path[i--] = '\0';
 326     }
 327
 328     /* Does it exist? */
 329     if (stat(path, &finfo) != 0) {
 330         /* No, but maybe we can create it */
 331 #ifdef WIN32
 332         if (mkdir(path) != 0)
 333 #else
 334         if (mkdir(path, S_IRWXU) != 0)
 335 #endif
 336         {
 337             return ap_psprintf(tp,
 338                 "doesn't exist and can't be created: %s",
 339                 strerror(errno));
 340         }
 341
 342 #ifndef WIN32
 343         /* If we're root, we're gonna setuid/setgid so we need to chown */
 344         if (geteuid() == 0 && chown(path, ap_user_id, ap_group_id) != 0) {
 345             return ap_psprintf(tp,
 346                 "can't chown() to the server (uid %ld, gid %ld): %s",
 347                 (long)ap_user_id, (long)ap_group_id, strerror(errno));
 348         }
 349 #endif
 350     }
 351     else {
 352         /* Yes, is it a directory? */
 353         if (!S_ISDIR(finfo.st_mode))
 354             return "isn't a directory!";
 355
 356         /* Can we RWX in there? */
 357 #ifdef WIN32
 358         err = fcgi_util_check_access(tp, NULL, &finfo, _S_IREAD | _S_IWRITE | _S_IEXEC, fcgi_user_id, fcgi_group_id);
 359 #else
 360         err = fcgi_util_check_access(tp, NULL, &finfo, R_OK | W_OK | X_OK,
 361                           fcgi_user_id, fcgi_group_id);
 362 #endif
 363         if (err != NULL) {
 364             return ap_psprintf(tp,
 365                 "access for server (uid %ld, gid %ld) failed: %s",
 366                 (long)fcgi_user_id, (long)fcgi_group_id, err);
 367         }
 368     }
 369     return NULL;
 370 }
 371
 372 /*******************************************************************************
 373  * Create a "dynamic" subdirectory.  If the directory
 374  * already exists we don't mess with it unless 'wax' is set.
 375  */
 376 #ifndef WIN32
 377 const char *fcgi_config_make_dynamic_dir(pool *p, const int wax)
 378 {
 379     const char *err;
 380     pool *tp;
 381
 382     fcgi_dynamic_dir = ap_pstrcat(p, fcgi_socket_dir, "/dynamic", NULL);
 383
 384     if ((err = fcgi_config_make_dir(p, fcgi_dynamic_dir)))
 385         return ap_psprintf(p, "can't create dynamic directory \"%s\": %s", fcgi_dynamic_dir, err);
 386
 387     /* Don't step on a running server unless its OK. */
 388     if (!wax)
 389         return NULL;
 390
 391 #ifdef APACHE2
 392     {
 393         apr_dir_t * dir;
 394         apr_finfo_t finfo;
 395
 396         if (apr_pool_create(&tp, p))
 397             return "apr_pool_create() failed";
 398
 399         if (apr_dir_open(&dir, fcgi_dynamic_dir, tp))
 400             return "apr_dir_open() failed";
 401
 402         /* delete the contents */
 403
 404         while (apr_dir_read(&finfo, APR_FINFO_NAME, dir) == APR_SUCCESS)
 405         {
 406             if (strcmp(finfo.name, ".") == 0 || strcmp(finfo.name, "..") == 0)
 407                 continue;
 408
 409             apr_file_remove(finfo.name, tp);
 410         }
 411     }
 412
 413 #else /* !APACHE2 */
 414     {
 415         DIR *dp;
 416         struct dirent *dirp = NULL;
 417
 418         tp = ap_make_sub_pool(p);
 419
 420         dp = ap_popendir(tp, fcgi_dynamic_dir);
 421         if (dp == NULL) {
 422             ap_destroy_pool(tp);
 423             return ap_psprintf(p, "can't open dynamic directory \"%s\": %s",
 424                 fcgi_dynamic_dir, strerror(errno));
 425         }
 426
 427         /* delete the contents */
 428
 429         while ((dirp = readdir(dp)) != NULL)
 430         {
 431             if (strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0)
 432                 continue;
 433
 434             unlink(ap_pstrcat(tp, fcgi_dynamic_dir, "/", dirp->d_name, NULL));
 435         }
 436     }
 437
 438 #endif /* !APACHE2 */
 439
 440     ap_destroy_pool(tp);
 441
 442     return NULL;
 443 }
 444 #endif
 445
 446 /*******************************************************************************
 447  * Change the directory used for the Unix/Domain sockets from the default.
 448  * Create the directory and the "dynamic" subdirectory.
 449  */
 450 const char *fcgi_config_set_socket_dir(cmd_parms *cmd, void *dummy, const char *arg)
 451 {
 452     pool * const tp = cmd->temp_pool;
 453     const char * const name = cmd->cmd->name;
 454     const char *err;
 455     char * arg_nc;
 456
 457     if (fcgi_socket_dir) {
 458         return ap_psprintf(tp, "%s %s: already defined as \"%s\"",
 459                         name, arg, fcgi_socket_dir);
 460     }
 461
 462     err = fcgi_config_set_fcgi_uid_n_gid(1);
 463     if (err != NULL)
 464         return ap_psprintf(tp, "%s %s: %s", name, arg, err);
 465
 466     if (fcgi_servers != NULL) {
 467         return ap_psprintf(tp,
 468             "The %s command must preceed static FastCGI server definitions",
 469             name);
 470     }
 471
 472     arg_nc = ap_pstrdup(cmd->pool, arg);
 473
 474 #ifndef WIN32
 475
 476 #ifdef APACHE2
 477     if (apr_filepath_merge(&arg_nc, "", arg, 0, cmd->pool))
 478         return ap_psprintf(tp, "%s %s: invalid filepath", name, arg);
 479 #else
 480     arg_nc = ap_os_canonical_filename(cmd->pool, arg_nc);
 481 #endif
 482
 483     arg_nc = ap_server_root_relative(cmd->pool, arg_nc);
 484
 485 #else /* WIN32 */
 486
 487         if (strncmp(arg_nc, "\\\\.\\pipe\\", 9) != 0)
 488                 return ap_psprintf(tp, "%s %s is invalid format",name, arg_nc);
 489
 490 #endif
 491
 492     fcgi_socket_dir = arg_nc;
 493
 494 #ifdef WIN32
 495     fcgi_dynamic_dir = ap_pstrcat(cmd->pool, fcgi_socket_dir, "dynamic", NULL);
 496 #else
 497     err = fcgi_config_make_dir(tp, fcgi_socket_dir);
 498     if (err != NULL)
 499         return ap_psprintf(tp, "%s %s: %s", name, arg_nc, err);
 500
 501     err = fcgi_config_make_dynamic_dir(cmd->pool, 0);
 502     if (err != NULL)
 503         return ap_psprintf(tp, "%s %s: %s", name, arg_nc, err);
 504 #endif
 505
 506     return NULL;
 507 }
 508 \f
 509 /*******************************************************************************
 510  * Enable, disable, or specify the path to a wrapper used to invoke all
 511  * FastCGI applications.
 512  */
 513 const char *fcgi_config_set_wrapper(cmd_parms *cmd, void *dummy, const char *arg)
 514 {
 515 #ifdef WIN32
 516     return ap_psprintf(cmd->temp_pool,
 517         "the %s directive is not supported on WIN", cmd->cmd->name);
 518 #else
 519
 520     const char *err = NULL;
 521     const char * const name = cmd->cmd->name;
 522     pool * const tp = cmd->temp_pool;
 523     char * wrapper;
 524
 525     if (!ap_suexec_enabled && strcasecmp(arg, "On") == 0) {
 526         fprintf(stderr, "Warning: \"%s On\" requires SUEXEC be enabled in Apache", name);
 527         return NULL;
 528     }
 529
 530     err = fcgi_config_set_fcgi_uid_n_gid(1);
 531     if (err != NULL)
 532         return ap_psprintf(tp, "%s %s: %s", name, arg, err);
 533
 534     if (fcgi_servers != NULL) {
 535         return ap_psprintf(tp,
 536             "The %s command must preceed static FastCGI server definitions", name);
 537     }
 538
 539     if (strcasecmp(arg, "On") == 0) {
 540         fcgi_wrapper = SUEXEC_BIN;
 541     }
 542     else if (strcasecmp(arg, "Off") == 0) {
 543         fcgi_wrapper = NULL;
 544     }
 545     else {
 546 #ifdef APACHE2
 547     if (apr_filepath_merge((char **) &arg, "", arg, 0, cmd->pool))
 548         return ap_psprintf(tp, "%s %s: invalid filepath", name, arg);
 549 #else
 550         wrapper = ap_os_canonical_filename(cmd->pool, (char *) arg);
 551 #endif
 552
 553         wrapper = ap_server_root_relative(cmd->pool, wrapper);
 554
 555         err = fcgi_util_check_access(tp, wrapper, NULL, X_OK, fcgi_user_id, fcgi_group_id);
 556
 557         if (err != NULL) {
 558             return ap_psprintf(tp,
 559                 "%s: \"%s\" access for server (uid %ld, gid %ld) failed: %s",
 560                 name, wrapper, (long)fcgi_user_id, (long)fcgi_group_id, err);
 561         }
 562
 563         fcgi_wrapper = wrapper;
 564     }
 565     return NULL;
 566 #endif /* !WIN32 */
 567 }
 568
 569 /*******************************************************************************
 570  * Configure a static FastCGI server.
 571  */
 572 const char *fcgi_config_new_static_server(cmd_parms *cmd, void *dummy, const char *arg)
 573 {
 574     fcgi_server *s;
 575     pool *p = cmd->pool, *tp = cmd->temp_pool;
 576     const char *name = cmd->cmd->name;
 577     char *fs_path = ap_getword_conf(p, &arg);
 578     const char *option, *err;
 579
 580     /* Allocate temp storage for the array of initial environment variables */
 581     char **envp = ap_pcalloc(tp, sizeof(char *) * (MAX_INIT_ENV_VARS + 3));
 582     unsigned int envc = 0;
 583
 584 #ifdef WIN32
 585     HANDLE mutex;
 586 #endif
 587
 588     if (*fs_path == '\0')
 589         return "AppClass requires a pathname!?";
 590
 591     if ((err = fcgi_config_set_fcgi_uid_n_gid(1)) != NULL)
 592         return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 593
 594 #ifdef APACHE2
 595     if (apr_filepath_merge(&fs_path, "", fs_path, 0, p))
 596         return ap_psprintf(tp, "%s %s: invalid filepath", name, fs_path);
 597 #else
 598     fs_path = ap_os_canonical_filename(p, fs_path);
 599 #endif
 600     fs_path = ap_server_root_relative(p, fs_path);
 601
 602     ap_getparents(fs_path);
 603     ap_no2slash(fs_path);
 604
 605     /* See if we've already got one of these configured */
 606     s = fcgi_util_fs_get_by_id(fs_path, fcgi_util_get_server_uid(cmd->server),
 607                                fcgi_util_get_server_gid(cmd->server));
 608     if (s != NULL) {
 609         if (fcgi_wrapper) {
 610             return ap_psprintf(tp,
 611                 "%s: redefinition of a previously defined FastCGI "
 612                 "server \"%s\" with uid=%ld and gid=%ld",
 613                 name, fs_path, (long) fcgi_util_get_server_uid(cmd->server),
 614                 (long) fcgi_util_get_server_gid(cmd->server));
 615         }
 616         else {
 617             return ap_psprintf(tp,
 618                 "%s: redefinition of a previously defined FastCGI server \"%s\"",
 619                 name, fs_path);
 620         }
 621     }
 622
 623     err = fcgi_util_fs_is_path_ok(tp, fs_path, NULL);
 624     if (err != NULL) {
 625         return ap_psprintf(tp, "%s: \"%s\" %s", name, fs_path, err);
 626     }
 627
 628     s = fcgi_util_fs_new(p);
 629     s->fs_path = fs_path;
 630     s->directive = APP_CLASS_STANDARD;
 631     s->restartOnExit = TRUE;
 632     s->numProcesses = 1;
 633
 634 #ifdef WIN32
 635
 636     // TCP FastCGI applications require SystemRoot be present in the environment
 637     // Put it in both for consistency to the application
 638     fcgi_config_set_env_var(tp, envp, &envc, "SystemRoot");
 639
 640     mutex = CreateMutex(NULL, FALSE, fs_path);
 641
 642     if (mutex == NULL)
 643     {
 644         ap_log_error(FCGI_LOG_ALERT, fcgi_apache_main_server,
 645             "FastCGI: CreateMutex() failed");
 646         return "failed to create FastCGI application accept mutex";
 647     }
 648
 649     SetHandleInformation(mutex, HANDLE_FLAG_INHERIT, TRUE);
 650
 651     s->mutex_env_string = ap_psprintf(p, "_FCGI_MUTEX_=%ld", mutex);
 652
 653 #endif
 654
 655     /*  Parse directive arguments */
 656     while (*arg) {
 657         option = ap_getword_conf(tp, &arg);
 658
 659         if (strcasecmp(option, "-processes") == 0) {
 660             if ((err = get_u_int(tp, &arg, &s->numProcesses, 1)))
 661                 return invalid_value(tp, name, fs_path, option, err);
 662         }
 663         else if (strcasecmp(option, "-restart-delay") == 0) {
 664             if ((err = get_u_int(tp, &arg, &s->restartDelay, 0)))
 665                 return invalid_value(tp, name, fs_path, option, err);
 666         }
 667         else if (strcasecmp(option, "-init-start-delay") == 0) {
 668             if ((err = get_int(tp, &arg, &s->initStartDelay, 0)))
 669                 return invalid_value(tp, name, fs_path, option, err);
 670         }
 671         else if (strcasecmp(option, "-priority") == 0) {
 672             if ((err = get_u_int(tp, &arg, &s->processPriority, 0)))
 673                 return invalid_value(tp, name, fs_path, option, err);
 674         }
 675         else if (strcasecmp(option, "-listen-queue-depth") == 0) {
 676             if ((err = get_u_int(tp, &arg, &s->listenQueueDepth, 1)))
 677                 return invalid_value(tp, name, fs_path, option, err);
 678         }
 679         else if (strcasecmp(option, "-appConnTimeout") == 0) {
 680             if ((err = get_u_int(tp, &arg, &s->appConnectTimeout, 0)))
 681                 return invalid_value(tp, name, fs_path, option, err);
 682         }
 683         else if (strcasecmp(option, "-idle-timeout") == 0) {
 684             if ((err = get_u_int(tp, &arg, &s->idle_timeout, 1)))
 685                 return invalid_value(tp, name, fs_path, option, err);
 686         }
 687         else if (strcasecmp(option, "-port") == 0) {
 688             if ((err = get_u_short(tp, &arg, &s->port, 1)))
 689                 return invalid_value(tp, name, fs_path, option, err);
 690         }
 691         else if (strcasecmp(option, "-socket") == 0) {
 692             s->socket_path = ap_getword_conf(tp, &arg);
 693             if (*s->socket_path == '\0')
 694                 return invalid_value(tp, name, fs_path, option, "\"\"");
 695         }
 696         else if (strcasecmp(option, "-initial-env") == 0) {
 697             if ((err = get_env_var(p, &arg, envp, &envc)))
 698                 return invalid_value(tp, name, fs_path, option, err);
 699         }
 700         else if (strcasecmp(option, "-pass-header") == 0) {
 701             if ((err = get_pass_header(p, &arg, &s->pass_headers)))
 702                 return invalid_value(tp, name, fs_path, option, err);
 703         }
 704         else if (strcasecmp(option, "-flush") == 0) {
 705             s->flush = 1;
 706         }
 707         else if (strcasecmp(option, "-user") == 0) {
 708 #ifdef WIN32
 709             return ap_psprintf(tp,
 710                 "%s %s: the -user option isn't supported on WIN", name, fs_path);
 711 #else
 712             s->username = ap_getword_conf(tp, &arg);
 713             if (*s->user == '\0')
 714                 return invalid_value(tp, name, fs_path, option, "\"\"");
 715 #endif
 716         }
 717         else if (strcasecmp(option, "-group") == 0) {
 718 #ifdef WIN32
 719             return ap_psprintf(tp,
 720                 "%s %s: the -group option isn't supported on WIN", name, fs_path);
 721 #else
 722             s->group = ap_getword_conf(tp, &arg);
 723             if (*s->group == '\0')
 724                 return invalid_value(tp, name, fs_path, option, "\"\"");
 725 #endif
 726         }
 727         else {
 728             return ap_psprintf(tp, "%s %s: invalid option: %s", name, fs_path, option);
 729         }
 730     } /* while */
 731
 732 #ifndef WIN32
 733     if (s->user)
 734     {
 735         if (s->group == NULL)
 736         {
 737             return ap_psprintf(tp,
 738                 "%s %s: -user and -group must be used together", name, fs_path);
 739         }
 740
 741         s->uid = ap_uname2id(s->user);
 742         s->gid = ap_gname2id(s->group);
 743     }
 744     else
 745     {
 746         if (s->group)
 747         {
 748             return ap_psprintf(tp,
 749                 "%s %s: -user and -group must be used together", name, fs_path);
 750         }
 751
 752         s->uid = fcgi_util_get_server_uid(cmd->server);
 753         s->gid = fcgi_util_get_server_gid(cmd->server);
 754     }
 755
 756     if ((err = fcgi_util_fs_set_uid_n_gid(p, s, s->uid, s->gid)))
 757     {
 758         return ap_psprintf(tp,
 759             "%s %s: invalid user or group: %s", name, fs_path, err);
 760     }
 761 #endif /* !WIN32 */
 762
 763     if (s->socket_path != NULL && s->port != 0) {
 764         return ap_psprintf(tp,
 765                 "%s %s: -port and -socket are mutually exclusive options",
 766                 name, fs_path);
 767     }
 768
 769     /* Move env array to a surviving pool */
 770     s->envp = (char **)ap_pcalloc(p, sizeof(char *) * (envc + 4));
 771     memcpy(s->envp, envp, sizeof(char *) * envc);
 772
 773     /* Initialize process structs */
 774     s->procs = fcgi_util_fs_create_procs(p, s->numProcesses);
 775
 776     /* Build the appropriate sockaddr structure */
 777     if (s->port != 0) {
 778         err = fcgi_util_socket_make_inet_addr(p, (struct sockaddr_in **)&s->socket_addr,
 779                                 &s->socket_addr_len, NULL, s->port);
 780         if (err != NULL)
 781             return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 782 #ifdef WIN32
 783         err = fcgi_util_socket_make_inet_addr(p, (struct sockaddr_in **)&s->dest_addr,
 784                                           &s->socket_addr_len, "localhost", s->port);
 785         if (err != NULL)
 786             return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 787 #endif
 788     } else {
 789         if (s->socket_path == NULL)
 790              s->socket_path = fcgi_util_socket_hash_filename(tp, fs_path, s->user, s->group);
 791
 792         if (fcgi_socket_dir == NULL)
 793             fcgi_socket_dir = DEFAULT_SOCK_DIR;
 794
 795         s->socket_path = fcgi_util_socket_make_path_absolute(p, s->socket_path, 0);
 796 #ifndef WIN32
 797         err = fcgi_util_socket_make_domain_addr(p, (struct sockaddr_un **)&s->socket_addr,
 798                                   &s->socket_addr_len, s->socket_path);
 799         if (err != NULL)
 800             return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 801 #endif
 802     }
 803
 804     /* Add it to the list of FastCGI servers */
 805     fcgi_util_fs_add(s);
 806
 807     return NULL;
 808 }
 809 \f
 810 /*******************************************************************************
 811  * Configure a static FastCGI server that is started/managed elsewhere.
 812  */
 813 const char *fcgi_config_new_external_server(cmd_parms *cmd, void *dummy, const char *arg)
 814 {
 815     fcgi_server *s;
 816     pool * const p = cmd->pool, *tp = cmd->temp_pool;
 817     const char * const name = cmd->cmd->name;
 818     char *fs_path = ap_getword_conf(p, &arg);
 819     const char *option, *err;
 820
 821     if (!*fs_path) {
 822         return ap_pstrcat(tp, name, " requires a path and either a -socket or -host option", NULL);
 823     }
 824
 825 #ifdef APACHE2
 826     if (apr_filepath_merge(&fs_path, "", fs_path, 0, p))
 827         return ap_psprintf(tp, "%s %s: invalid filepath", name, fs_path);
 828 #else
 829     fs_path = ap_os_canonical_filename(p, fs_path);
 830 #endif
 831
 832     fs_path = ap_server_root_relative(p, fs_path);
 833
 834     ap_getparents(fs_path);
 835     ap_no2slash(fs_path);
 836
 837     /* See if we've already got one of these bettys configured */
 838     s = fcgi_util_fs_get_by_id(fs_path, fcgi_util_get_server_uid(cmd->server),
 839                                fcgi_util_get_server_gid(cmd->server));
 840     if (s != NULL) {
 841         if (fcgi_wrapper) {
 842             return ap_psprintf(tp,
 843                 "%s: redefinition of a previously defined class \"%s\" "
 844                 "with uid=%ld and gid=%ld",
 845                 name, fs_path, (long) fcgi_util_get_server_uid(cmd->server),
 846                 (long) fcgi_util_get_server_gid(cmd->server));
 847         }
 848         else
 849         {
 850             return ap_psprintf(tp,
 851                 "%s: redefinition of previously defined class \"%s\"", name, fs_path);
 852         }
 853     }
 854
 855     s = fcgi_util_fs_new(p);
 856     s->fs_path = fs_path;
 857     s->directive = APP_CLASS_EXTERNAL;
 858
 859     /*  Parse directive arguments */
 860     while (*arg != '\0') {
 861         option = ap_getword_conf(tp, &arg);
 862
 863         if (strcasecmp(option, "-host") == 0) {
 864             if ((err = get_host_n_port(p, &arg, &s->host, &s->port)))
 865                 return invalid_value(tp, name, fs_path, option, err);
 866         }
 867         else if (strcasecmp(option, "-socket") == 0) {
 868             s->socket_path = ap_getword_conf(tp, &arg);
 869             if (*s->socket_path == '\0')
 870                 return invalid_value(tp, name, fs_path, option, "\"\"");
 871         }
 872         else if (strcasecmp(option, "-appConnTimeout") == 0) {
 873             if ((err = get_u_int(tp, &arg, &s->appConnectTimeout, 0)))
 874                 return invalid_value(tp, name, fs_path, option, err);
 875         }
 876         else if (strcasecmp(option, "-idle-timeout") == 0) {
 877             if ((err = get_u_int(tp, &arg, &s->idle_timeout, 1)))
 878                 return invalid_value(tp, name, fs_path, option, err);
 879         }
 880         else if (strcasecmp(option, "-pass-header") == 0) {
 881             if ((err = get_pass_header(p, &arg, &s->pass_headers)))
 882                 return invalid_value(tp, name, fs_path, option, err);
 883         }
 884         else if (strcasecmp(option, "-flush") == 0) {
 885             s->flush = 1;
 886         }
 887         else if (strcasecmp(option, "-user") == 0) {
 888 #ifdef WIN32
 889             return ap_psprintf(tp,
 890                 "%s %s: the -user option isn't supported on WIN", name, fs_path);
 891 #else
 892             s->username = ap_getword_conf(tp, &arg);
 893             if (*s->user == '\0')
 894                 return invalid_value(tp, name, fs_path, option, "\"\"");
 895 #endif
 896         }
 897         else if (strcasecmp(option, "-group") == 0) {
 898 #ifdef WIN32
 899             return ap_psprintf(tp,
 900                 "%s %s: the -group option isn't supported on WIN", name, fs_path);
 901 #else
 902             s->group = ap_getword_conf(tp, &arg);
 903             if (*s->group == '\0')
 904                 return invalid_value(tp, name, fs_path, option, "\"\"");
 905 #endif
 906         }
 907         else {
 908             return ap_psprintf(tp, "%s %s: invalid option: %s", name, fs_path, option);
 909         }
 910     } /* while */
 911
 912 #ifndef WIN32
 913     if (s->user)
 914     {
 915         if (s->group == NULL)
 916         {
 917             return ap_psprintf(tp,
 918                 "%s %s: -user and -group must be used together", name, fs_path);
 919         }
 920
 921         s->uid = ap_uname2id(s->user);
 922         s->gid = ap_gname2id(s->group);
 923     }
 924     else
 925     {
 926         if (s->group)
 927         {
 928             return ap_psprintf(tp,
 929                 "%s %s: -user and -group must be used together", name, fs_path);
 930         }
 931
 932         s->uid = fcgi_util_get_server_uid(cmd->server);
 933         s->gid = fcgi_util_get_server_gid(cmd->server);
 934     }
 935
 936     if ((err = fcgi_util_fs_set_uid_n_gid(p, s, s->uid, s->gid)))
 937     {
 938         return ap_psprintf(tp,
 939             "%s %s: invalid user or group: %s", name, fs_path, err);
 940     }
 941 #endif /* !WIN32 */
 942
 943     /* Require one of -socket or -host, but not both */
 944     if (s->socket_path != NULL && s->port != 0) {
 945         return ap_psprintf(tp,
 946             "%s %s: -host and -socket are mutually exclusive options",
 947             name, fs_path);
 948     }
 949     if (s->socket_path == NULL && s->port == 0) {
 950         return ap_psprintf(tp,
 951             "%s %s: -socket or -host option missing", name, fs_path);
 952     }
 953
 954     /* Build the appropriate sockaddr structure */
 955     if (s->port != 0) {
 956         err = fcgi_util_socket_make_inet_addr(p, (struct sockaddr_in **)&s->socket_addr,
 957             &s->socket_addr_len, s->host, s->port);
 958         if (err != NULL)
 959             return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 960     } else {
 961
 962         if (fcgi_socket_dir == NULL)
 963             fcgi_socket_dir = DEFAULT_SOCK_DIR;
 964
 965         s->socket_path = fcgi_util_socket_make_path_absolute(p, s->socket_path, 0);
 966 #ifndef WIN32
 967         err = fcgi_util_socket_make_domain_addr(p, (struct sockaddr_un **)&s->socket_addr,
 968                                   &s->socket_addr_len, s->socket_path);
 969         if (err != NULL)
 970             return ap_psprintf(tp, "%s %s: %s", name, fs_path, err);
 971 #endif
 972     }
 973
 974     /* Add it to the list of FastCGI servers */
 975     fcgi_util_fs_add(s);
 976
 977     return NULL;
 978 }
 979 \f
 980 /*
 981  *----------------------------------------------------------------------
 982  *
 983  * fcgi_config_set_config --
 984  *
 985  *      Implements the FastCGI FCGIConfig configuration directive.
 986  *      This command adds routines to control the execution of the
 987  *      dynamic FastCGI processes.
 988  *
 989  *
 990  *----------------------------------------------------------------------
 991  */
 992 const char *fcgi_config_set_config(cmd_parms *cmd, void *dummy, const char *arg)
 993 {
 994     pool * const p = cmd->pool;
 995     pool * const tp = cmd->temp_pool;
 996     const char *err, *option;
 997     const char * const name = cmd->cmd->name;
 998
 999     /* Allocate temp storage for an initial environment */
1000     unsigned int envc = 0;
1001     char **envp = (char **)ap_pcalloc(tp, sizeof(char *) * (MAX_INIT_ENV_VARS + 3));
1002
1003     /* Parse the directive arguments */
1004     while (*arg) {
1005         option = ap_getword_conf(tp, &arg);
1006
1007         if (strcasecmp(option, "-maxProcesses") == 0) {
1008             if ((err = get_u_int(tp, &arg, &dynamicMaxProcs, 1)))
1009                 return invalid_value(tp, name, NULL, option, err);
1010         }
1011         else if (strcasecmp(option, "-minProcesses") == 0) {
1012             if ((err = get_int(tp, &arg, &dynamicMinProcs, 0)))
1013                 return invalid_value(tp, name, NULL, option, err);
1014         }
1015         else if (strcasecmp(option, "-maxClassProcesses") == 0) {
1016             if ((err = get_int(tp, &arg, &dynamicMaxClassProcs, 1)))
1017                 return invalid_value(tp, name, NULL, option, err);
1018         }
1019         else if (strcasecmp(option, "-killInterval") == 0) {
1020             if ((err = get_u_int(tp, &arg, &dynamicKillInterval, 1)))
1021                 return invalid_value(tp, name, NULL, option, err);
1022         }
1023         else if (strcasecmp(option, "-updateInterval") == 0) {
1024             if ((err = get_u_int(tp, &arg, &dynamicUpdateInterval, 1)))
1025                 return invalid_value(tp, name, NULL, option, err);
1026         }
1027         else if (strcasecmp(option, "-gainValue") == 0) {
1028             if ((err = get_float(tp, &arg, &dynamicGain, 0.0, 1.0)))
1029                 return invalid_value(tp, name, NULL, option, err);
1030         }
1031         else if ((strcasecmp(option, "-singleThreshold") == 0)
1032                     || (strcasecmp(option, "-singleThreshhold") == 0))
1033         {
1034             if ((err = get_int(tp, &arg, &dynamicThreshold1, 0)))
1035                 return invalid_value(tp, name, NULL, option, err);
1036         }
1037         else if ((strcasecmp(option, "-multiThreshold") == 0)
1038                     || (strcasecmp(option, "-multiThreshhold") == 0))
1039         {
1040             if ((err = get_int(tp, &arg, &dynamicThresholdN, 0)))
1041                 return invalid_value(tp, name, NULL, option, err);
1042         }
1043         else if (strcasecmp(option, "-startDelay") == 0) {
1044             if ((err = get_u_int(tp, &arg, &dynamicPleaseStartDelay, 1)))
1045                 return invalid_value(tp, name, NULL, option, err);
1046         }
1047         else if (strcasecmp(option, "-initial-env") == 0) {
1048             if ((err = get_env_var(p, &arg, envp, &envc)))
1049                 return invalid_value(tp, name, NULL, option, err);
1050         }
1051         else if (strcasecmp(option, "-pass-header") == 0) {
1052             if ((err = get_pass_header(p, &arg, &dynamic_pass_headers)))
1053                 return invalid_value(tp, name, NULL, option, err);
1054         }
1055         else if (strcasecmp(option, "-appConnTimeout") == 0) {
1056             if ((err = get_u_int(tp, &arg, &dynamicAppConnectTimeout, 0)))
1057                 return invalid_value(tp, name, NULL, option, err);
1058         }
1059         else if (strcasecmp(option, "-idle-timeout") == 0) {
1060             if ((err = get_u_int(tp, &arg, &dynamic_idle_timeout, 1)))
1061                 return invalid_value(tp, name, NULL, option, err);
1062         }
1063         else if (strcasecmp(option, "-listen-queue-depth") == 0) {
1064             if ((err = get_u_int(tp, &arg, &dynamicListenQueueDepth, 1)))
1065                 return invalid_value(tp, name, NULL, option, err);
1066         }
1067         else if (strcasecmp(option, "-restart-delay") == 0) {
1068             if ((err = get_u_int(tp, &arg, &dynamicRestartDelay, 0)))
1069                 return invalid_value(tp, name, NULL, option, err);
1070         }
1071         else if (strcasecmp(option, "-init-start-delay") == 0) {
1072             if ((err = get_u_int(tp, &arg, &dynamicInitStartDelay, 0)))
1073                 return invalid_value(tp, name, NULL, option, err);
1074         }
1075         else if (strcasecmp(option, "-processSlack") == 0) {
1076             if ((err = get_u_int(tp, &arg, &dynamicProcessSlack, 1)))
1077                 return invalid_value(tp, name, NULL, option, err);
1078         }
1079         else if (strcasecmp(option, "-restart") == 0) {
1080             dynamicAutoRestart = 1;
1081         }
1082         else if (strcasecmp(option, "-autoUpdate") == 0) {
1083             dynamicAutoUpdate = 1;
1084                 }
1085         else if (strcasecmp(option, "-flush") == 0) {
1086             dynamicFlush = TRUE;
1087         }
1088         else {
1089             return ap_psprintf(tp, "%s: invalid option: %s", name, option);
1090         }
1091     } /* while */
1092
1093     if (dynamicProcessSlack >= dynamicMaxProcs + 1) {
1094             /* the kill policy would work unexpectedly */
1095         return ap_psprintf(tp,
1096             "%s: processSlack (%u) must be less than maxProcesses (%u) + 1",
1097                 name, dynamicProcessSlack, dynamicMaxProcs);
1098     }
1099
1100     /* Move env array to a surviving pool, leave 2 extra slots for
1101      * WIN32 _FCGI_MUTEX_ and _FCGI_SHUTDOWN_EVENT_ */
1102     dynamicEnvp = (char **)ap_pcalloc(p, sizeof(char *) * (envc + 4));
1103     memcpy(dynamicEnvp, envp, sizeof(char *) * envc);
1104
1105     return NULL;
1106 }
1107
1108 void *fcgi_config_create_dir_config(pool *p, char *dummy)
1109 {
1110     fcgi_dir_config *dir_config = ap_pcalloc(p, sizeof(fcgi_dir_config));
1111
1112     dir_config->authenticator_options = FCGI_AUTHORITATIVE;
1113     dir_config->authorizer_options = FCGI_AUTHORITATIVE;
1114     dir_config->access_checker_options = FCGI_AUTHORITATIVE;
1115
1116     return dir_config;
1117 }
1118
1119
1120 const char *fcgi_config_new_auth_server(cmd_parms * cmd,
1121     void * dircfg, const char *fs_path, const char * compat)
1122 {
1123     fcgi_dir_config * dir_config = (fcgi_dir_config *) dircfg;
1124     pool * const tp = cmd->temp_pool;
1125     char * auth_server;
1126
1127 #ifdef APACHE2
1128     if (apr_filepath_merge(&auth_server, "", fs_path, 0, cmd->pool))
1129         return ap_psprintf(tp, "%s %s: invalid filepath", cmd->cmd->name, fs_path);
1130 #else
1131     auth_server = (char *) ap_os_canonical_filename(cmd->pool, fs_path);
1132 #endif
1133
1134     auth_server = ap_server_root_relative(cmd->pool, auth_server);
1135
1136     /* Make sure its already configured or at least a candidate for dynamic */
1137     if (fcgi_util_fs_get_by_id(auth_server, fcgi_util_get_server_uid(cmd->server),
1138                                fcgi_util_get_server_gid(cmd->server)) == NULL)
1139     {
1140         const char *err = fcgi_util_fs_is_path_ok(tp, auth_server, NULL);
1141         if (err)
1142             return ap_psprintf(tp, "%s: \"%s\" %s", cmd->cmd->name, auth_server, err);
1143     }
1144
1145     if (compat && strcasecmp(compat, "-compat"))
1146         return ap_psprintf(cmd->temp_pool, "%s: unknown option: \"%s\"", cmd->cmd->name, compat);
1147
1148     switch((int)cmd->info) {
1149         case FCGI_AUTH_TYPE_AUTHENTICATOR:
1150             dir_config->authenticator = auth_server;
1151             dir_config->authenticator_options |= (compat) ? FCGI_COMPAT : 0;
1152             break;
1153         case FCGI_AUTH_TYPE_AUTHORIZER:
1154             dir_config->authorizer = auth_server;
1155             dir_config->authorizer_options |= (compat) ? FCGI_COMPAT : 0;
1156             break;
1157         case FCGI_AUTH_TYPE_ACCESS_CHECKER:
1158             dir_config->access_checker = auth_server;
1159             dir_config->access_checker_options |= (compat) ? FCGI_COMPAT : 0;
1160             break;
1161     }
1162
1163     return NULL;
1164 }
1165
1166 const char *fcgi_config_set_authoritative_slot(cmd_parms * cmd,
1167     void * dir_config, int arg)
1168 {
1169     int offset = (int)(long)cmd->info;
1170
1171     if (arg)
1172         *((u_char *)dir_config + offset) |= FCGI_AUTHORITATIVE;
1173     else
1174         *((u_char *)dir_config + offset) &= ~FCGI_AUTHORITATIVE;
1175
1176     return NULL;
1177 }