fcgi_config.c

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