granicus.if.org Git - apache/blob - server/mpm_unix.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /* The purpose of this file is to store the code that MOST mpm's will need
  18  * this does not mean a function only goes into this file if every MPM needs
  19  * it.  It means that if a function is needed by more than one MPM, and
  20  * future maintenance would be served by making the code common, then the
  21  * function belongs here.
  22  *
  23  * This is going in src/main because it is not platform specific, it is
  24  * specific to multi-process servers, but NOT to Unix.  Which is why it
  25  * does not belong in src/os/unix
  26  */
  27
  28 #ifndef WIN32
  29
  30 #include "apr.h"
  31 #include "apr_thread_proc.h"
  32 #include "apr_signal.h"
  33 #include "apr_strings.h"
  34 #define APR_WANT_STRFUNC
  35 #include "apr_want.h"
  36 #include "apr_getopt.h"
  37 #include "apr_optional.h"
  38 #include "apr_allocator.h"
  39
  40 #include "httpd.h"
  41 #include "http_config.h"
  42 #include "http_core.h"
  43 #include "http_log.h"
  44 #include "http_main.h"
  45 #include "mpm_common.h"
  46 #include "ap_mpm.h"
  47 #include "ap_listen.h"
  48 #include "scoreboard.h"
  49 #include "util_mutex.h"
  50
  51 #ifdef HAVE_PWD_H
  52 #include <pwd.h>
  53 #endif
  54 #ifdef HAVE_GRP_H
  55 #include <grp.h>
  56 #endif
  57 #if APR_HAVE_UNISTD_H
  58 #include <unistd.h>
  59 #endif
  60
  61
  62 /* we know core's module_index is 0 */
  63 #undef APLOG_MODULE_INDEX
  64 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
  65
  66 typedef enum {DO_NOTHING, SEND_SIGTERM, SEND_SIGKILL, GIVEUP} action_t;
  67
  68 typedef struct extra_process_t {
  69     struct extra_process_t *next;
  70     pid_t pid;
  71     ap_generation_t gen;
  72 } extra_process_t;
  73
  74 static extra_process_t *extras;
  75
  76 AP_DECLARE(void) ap_register_extra_mpm_process(pid_t pid, ap_generation_t gen)
  77 {
  78     extra_process_t *p = (extra_process_t *)ap_malloc(sizeof(extra_process_t));
  79
  80     p->next = extras;
  81     p->pid = pid;
  82     p->gen = gen;
  83     extras = p;
  84 }
  85
  86 AP_DECLARE(int) ap_unregister_extra_mpm_process(pid_t pid, ap_generation_t *old_gen)
  87 {
  88     extra_process_t *cur = extras;
  89     extra_process_t *prev = NULL;
  90
  91     while (cur && cur->pid != pid) {
  92         prev = cur;
  93         cur = cur->next;
  94     }
  95
  96     if (cur) {
  97         if (prev) {
  98             prev->next = cur->next;
  99         }
 100         else {
 101             extras = cur->next;
 102         }
 103         *old_gen = cur->gen;
 104         free(cur);
 105         return 1; /* found */
 106     }
 107     else {
 108         /* we don't know about any such process */
 109         return 0;
 110     }
 111 }
 112
 113 static int reclaim_one_pid(pid_t pid, action_t action)
 114 {
 115     apr_proc_t proc;
 116     apr_status_t waitret;
 117     apr_exit_why_e why;
 118     int status;
 119
 120     /* Ensure pid sanity. */
 121     if (pid < 1) {
 122         return 1;
 123     }
 124
 125     proc.pid = pid;
 126     waitret = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
 127     if (waitret != APR_CHILD_NOTDONE) {
 128         if (waitret == APR_CHILD_DONE)
 129             ap_process_child_status(&proc, why, status);
 130         return 1;
 131     }
 132
 133     switch(action) {
 134     case DO_NOTHING:
 135         break;
 136
 137     case SEND_SIGTERM:
 138         /* ok, now it's being annoying */
 139         ap_log_error(APLOG_MARK, APLOG_WARNING,
 140                      0, ap_server_conf, APLOGNO(00045)
 141                      "child process %" APR_PID_T_FMT
 142                      " still did not exit, "
 143                      "sending a SIGTERM",
 144                      pid);
 145         kill(pid, SIGTERM);
 146         break;
 147
 148     case SEND_SIGKILL:
 149         ap_log_error(APLOG_MARK, APLOG_ERR,
 150                      0, ap_server_conf, APLOGNO(00046)
 151                      "child process %" APR_PID_T_FMT
 152                      " still did not exit, "
 153                      "sending a SIGKILL",
 154                      pid);
 155         kill(pid, SIGKILL);
 156         break;
 157
 158     case GIVEUP:
 159         /* gave it our best shot, but alas...  If this really
 160          * is a child we are trying to kill and it really hasn't
 161          * exited, we will likely fail to bind to the port
 162          * after the restart.
 163          */
 164         ap_log_error(APLOG_MARK, APLOG_ERR,
 165                      0, ap_server_conf, APLOGNO(00047)
 166                      "could not make child process %" APR_PID_T_FMT
 167                      " exit, "
 168                      "attempting to continue anyway",
 169                      pid);
 170         break;
 171     }
 172
 173     return 0;
 174 }
 175
 176 AP_DECLARE(void) ap_reclaim_child_processes(int terminate,
 177                                             ap_reclaim_callback_fn_t *mpm_callback)
 178 {
 179     apr_time_t waittime = 1024 * 16;
 180     int i;
 181     extra_process_t *cur_extra;
 182     int not_dead_yet;
 183     int max_daemons;
 184     apr_time_t starttime = apr_time_now();
 185     /* this table of actions and elapsed times tells what action is taken
 186      * at which elapsed time from starting the reclaim
 187      */
 188     struct {
 189         action_t action;
 190         apr_time_t action_time;
 191     } action_table[] = {
 192         {DO_NOTHING, 0}, /* dummy entry for iterations where we reap
 193                           * children but take no action against
 194                           * stragglers
 195                           */
 196         {SEND_SIGTERM, apr_time_from_sec(3)},
 197         {SEND_SIGTERM, apr_time_from_sec(5)},
 198         {SEND_SIGTERM, apr_time_from_sec(7)},
 199         {SEND_SIGKILL, apr_time_from_sec(9)},
 200         {GIVEUP,       apr_time_from_sec(10)}
 201     };
 202     int cur_action;      /* index of action we decided to take this
 203                           * iteration
 204                           */
 205     int next_action = 1; /* index of first real action */
 206
 207     ap_mpm_query(AP_MPMQ_MAX_DAEMON_USED, &max_daemons);
 208
 209     do {
 210         apr_sleep(waittime);
 211         /* don't let waittime get longer than 1 second; otherwise, we don't
 212          * react quickly to the last child exiting, and taking action can
 213          * be delayed
 214          */
 215         waittime = waittime * 4;
 216         if (waittime > apr_time_from_sec(1)) {
 217             waittime = apr_time_from_sec(1);
 218         }
 219
 220         /* see what action to take, if any */
 221         if (action_table[next_action].action_time <= apr_time_now() - starttime) {
 222             cur_action = next_action;
 223             ++next_action;
 224         }
 225         else {
 226             cur_action = 0; /* nothing to do */
 227         }
 228
 229         /* now see who is done */
 230         not_dead_yet = 0;
 231         for (i = 0; i < max_daemons; ++i) {
 232             process_score *ps = ap_get_scoreboard_process(i);
 233             pid_t pid = ps->pid;
 234
 235             if (pid == 0) {
 236                 continue; /* not every scoreboard entry is in use */
 237             }
 238
 239             if (reclaim_one_pid(pid, action_table[cur_action].action)) {
 240                 mpm_callback(i, 0, 0);
 241             }
 242             else {
 243                 ++not_dead_yet;
 244             }
 245         }
 246
 247         cur_extra = extras;
 248         while (cur_extra) {
 249             ap_generation_t old_gen;
 250             extra_process_t *next = cur_extra->next;
 251
 252             if (reclaim_one_pid(cur_extra->pid, action_table[cur_action].action)) {
 253                 if (ap_unregister_extra_mpm_process(cur_extra->pid, &old_gen) == 1) {
 254                     mpm_callback(-1, cur_extra->pid, old_gen);
 255                 }
 256                 else {
 257                     AP_DEBUG_ASSERT(1 == 0);
 258                 }
 259             }
 260             else {
 261                 ++not_dead_yet;
 262             }
 263             cur_extra = next;
 264         }
 265 #if APR_HAS_OTHER_CHILD
 266         apr_proc_other_child_refresh_all(APR_OC_REASON_RESTART);
 267 #endif
 268
 269     } while (not_dead_yet > 0 &&
 270              action_table[cur_action].action != GIVEUP);
 271 }
 272
 273 AP_DECLARE(void) ap_relieve_child_processes(ap_reclaim_callback_fn_t *mpm_callback)
 274 {
 275     int i;
 276     extra_process_t *cur_extra;
 277     int max_daemons;
 278
 279     ap_mpm_query(AP_MPMQ_MAX_DAEMON_USED, &max_daemons);
 280
 281     /* now see who is done */
 282     for (i = 0; i < max_daemons; ++i) {
 283         process_score *ps = ap_get_scoreboard_process(i);
 284         pid_t pid = ps->pid;
 285
 286         if (pid == 0) {
 287             continue; /* not every scoreboard entry is in use */
 288         }
 289
 290         if (reclaim_one_pid(pid, DO_NOTHING)) {
 291             mpm_callback(i, 0, 0);
 292         }
 293     }
 294
 295     cur_extra = extras;
 296     while (cur_extra) {
 297         ap_generation_t old_gen;
 298         extra_process_t *next = cur_extra->next;
 299
 300         if (reclaim_one_pid(cur_extra->pid, DO_NOTHING)) {
 301             if (ap_unregister_extra_mpm_process(cur_extra->pid, &old_gen) == 1) {
 302                 mpm_callback(-1, cur_extra->pid, old_gen);
 303             }
 304             else {
 305                 AP_DEBUG_ASSERT(1 == 0);
 306             }
 307         }
 308         cur_extra = next;
 309     }
 310 }
 311
 312 /* Before sending the signal to the pid this function verifies that
 313  * the pid is a member of the current process group; either using
 314  * apr_proc_wait(), where waitpid() guarantees to fail for non-child
 315  * processes; or by using getpgid() directly, if available. */
 316 AP_DECLARE(apr_status_t) ap_mpm_safe_kill(pid_t pid, int sig)
 317 {
 318 #ifndef HAVE_GETPGID
 319     apr_proc_t proc;
 320     apr_status_t rv;
 321     apr_exit_why_e why;
 322     int status;
 323
 324     /* Ensure pid sanity */
 325     if (pid < 1) {
 326         return APR_EINVAL;
 327     }
 328
 329     proc.pid = pid;
 330     rv = apr_proc_wait(&proc, &status, &why, APR_NOWAIT);
 331     if (rv == APR_CHILD_DONE) {
 332         /* The child already died - log the termination status if
 333          * necessary: */
 334         ap_process_child_status(&proc, why, status);
 335         return APR_EINVAL;
 336     }
 337     else if (rv != APR_CHILD_NOTDONE) {
 338         /* The child is already dead and reaped, or was a bogus pid -
 339          * log this either way. */
 340         ap_log_error(APLOG_MARK, APLOG_NOTICE, rv, ap_server_conf, APLOGNO(00048)
 341                      "cannot send signal %d to pid %ld (non-child or "
 342                      "already dead)", sig, (long)pid);
 343         return APR_EINVAL;
 344     }
 345 #else
 346     pid_t pg;
 347
 348     /* Ensure pid sanity. */
 349     if (pid < 1) {
 350         return APR_EINVAL;
 351     }
 352
 353     pg = getpgid(pid);
 354     if (pg == -1) {
 355         /* Process already dead... */
 356         return errno;
 357     }
 358
 359     if (pg != getpgrp()) {
 360         ap_log_error(APLOG_MARK, APLOG_ALERT, 0, ap_server_conf, APLOGNO(00049)
 361                      "refusing to send signal %d to pid %ld outside "
 362                      "process group", sig, (long)pid);
 363         return APR_EINVAL;
 364     }
 365 #endif
 366
 367     return kill(pid, sig) ? errno : APR_SUCCESS;
 368 }
 369
 370
 371 AP_DECLARE(int) ap_process_child_status(apr_proc_t *pid, apr_exit_why_e why,
 372                                         int status)
 373 {
 374     int signum = status;
 375     const char *sigdesc;
 376
 377     /* Child died... if it died due to a fatal error,
 378      * we should simply bail out.  The caller needs to
 379      * check for bad rc from us and exit, running any
 380      * appropriate cleanups.
 381      *
 382      * If the child died due to a resource shortage,
 383      * the parent should limit the rate of forking
 384      */
 385     if (APR_PROC_CHECK_EXIT(why)) {
 386         if (status == APEXIT_CHILDSICK) {
 387             return status;
 388         }
 389
 390         if (status == APEXIT_CHILDFATAL) {
 391             ap_log_error(APLOG_MARK, APLOG_ALERT,
 392                          0, ap_server_conf, APLOGNO(00050)
 393                          "Child %" APR_PID_T_FMT
 394                          " returned a Fatal error... Apache is exiting!",
 395                          pid->pid);
 396             return APEXIT_CHILDFATAL;
 397         }
 398
 399         return 0;
 400     }
 401
 402     if (APR_PROC_CHECK_SIGNALED(why)) {
 403         sigdesc = apr_signal_description_get(signum);
 404
 405         switch (signum) {
 406         case SIGTERM:
 407         case SIGHUP:
 408         case AP_SIG_GRACEFUL:
 409         case SIGKILL:
 410             break;
 411
 412         default:
 413             if (APR_PROC_CHECK_CORE_DUMP(why)) {
 414                 ap_log_error(APLOG_MARK, APLOG_NOTICE,
 415                              0, ap_server_conf, APLOGNO(00051)
 416                              "child pid %ld exit signal %s (%d), "
 417                              "possible coredump in %s",
 418                              (long)pid->pid, sigdesc, signum,
 419                              ap_coredump_dir);
 420             }
 421             else {
 422                 ap_log_error(APLOG_MARK, APLOG_NOTICE,
 423                              0, ap_server_conf, APLOGNO(00052)
 424                              "child pid %ld exit signal %s (%d)",
 425                              (long)pid->pid, sigdesc, signum);
 426             }
 427         }
 428     }
 429     return 0;
 430 }
 431
 432 AP_DECLARE(apr_status_t) ap_mpm_pod_open(apr_pool_t *p, ap_pod_t **pod)
 433 {
 434     apr_status_t rv;
 435
 436     *pod = apr_palloc(p, sizeof(**pod));
 437     rv = apr_file_pipe_create_ex(&((*pod)->pod_in), &((*pod)->pod_out),
 438                                  APR_WRITE_BLOCK, p);
 439     if (rv != APR_SUCCESS) {
 440         return rv;
 441     }
 442
 443     apr_file_pipe_timeout_set((*pod)->pod_in, 0);
 444     (*pod)->p = p;
 445
 446     /* close these before exec. */
 447     apr_file_inherit_unset((*pod)->pod_in);
 448     apr_file_inherit_unset((*pod)->pod_out);
 449
 450     return APR_SUCCESS;
 451 }
 452
 453 AP_DECLARE(apr_status_t) ap_mpm_pod_check(ap_pod_t *pod)
 454 {
 455     char c;
 456     apr_size_t len = 1;
 457     apr_status_t rv;
 458
 459     rv = apr_file_read(pod->pod_in, &c, &len);
 460
 461     if ((rv == APR_SUCCESS) && (len == 1)) {
 462         return APR_SUCCESS;
 463     }
 464
 465     if (rv != APR_SUCCESS) {
 466         return rv;
 467     }
 468
 469     return AP_NORESTART;
 470 }
 471
 472 AP_DECLARE(apr_status_t) ap_mpm_pod_close(ap_pod_t *pod)
 473 {
 474     apr_status_t rv;
 475
 476     rv = apr_file_close(pod->pod_out);
 477     if (rv != APR_SUCCESS) {
 478         return rv;
 479     }
 480
 481     rv = apr_file_close(pod->pod_in);
 482     if (rv != APR_SUCCESS) {
 483         return rv;
 484     }
 485
 486     return APR_SUCCESS;
 487 }
 488
 489 static apr_status_t pod_signal_internal(ap_pod_t *pod)
 490 {
 491     apr_status_t rv;
 492     char char_of_death = '!';
 493     apr_size_t one = 1;
 494
 495     rv = apr_file_write(pod->pod_out, &char_of_death, &one);
 496     if (rv != APR_SUCCESS) {
 497         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00053)
 498                      "write pipe_of_death");
 499     }
 500
 501     return rv;
 502 }
 503
 504 /* This function connects to the server, then immediately closes the connection.
 505  * This permits the MPM to skip the poll when there is only one listening
 506  * socket, because it provides a alternate way to unblock an accept() when
 507  * the pod is used.
 508  */
 509 static apr_status_t dummy_connection(ap_pod_t *pod)
 510 {
 511     char *srequest;
 512     apr_status_t rv;
 513     apr_socket_t *sock;
 514     apr_pool_t *p;
 515     apr_size_t len;
 516     ap_listen_rec *lp;
 517
 518     /* create a temporary pool for the socket.  pconf stays around too long */
 519     rv = apr_pool_create(&p, pod->p);
 520     if (rv != APR_SUCCESS) {
 521         return rv;
 522     }
 523
 524     /* If possible, find a listener which is configured for
 525      * plain-HTTP, not SSL; using an SSL port would either be
 526      * expensive to do correctly (performing a complete SSL handshake)
 527      * or cause log spam by doing incorrectly (simply sending EOF). */
 528     lp = ap_listeners;
 529     while (lp && lp->protocol && strcasecmp(lp->protocol, "http") != 0) {
 530         lp = lp->next;
 531     }
 532     if (!lp) {
 533         lp = ap_listeners;
 534     }
 535
 536     rv = apr_socket_create(&sock, lp->bind_addr->family, SOCK_STREAM, 0, p);
 537     if (rv != APR_SUCCESS) {
 538         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00054)
 539                      "get socket to connect to listener");
 540         apr_pool_destroy(p);
 541         return rv;
 542     }
 543
 544     /* on some platforms (e.g., FreeBSD), the kernel won't accept many
 545      * queued connections before it starts blocking local connects...
 546      * we need to keep from blocking too long and instead return an error,
 547      * because the MPM won't want to hold up a graceful restart for a
 548      * long time
 549      */
 550     rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
 551     if (rv != APR_SUCCESS) {
 552         ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00055)
 553                      "set timeout on socket to connect to listener");
 554         apr_socket_close(sock);
 555         apr_pool_destroy(p);
 556         return rv;
 557     }
 558
 559     rv = apr_socket_connect(sock, lp->bind_addr);
 560     if (rv != APR_SUCCESS) {
 561         int log_level = APLOG_WARNING;
 562
 563         if (APR_STATUS_IS_TIMEUP(rv)) {
 564             /* probably some server processes bailed out already and there
 565              * is nobody around to call accept and clear out the kernel
 566              * connection queue; usually this is not worth logging
 567              */
 568             log_level = APLOG_DEBUG;
 569         }
 570
 571         ap_log_error(APLOG_MARK, log_level, rv, ap_server_conf, APLOGNO(00056)
 572                      "connect to listener on %pI", lp->bind_addr);
 573         apr_pool_destroy(p);
 574         return rv;
 575     }
 576
 577     /* Create the request string. We include a User-Agent so that
 578      * adminstrators can track down the cause of the odd-looking
 579      * requests in their logs.
 580      */
 581     srequest = apr_pstrcat(p, "OPTIONS * HTTP/1.0\r\nUser-Agent: ",
 582                            ap_get_server_description(),
 583                            " (internal dummy connection)\r\n\r\n", NULL);
 584
 585     /* Since some operating systems support buffering of data or entire
 586      * requests in the kernel, we send a simple request, to make sure
 587      * the server pops out of a blocking accept().
 588      */
 589     /* XXX: This is HTTP specific. We should look at the Protocol for each
 590      * listener, and send the correct type of request to trigger any Accept
 591      * Filters.
 592      */
 593     len = strlen(srequest);
 594     apr_socket_send(sock, srequest, &len);
 595     apr_socket_close(sock);
 596     apr_pool_destroy(p);
 597
 598     return rv;
 599 }
 600
 601 AP_DECLARE(apr_status_t) ap_mpm_pod_signal(ap_pod_t *pod)
 602 {
 603     apr_status_t rv;
 604
 605     rv = pod_signal_internal(pod);
 606     if (rv != APR_SUCCESS) {
 607         return rv;
 608     }
 609
 610     return dummy_connection(pod);
 611 }
 612
 613 void ap_mpm_pod_killpg(ap_pod_t *pod, int num)
 614 {
 615     int i;
 616     apr_status_t rv = APR_SUCCESS;
 617
 618     /* we don't write anything to the pod here...  we assume
 619      * that the would-be reader of the pod has another way to
 620      * see that it is time to die once we wake it up
 621      *
 622      * writing lots of things to the pod at once is very
 623      * problematic... we can fill the kernel pipe buffer and
 624      * be blocked until somebody consumes some bytes or
 625      * we hit a timeout...  if we hit a timeout we can't just
 626      * keep trying because maybe we'll never successfully
 627      * write again...  but then maybe we'll leave would-be
 628      * readers stranded (a number of them could be tied up for
 629      * a while serving time-consuming requests)
 630      */
 631     for (i = 0; i < num && rv == APR_SUCCESS; i++) {
 632         rv = dummy_connection(pod);
 633     }
 634 }
 635
 636 static const char *dash_k_arg = NULL;
 637 static const char *dash_k_arg_noarg = "noarg";
 638
 639 static int send_signal(pid_t pid, int sig)
 640 {
 641     if (kill(pid, sig) < 0) {
 642         ap_log_error(APLOG_MARK, APLOG_STARTUP, errno, NULL, APLOGNO(00057)
 643                      "sending signal to server");
 644         return 1;
 645     }
 646     return 0;
 647 }
 648
 649 int ap_signal_server(int *exit_status, apr_pool_t *pconf)
 650 {
 651     apr_status_t rv;
 652     pid_t otherpid;
 653     int running = 0;
 654     const char *status;
 655
 656     *exit_status = 0;
 657
 658     rv = ap_read_pid(pconf, ap_pid_fname, &otherpid);
 659     if (rv != APR_SUCCESS) {
 660         if (!APR_STATUS_IS_ENOENT(rv)) {
 661             ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, NULL, APLOGNO(00058)
 662                          "Error retrieving pid file %s", ap_pid_fname);
 663             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL, APLOGNO(00059)
 664                          "Remove it before continuing if it is corrupted.");
 665             *exit_status = 1;
 666             return 1;
 667         }
 668         status = "httpd (no pid file) not running";
 669     }
 670     else {
 671         if (kill(otherpid, 0) == 0) {
 672             running = 1;
 673             status = apr_psprintf(pconf,
 674                                   "httpd (pid %" APR_PID_T_FMT ") already "
 675                                   "running", otherpid);
 676         }
 677         else {
 678             status = apr_psprintf(pconf,
 679                                   "httpd (pid %" APR_PID_T_FMT "?) not running",
 680                                   otherpid);
 681         }
 682     }
 683
 684     if (!strcmp(dash_k_arg, "start") || dash_k_arg == dash_k_arg_noarg) {
 685         if (running) {
 686             printf("%s\n", status);
 687             return 1;
 688         }
 689     }
 690
 691     if (!strcmp(dash_k_arg, "stop")) {
 692         if (!running) {
 693             printf("%s\n", status);
 694         }
 695         else {
 696             send_signal(otherpid, SIGTERM);
 697         }
 698         return 1;
 699     }
 700
 701     if (!strcmp(dash_k_arg, "restart")) {
 702         if (!running) {
 703             printf("httpd not running, trying to start\n");
 704         }
 705         else {
 706             *exit_status = send_signal(otherpid, SIGHUP);
 707             return 1;
 708         }
 709     }
 710
 711     if (!strcmp(dash_k_arg, "graceful")) {
 712         if (!running) {
 713             printf("httpd not running, trying to start\n");
 714         }
 715         else {
 716             *exit_status = send_signal(otherpid, AP_SIG_GRACEFUL);
 717             return 1;
 718         }
 719     }
 720
 721     if (!strcmp(dash_k_arg, "graceful-stop")) {
 722         if (!running) {
 723             printf("%s\n", status);
 724         }
 725         else {
 726             *exit_status = send_signal(otherpid, AP_SIG_GRACEFUL_STOP);
 727         }
 728         return 1;
 729     }
 730
 731     return 0;
 732 }
 733
 734 void ap_mpm_rewrite_args(process_rec *process)
 735 {
 736     apr_array_header_t *mpm_new_argv;
 737     apr_status_t rv;
 738     apr_getopt_t *opt;
 739     char optbuf[3];
 740     const char *optarg;
 741
 742     mpm_new_argv = apr_array_make(process->pool, process->argc,
 743                                   sizeof(const char **));
 744     *(const char **)apr_array_push(mpm_new_argv) = process->argv[0];
 745     apr_getopt_init(&opt, process->pool, process->argc, process->argv);
 746     opt->errfn = NULL;
 747     optbuf[0] = '-';
 748     /* option char returned by apr_getopt() will be stored in optbuf[1] */
 749     optbuf[2] = '\0';
 750     while ((rv = apr_getopt(opt, "k:" AP_SERVER_BASEARGS,
 751                             optbuf + 1, &optarg)) == APR_SUCCESS) {
 752         switch(optbuf[1]) {
 753         case 'k':
 754             if (!dash_k_arg) {
 755                 if (!strcmp(optarg, "start") || !strcmp(optarg, "stop") ||
 756                     !strcmp(optarg, "restart") || !strcmp(optarg, "graceful") ||
 757                     !strcmp(optarg, "graceful-stop")) {
 758                     dash_k_arg = optarg;
 759                     break;
 760                 }
 761             }
 762         default:
 763             *(const char **)apr_array_push(mpm_new_argv) =
 764                 apr_pstrdup(process->pool, optbuf);
 765             if (optarg) {
 766                 *(const char **)apr_array_push(mpm_new_argv) = optarg;
 767             }
 768         }
 769     }
 770
 771     /* back up to capture the bad argument */
 772     if (rv == APR_BADCH || rv == APR_BADARG) {
 773         opt->ind--;
 774     }
 775
 776     while (opt->ind < opt->argc) {
 777         *(const char **)apr_array_push(mpm_new_argv) =
 778             apr_pstrdup(process->pool, opt->argv[opt->ind++]);
 779     }
 780
 781     process->argc = mpm_new_argv->nelts;
 782     process->argv = (const char * const *)mpm_new_argv->elts;
 783
 784     if (NULL == dash_k_arg) {
 785         dash_k_arg = dash_k_arg_noarg;
 786     }
 787
 788     APR_REGISTER_OPTIONAL_FN(ap_signal_server);
 789 }
 790
 791 static pid_t parent_pid, my_pid;
 792 static apr_pool_t *pconf;
 793
 794 #if AP_ENABLE_EXCEPTION_HOOK
 795
 796 static int exception_hook_enabled;
 797
 798 const char *ap_mpm_set_exception_hook(cmd_parms *cmd, void *dummy,
 799                                       const char *arg)
 800 {
 801     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 802     if (err != NULL) {
 803         return err;
 804     }
 805
 806     if (cmd->server->is_virtual) {
 807         return "EnableExceptionHook directive not allowed in <VirtualHost>";
 808     }
 809
 810     if (strcasecmp(arg, "on") == 0) {
 811         exception_hook_enabled = 1;
 812     }
 813     else if (strcasecmp(arg, "off") == 0) {
 814         exception_hook_enabled = 0;
 815     }
 816     else {
 817         return "parameter must be 'on' or 'off'";
 818     }
 819
 820     return NULL;
 821 }
 822
 823 static void run_fatal_exception_hook(int sig)
 824 {
 825     ap_exception_info_t ei = {0};
 826
 827     if (exception_hook_enabled &&
 828         geteuid() != 0 &&
 829         my_pid != parent_pid) {
 830         ei.sig = sig;
 831         ei.pid = my_pid;
 832         ap_run_fatal_exception(&ei);
 833     }
 834 }
 835 #endif /* AP_ENABLE_EXCEPTION_HOOK */
 836
 837 /* handle all varieties of core dumping signals */
 838 static void sig_coredump(int sig)
 839 {
 840     apr_filepath_set(ap_coredump_dir, pconf);
 841     apr_signal(sig, SIG_DFL);
 842 #if AP_ENABLE_EXCEPTION_HOOK
 843     run_fatal_exception_hook(sig);
 844 #endif
 845     /* linuxthreads issue calling getpid() here:
 846      *   This comparison won't match if the crashing thread is
 847      *   some module's thread that runs in the parent process.
 848      *   The fallout, which is limited to linuxthreads:
 849      *   The special log message won't be written when such a
 850      *   thread in the parent causes the parent to crash.
 851      */
 852     if (getpid() == parent_pid) {
 853         ap_log_error(APLOG_MARK, APLOG_NOTICE,
 854                      0, ap_server_conf, APLOGNO(00060)
 855                      "seg fault or similar nasty error detected "
 856                      "in the parent process");
 857         /* XXX we can probably add some rudimentary cleanup code here,
 858          * like getting rid of the pid file.  If any additional bad stuff
 859          * happens, we are protected from recursive errors taking down the
 860          * system since this function is no longer the signal handler   GLA
 861          */
 862     }
 863     kill(getpid(), sig);
 864     /* At this point we've got sig blocked, because we're still inside
 865      * the signal handler.  When we leave the signal handler it will
 866      * be unblocked, and we'll take the signal... and coredump or whatever
 867      * is appropriate for this particular Unix.  In addition the parent
 868      * will see the real signal we received -- whereas if we called
 869      * abort() here, the parent would only see SIGABRT.
 870      */
 871 }
 872
 873 AP_DECLARE(apr_status_t) ap_fatal_signal_child_setup(server_rec *s)
 874 {
 875     my_pid = getpid();
 876     return APR_SUCCESS;
 877 }
 878
 879 AP_DECLARE(apr_status_t) ap_fatal_signal_setup(server_rec *s,
 880                                                apr_pool_t *pconf)
 881 {
 882 #ifndef NO_USE_SIGACTION
 883     struct sigaction sa;
 884
 885     sigemptyset(&sa.sa_mask);
 886
 887 #if defined(SA_ONESHOT)
 888     sa.sa_flags = SA_ONESHOT;
 889 #elif defined(SA_RESETHAND)
 890     sa.sa_flags = SA_RESETHAND;
 891 #else
 892     sa.sa_flags = 0;
 893 #endif
 894
 895     sa.sa_handler = sig_coredump;
 896     if (sigaction(SIGSEGV, &sa, NULL) < 0)
 897         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00061) "sigaction(SIGSEGV)");
 898 #ifdef SIGBUS
 899     if (sigaction(SIGBUS, &sa, NULL) < 0)
 900         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00062) "sigaction(SIGBUS)");
 901 #endif
 902 #ifdef SIGABORT
 903     if (sigaction(SIGABORT, &sa, NULL) < 0)
 904         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00063) "sigaction(SIGABORT)");
 905 #endif
 906 #ifdef SIGABRT
 907     if (sigaction(SIGABRT, &sa, NULL) < 0)
 908         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00064) "sigaction(SIGABRT)");
 909 #endif
 910 #ifdef SIGILL
 911     if (sigaction(SIGILL, &sa, NULL) < 0)
 912         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00065) "sigaction(SIGILL)");
 913 #endif
 914 #ifdef SIGFPE
 915     if (sigaction(SIGFPE, &sa, NULL) < 0)
 916         ap_log_error(APLOG_MARK, APLOG_WARNING, errno, s, APLOGNO(00066) "sigaction(SIGFPE)");
 917 #endif
 918
 919 #else /* NO_USE_SIGACTION */
 920
 921     apr_signal(SIGSEGV, sig_coredump);
 922 #ifdef SIGBUS
 923     apr_signal(SIGBUS, sig_coredump);
 924 #endif /* SIGBUS */
 925 #ifdef SIGABORT
 926     apr_signal(SIGABORT, sig_coredump);
 927 #endif /* SIGABORT */
 928 #ifdef SIGABRT
 929     apr_signal(SIGABRT, sig_coredump);
 930 #endif /* SIGABRT */
 931 #ifdef SIGILL
 932     apr_signal(SIGILL, sig_coredump);
 933 #endif /* SIGILL */
 934 #ifdef SIGFPE
 935     apr_signal(SIGFPE, sig_coredump);
 936 #endif /* SIGFPE */
 937
 938 #endif /* NO_USE_SIGACTION */
 939
 940     pconf = pconf;
 941     parent_pid = my_pid = getpid();
 942
 943     return APR_SUCCESS;
 944 }
 945
 946 #endif /* WIN32 */