]> git.pld-linux.org Git - packages/apache.git/blame - httpd-2.0.47-metuxmpm-r7.diff
projects / packages / apache.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- wait for httpd to really stop
[packages/apache.git] / httpd-2.0.47-metuxmpm-r7.diff
CommitLineData
2a474d9f
AM		 1diff -ruN httpd-2.0.47/server/mpm/config.m4 httpd-2.0.47-metuxmpm-r7/server/mpm/config.m4
2--- httpd-2.0.47/server/mpm/config.m4 2003-03-11 08:07:52.000000000 +0100
3+++ httpd-2.0.47-metuxmpm-r7/server/mpm/config.m4 2003-09-19 20:18:32.000000000 +0200
4@@ -1,7 +1,7 @@
5 AC_MSG_CHECKING(which MPM to use)
6 AC_ARG_WITH(mpm,
7 APACHE_HELP_STRING(--with-mpm=MPM,Choose the process model for Apache to use.
8- MPM={beos|worker|prefork|mpmt_os2|perchild|leader|threadpool}),[
9+ MPM={beos|worker|prefork|mpmt_os2|perchild|leader|threadpool|metuxmpm}),[
10 APACHE_MPM=$withval
11 ],[
12 if test "x$APACHE_MPM" = "x"; then
13@@ -12,7 +12,7 @@
14
15 apache_cv_mpm=$APACHE_MPM
16
17-if test "$apache_cv_mpm" = "worker" -o "$apache_cv_mpm" = "perchild" -o "$apache_cv_mpm" = "leader" -o "$apache_cv_mpm" = "threadpool" ; then
18+if test "$apache_cv_mpm" = "worker" -o "$apache_cv_mpm" = "perchild" -o "$apache_cv_mpm" = "metuxmpm" -o "$apache_cv_mpm" = "leader" -o "$apache_cv_mpm" = "threadpool" ; then
19 APR_CHECK_APR_DEFINE(APR_HAS_THREADS)
20
21 if test "x$ac_cv_define_APR_HAS_THREADS" = "xno"; then
22@@ -26,7 +26,7 @@
23 APACHE_FAST_OUTPUT(server/mpm/Makefile)
24
25 MPM_NAME=$apache_cv_mpm
26-if test "$MPM_NAME" = "leader" -o "$MPM_NAME" = "threadpool" -o "$MPM_NAME" = "perchild"; then
27+if test "$MPM_NAME" = "leader" -o "$MPM_NAME" = "threadpool" -o "$MPM_NAME" = "perchild" -o "$MPM_NAME" = "metuxmpm"; then
28 AC_MSG_WARN(You have selected an EXPERIMENTAL MPM. Be warned!)
29 MPM_SUBDIR_NAME=experimental/$MPM_NAME
30 else
31diff -ruN httpd-2.0.47/server/mpm/experimental/metuxmpm/Makefile.in httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/Makefile.in
32--- httpd-2.0.47/server/mpm/experimental/metuxmpm/Makefile.in 1970-01-01 01:00:00.000000000 +0100
33+++ httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/Makefile.in 2003-09-19 20:18:32.000000000 +0200
34@@ -0,0 +1,5 @@
35+
36+LTLIBRARY_NAME = libmetuxmpm.la
37+LTLIBRARY_SOURCES = metuxmpm.c
38+
39+include $(top_srcdir)/build/ltlib.mk
40diff -ruN httpd-2.0.47/server/mpm/experimental/metuxmpm/config5.m4 httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/config5.m4
41--- httpd-2.0.47/server/mpm/experimental/metuxmpm/config5.m4 1970-01-01 01:00:00.000000000 +0100
42+++ httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/config5.m4 2003-09-19 20:18:32.000000000 +0200
43@@ -0,0 +1,6 @@
44+dnl ## XXX - Need a more thorough check of the proper flags to use
45+
46+if test "$MPM_NAME" = "metuxmpm" ; then
47+ AC_CHECK_FUNCS(pthread_kill)
48+ APACHE_FAST_OUTPUT(server/mpm/$MPM_SUBDIR_NAME/Makefile)
49+fi
50diff -ruN httpd-2.0.47/server/mpm/experimental/metuxmpm/metuxmpm.c httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/metuxmpm.c
51--- httpd-2.0.47/server/mpm/experimental/metuxmpm/metuxmpm.c 1970-01-01 01:00:00.000000000 +0100
52+++ httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/metuxmpm.c 2003-09-19 20:24:22.000000000 +0200
53@@ -0,0 +1,2575 @@
54+/* ====================================================================
55+ * The Apache Software License, Version 1.1
56+ *
57+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
58+ * reserved.
59+ *
60+ * Redistribution and use in source and binary forms, with or without
61+ * modification, are permitted provided that the following conditions
62+ * are met:
63+ *
64+ * 1. Redistributions of source code must retain the above copyright
65+ * notice, this list of conditions and the following disclaimer.
66+ *
67+ * 2. Redistributions in binary form must reproduce the above copyright
68+ * notice, this list of conditions and the following disclaimer in
69+ * the documentation and/or other materials provided with the
70+ * distribution.
71+ *
72+ * 3. The end-user documentation included with the redistribution,
73+ * if any, must include the following acknowledgment:
74+ * "This product includes software developed by the
75+ * Apache Software Foundation (http://www.apache.org/)."
76+ * Alternately, this acknowledgment may appear in the software itself,
77+ * if and wherever such third-party acknowledgments normally appear.
78+ *
79+ * 4. The names "Apache" and "Apache Software Foundation" must
80+ * not be used to endorse or promote products derived from this
81+ * software without prior written permission. For written
82+ * permission, please contact apache@apache.org.
83+ *
84+ * 5. Products derived from this software may not be called "Apache",
85+ * nor may "Apache" appear in their name, without prior written
86+ * permission of the Apache Software Foundation.
87+ *
88+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
89+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
90+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
91+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
92+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
93+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
94+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
95+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
96+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
97+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
98+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
99+ * SUCH DAMAGE.
100+ * ====================================================================
101+ *
102+ * This software consists of voluntary contributions made by many
103+ * individuals on behalf of the Apache Software Foundation. For more
104+ * information on the Apache Software Foundation, please see
105+ * <http://www.apache.org/>.
106+ *
107+ * Portions of this software are based upon public domain software
108+ * originally written at the National Center for Supercomputing Applications,
109+ * University of Illinois, Urbana-Champaign.
110+ */
111+
112+/* TODO:
113+ + replace pipe_of_death by an generic command interface
114+ + also use this interface for child->child communications
115+ + add support for runtime configuration over this if.
116+ + what to do w/ unassigned vhosts ? who should handle them ?
117+ perhaps we shoudda add an DefaultProcessor option ?
118+ + test, test, test, and test, especially under high load.
119+ + what about persistent links w/ changing vhost ?
120+ should the client then give it back to the multiplexer ?
121+ + add timeouts in multiplexer to prevent local dos attacks
122+ + think about possible vulnarabilities. note that the vhost's user
123+ could ptrace the processor child and play nice games with it.
124+*/
125+
126+/* -- build configuration -- manly for debugging -- */
127+
128+/* #define MPM_METUXMPM_DEBUG */
129+
130+#define MPM_THREAD_ACCEPT_LOCK
131+
132+#include "apr_hash.h"
133+#include "apr_strings.h"
134+#include "apr_pools.h"
135+#include "apr_portable.h"
136+#include "apr_file_io.h"
137+#include "apr_signal.h"
138+
139+#define APR_WANT_IOVEC
140+#include "apr_want.h"
141+
142+#if APR_HAVE_UNISTD_H
143+#include <unistd.h>
144+#endif
145+#if APR_HAVE_SYS_SOCKET_H
146+#include <sys/socket.h>
147+#endif
148+
149+#if !APR_HAS_THREADS
150+#error The metuxmpm MPM requires APR threads, but they are unavailable.
151+#endif
152+
153+#define CORE_PRIVATE
154+
155+#include "ap_config.h"
156+#include "httpd.h"
157+#include "http_main.h"
158+#include "http_log.h"
159+#include "http_config.h" /* for read_config */
160+#include "http_core.h" /* for get_remote_host */
161+#include "http_protocol.h"
162+#include "http_connection.h"
163+#include "ap_mpm.h"
164+#include "unixd.h"
165+#include "mpm_common.h"
166+#include "ap_listen.h"
167+#include "mpm_default.h"
168+#include "mpm.h"
169+#include "scoreboard.h"
170+#include "util_filter.h"
171+#include "apr_poll.h"
172+
173+#include "util_ebcdic.h"
174+
175+#ifdef HAVE_POLL_H
176+#include <poll.h>
177+#endif
178+#ifdef HAVE_SYS_POLL_H
179+#include <sys/poll.h>
180+#endif
181+
182+/* ### should be APR-ized */
183+#include <grp.h>
184+#include <pwd.h>
185+#include <sys/stat.h>
186+#include <sys/un.h>
187+#include <setjmp.h>
188+#ifdef HAVE_SYS_PROCESSOR_H
189+#include <sys/processor.h> /* for bindprocessor() */
190+#endif
191+
192+#ifdef MPM_METUXMPM_DEBUG
193+# define _DBG(text,par...) \
194+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL, \
195+ "(metuxmpm: pid=%d uid=%d) %s(): " text, \
196+ getpid(), getuid(), __FUNCTION__, ##par, 0)
197+
198+# define _TRACE_CALL(text,par...) _DBG("calling " text, ##par)
199+# define _TRACE_RET(text,par...) _DBG("returned from " text, ##par)
200+#else
201+# define _DBG(par...)
202+# define _TRACE_RET(par...)
203+# define _TRACE_CALL(par...)
204+#endif /* MPM_METUXMPM_DEBUG */
205+
206+/* char of death - for signalling children to die */
207+#define AP_metuxmpm_CHAR_OF_DEATH '!'
208+
209+#define metuxmpm_SERVER_CONF(cf) \
210+ ((metuxmpm_server_conf *) ap_get_module_config(cf,&mpm_metuxmpm_module))
211+
212+
213+/*
214+ * Define some magic numbers that we use for the state of the incomming
215+ * request. These must be < 0 so they don't collide with a file descriptor.
216+ */
217+#define AP_metuxmpm_THISCHILD -1
218+#define AP_metuxmpm_OTHERCHILD -2
219+
220+/* Limit on the threads per process. Clients will be locked out if more than
221+ * this * server_limit are needed.
222+ *
223+ * We keep this for one reason it keeps the size of the scoreboard file small
224+ * enough that we can read the whole thing without worrying too much about
225+ * the overhead.
226+ */
227+#ifndef DEFAULT_THREAD_LIMIT
228+#define DEFAULT_THREAD_LIMIT 64
229+#endif
230+
231+/* Admin can't tune ThreadLimit beyond MAX_THREAD_LIMIT. We want
232+ * some sort of compile-time limit to help catch typos.
233+ */
234+#ifndef MAX_THREAD_LIMIT
235+#define MAX_THREAD_LIMIT 20000
236+#endif
237+
238+/* Limit on the total --- clients will be locked out if more servers than
239+ * this are needed. It is intended solely to keep the server from crashing
240+ * when things get out of hand.
241+ *
242+ * We keep a hard maximum number of servers, for two reasons --- first off,
243+ * in case something goes seriously wrong, we want to stop the fork bomb
244+ * short of actually crashing the machine we're running on by filling some
245+ * kernel table. Secondly, it keeps the size of the scoreboard file small
246+ * enough that we can read the whole thing without worrying too much about
247+ * the overhead.
248+ */
249+#ifndef DEFAULT_SERVER_LIMIT
250+#define DEFAULT_SERVER_LIMIT 8
251+#endif
252+
253+/* Admin can't tune ServerLimit beyond MAX_SERVER_LIMIT. We want
254+ * some sort of compile-time limit to help catch typos.
255+ */
256+#ifndef MAX_SERVER_LIMIT
257+#define MAX_SERVER_LIMIT 20000
258+#endif
259+
260+/*
261+ * Actual definitions of config globals
262+ */
263+
264+static int threads_to_start = 0; /* Worker threads per child */
265+static int min_spare_threads = 0;
266+static int max_spare_threads = 0;
267+static int max_threads = 0;
268+static int server_limit = DEFAULT_SERVER_LIMIT;
269+static int first_server_limit;
270+static int thread_limit = DEFAULT_THREAD_LIMIT;
271+static int first_thread_limit;
272+static int changed_limit_at_restart;
273+static int num_childs = 0;
274+static int workers_may_exit = 0;
275+static int requests_this_child;
276+static int num_listensocks = 0;
277+static ap_pod_t *pod;
278+static jmp_buf jmpbuffer;
279+static int thread_overflow_reported = 0;
280+
281+
282+/* === configuration stuff === */
283+/* the server limit is also the size of the server table */
284+static int cf_server_limit = MAX_SERVER_LIMIT; /* This need to be verified. Asbjorn Sannes. */
285+
286+/* -- server process information -- */
287+typedef struct
288+{
289+ uid_t uid;
290+ gid_t gid;
291+ int input; /* The socket descriptor */
292+ int output; /* The socket descriptor */
293+ int type;
294+ int id; /* index in child_info_table */
295+} child_info_t;
296+
297+#define CHILD_TYPE_MULTIPLEXER 1
298+#define CHILD_TYPE_PROCESSOR 2
299+
300+typedef struct
301+{
302+ const char *sockname; /* The base name for the socket */
303+ const char *fullsockname; /* socket base name + extension */
304+ child_info_t* child; /* The client which processes this server */
305+} metuxmpm_server_conf;
306+
307+typedef struct
308+{
309+ int sock_fd;
310+ int status;
311+ jmp_buf jmpbuffer;
312+} thread_info_t;
313+
314+/* Tables used to determine the user and group each child process should
315+ * run as. The hash table is used to correlate a server name with a child
316+ * process.
317+ */
318+static int child_info_table_size;
319+static child_info_t *child_info_table;
320+static thread_info_t *thread_info_table;
321+struct ap_ctable *ap_child_table;
322+
323+/*
324+ * The max child slot ever assigned, preserved across restarts. Necessary
325+ * to deal with NumServers changes across AP_SIG_GRACEFUL restarts. We
326+ * use this value to optimize routines that have to scan the entire child
327+ * table.
328+ *
329+ * XXX - It might not be worth keeping this code in. There aren't very
330+ * many child processes in this MPM.
331+ */
332+int ap_max_daemons_limit = -1;
333+int ap_threads_per_child; /* XXX not part of API! axe it! */
334+
335+module AP_MODULE_DECLARE_DATA mpm_metuxmpm_module;
336+
337+/* -- replace the pipe-of-death by an control socket -- */
338+static apr_file_t *pipe_of_death_in = NULL;
339+static apr_file_t *pipe_of_death_out = NULL;
340+static apr_thread_mutex_t *pipe_of_death_mutex;
341+
342+/* *Non*-shared http_main globals... */
343+
344+server_rec *ap_server_conf;
345+
346+/* one_process --- debugging mode variable; can be set from the command line
347+ * with the -X flag. If set, this gets you the child_main loop running
348+ * in the process which originally started up (no detach, no make_child),
349+ * which is a pretty nice debugging environment. (You'll get a SIGHUP
350+ * early in standalone_main; just continue through. This is the server
351+ * trying to kill off any child processes which it might have lying
352+ * around --- Apache doesn't keep track of their pids, it just sends
353+ * SIGHUP to the process group, ignoring it in the root process.
354+ * Continue through and you'll be fine.).
355+ */
356+
357+static int one_process = 0;
358+
359+#ifdef DEBUG_SIGSTOP
360+int raise_sigstop_flags;
361+#endif
362+
363+static apr_pool_t *pconf; /* Pool for config stuff */
364+static apr_pool_t *pchild; /* Pool for httpd child stuff */
365+static apr_pool_t *thread_pool_parent; /* Parent of per-thread pools */
366+static apr_thread_mutex_t *thread_pool_parent_mutex;
367+
368+static int child_num;
369+static unsigned int my_pid; /* Linux getpid() doesn't work except in
370+ main thread. Use this instead */
371+
372+/* -- stack w/ free thread slot IDs */
373+static int *worker_thread_free_ids;
374+static apr_threadattr_t *worker_thread_attr;
375+
376+/* Keep track of the number of idle worker threads */
377+static int idle_thread_count;
378+static apr_thread_mutex_t *idle_thread_count_mutex;
379+
380+/* Locks for accept serialization */
381+#ifdef NO_SERIALIZED_ACCEPT
382+
383+#define ACCEPT_PROC_MUTEX_INIT APR_SUCCESS
384+#define ACCEPT_PROC_MUTEX_LOCK APR_SUCCESS
385+#define ACCEPT_PROC_MUTEX_UNLOCK APR_SUCCESS
386+#define ACCEPT_PROC_MUTEX_CREATE APR_SUCCESS
387+
388+#else
389+
390+static apr_proc_mutex_t *process_accept_mutex;
391+
392+#define ACCEPT_PROC_MUTEX_LOCK (apr_proc_mutex_lock(process_accept_mutex))
393+#define ACCEPT_PROC_MUTEX_UNLOCK (apr_proc_mutex_unlock(process_accept_mutex))
394+#define ACCEPT_PROC_MUTEX_CREATE (apr_proc_mutex_create(&process_accept_mutex,ap_lock_fname, ap_accept_lock_mech,_pconf))
395+#define ACCEPT_PROC_MUTEX_INIT (apr_proc_mutex_child_init(&process_accept_mutex, ap_lock_fname, pchild));
396+
397+#endif /* NO_SERIALIZED_ACCEPT */
398+
399+static apr_thread_mutex_t *thread_accept_mutex;
400+
401+#ifdef MPM_metuxmpm_THREAD_ACCEPT_LOCK
402+
403+#define THREAD_ACCEPT_LOCK \
404+ _DBG("locking thread_accept_mutex"); \
405+ apr_thread_mutex_lock(thread_accept_mutex); \
406+ _DBG("got thread_accept_mutex locked");
407+
408+#define THREAD_ACCEPT_UNLOCK \
409+ _DBG("unlocking thread_accept_mutex"); \
410+ apr_thread_mutex_unlock(thread_accept_mutex); \
411+ _DBG("got thread_accept_mutex unlocked");
412+#else
413+
414+#define THREAD_ACCEPT_LOCK \
415+ _DBG("omitted locking thread_accept_mutex");
416+
417+#define THREAD_ACCEPT_UNLOCK \
418+ _DBG("omitted unlocking thread_accept_mutex");
419+
420+#endif
421+/* == Keep track of the number of worker threads currently active == */
422+static int worker_thread_count = 0;
423+static apr_thread_mutex_t *worker_thread_count_mutex;
424+
425+static inline int worker_thread_count_get ()
426+{
427+ int x;
428+ apr_thread_mutex_lock(worker_thread_count_mutex);
429+ x = worker_thread_count;
430+ apr_thread_mutex_unlock(worker_thread_count_mutex);
431+ _DBG("worker_thread_count=%d", x);
432+ return x;
433+}
434+
435+static inline int worker_thread_count_add ( int x )
436+{
437+ int y;
438+ apr_thread_mutex_lock(worker_thread_count_mutex);
439+ worker_thread_count += x;
440+ y = worker_thread_count;
441+ apr_thread_mutex_unlock(worker_thread_count_mutex);
442+ _DBG("worker_thread_count=%d (+%d)", y, x);
443+ return y;
444+}
445+
446+/* ------------------------------------------------------------------- */
447+
448+AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
449+{
450+ switch(query_code){
451+ case AP_MPMQ_MAX_DAEMON_USED:
452+ *result = ap_max_daemons_limit;
453+ return APR_SUCCESS;
454+ case AP_MPMQ_IS_THREADED:
455+ *result = AP_MPMQ_DYNAMIC;
456+ return APR_SUCCESS;
457+ case AP_MPMQ_IS_FORKED:
458+ *result = AP_MPMQ_STATIC;
459+ return APR_SUCCESS;
460+ case AP_MPMQ_HARD_LIMIT_DAEMONS:
461+ *result = cf_server_limit;
462+ return APR_SUCCESS;
463+ case AP_MPMQ_HARD_LIMIT_THREADS:
464+ *result = thread_limit;
465+ return APR_SUCCESS;
466+ case AP_MPMQ_MAX_THREADS:
467+ *result = max_threads;
468+ return APR_SUCCESS;
469+ case AP_MPMQ_MIN_SPARE_DAEMONS:
470+ *result = 0;
471+ return APR_SUCCESS;
472+ case AP_MPMQ_MIN_SPARE_THREADS:
473+ *result = min_spare_threads;
474+ return APR_SUCCESS;
475+ case AP_MPMQ_MAX_SPARE_DAEMONS:
476+ *result = 0;
477+ return APR_SUCCESS;
478+ case AP_MPMQ_MAX_SPARE_THREADS:
479+ *result = max_spare_threads;
480+ return APR_SUCCESS;
481+ case AP_MPMQ_MAX_REQUESTS_DAEMON:
482+ *result = ap_max_requests_per_child;
483+ return APR_SUCCESS;
484+ case AP_MPMQ_MAX_DAEMONS:
485+ *result = num_childs;
486+ return APR_SUCCESS;
487+ }
488+ return APR_ENOTIMPL;
489+}
490+
491+/* a clean exit from a child with proper cleanup */
492+static inline int clean_child_exit(int code)
493+{
494+ if (pchild) apr_pool_destroy(pchild);
495+ exit(code);
496+}
497+
498+/* handle all varieties of core dumping signals */
499+static void sig_coredump(int sig)
500+{
501+ chdir(ap_coredump_dir);
502+ apr_signal(sig, SIG_DFL);
503+ kill(getpid(), sig);
504+ /* At this point we've got sig blocked, because we're still inside
505+ * the signal handler. When we leave the signal handler it will
506+ * be unblocked, and we'll take the signal... and coredump or whatever
507+ * is appropriate for this particular Unix. In addition the parent
508+ * will see the real signal we received -- whereas if we called
509+ * abort() here, the parent would only see SIGABRT.
510+ */
511+}
512+
513+static void just_die(int sig)
514+{
515+ clean_child_exit(0);
516+}
517+
518+/*****************************************************************
519+ * Connection structures and accounting...
520+ */
521+
522+/* volatile just in case */
523+static int volatile shutdown_pending;
524+static int volatile restart_pending;
525+static int volatile is_graceful;
526+static int volatile child_fatal;
527+/* we don't currently track ap_my_generation, but mod_status
528+ * references it so it must be defined */
529+ap_generation_t volatile ap_my_generation=0;
530+
531+/*
532+ * ap_start_shutdown() and ap_start_restart(), below, are a first stab at
533+ * functions to initiate shutdown or restart without relying on signals.
534+ * Previously this was initiated in sig_term() and restart() signal handlers,
535+ * but we want to be able to start a shutdown/restart from other sources --
536+ * e.g. on Win32, from the service manager. Now the service manager can
537+ * call ap_start_shutdown() or ap_start_restart() as appropiate. Note that
538+ * these functions can also be called by the child processes, since global
539+ * variables are no longer used to pass on the required action to the parent.
540+ *
541+ * These should only be called from the parent process itself, since the
542+ * parent process will use the shutdown_pending and restart_pending variables
543+ * to determine whether to shutdown or restart. The child process should
544+ * call signal_parent() directly to tell the parent to die -- this will
545+ * cause neither of those variable to be set, which the parent will
546+ * assume means something serious is wrong (which it will be, for the
547+ * child to force an exit) and so do an exit anyway.
548+ */
549+
550+static void ap_start_shutdown(void)
551+{
552+ if (shutdown_pending == 1)
553+ {
554+ /* Um, is this _probably_ not an error, if the user has
555+ * tried to do a shutdown twice quickly, so we won't
556+ * worry about reporting it.
557+ */
558+ return;
559+ }
560+ shutdown_pending = 1;
561+}
562+
563+/* do a graceful restart if graceful == 1 */
564+static void ap_start_restart(int graceful)
565+{
566+ if (restart_pending == 1)
567+ {
568+ /* Probably not an error - don't bother reporting it */
569+ return;
570+ }
571+ restart_pending = 1;
572+ is_graceful = graceful;
573+}
574+
575+static void sig_term(int sig)
576+{
577+ ap_start_shutdown();
578+}
579+
580+static void restart(int sig)
581+{
582+ ap_start_restart(sig == AP_SIG_GRACEFUL);
583+}
584+
585+static void set_signals(void)
586+{
587+#ifndef NO_USE_SIGACTION
588+ struct sigaction sa;
589+
590+ sigemptyset(&sa.sa_mask);
591+ sa.sa_flags = 0;
592+
593+ if (!one_process) {
594+ sa.sa_handler = sig_coredump;
595+#if defined(SA_ONESHOT)
596+ sa.sa_flags = SA_ONESHOT;
597+#elif defined(SA_RESETHAND)
598+ sa.sa_flags = SA_RESETHAND;
599+#endif
600+ if (sigaction(SIGSEGV, &sa, NULL) < 0)
601+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
602+ "sigaction(SIGSEGV)");
603+#ifdef SIGBUS
604+ if (sigaction(SIGBUS, &sa, NULL) < 0)
605+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
606+ "sigaction(SIGBUS)");
607+#endif
608+#ifdef SIGABORT
609+ if (sigaction(SIGABORT, &sa, NULL) < 0)
610+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
611+ "sigaction(SIGABORT)");
612+#endif
613+#ifdef SIGABRT
614+ if (sigaction(SIGABRT, &sa, NULL) < 0)
615+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
616+ "sigaction(SIGABRT)");
617+#endif
618+#ifdef SIGILL
619+ if (sigaction(SIGILL, &sa, NULL) < 0)
620+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
621+ "sigaction(SIGILL)");
622+#endif
623+ sa.sa_flags = 0;
624+ }
625+ sa.sa_handler = sig_term;
626+ if (sigaction(SIGTERM, &sa, NULL) < 0)
627+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
628+ "sigaction(SIGTERM)");
629+#ifdef SIGINT
630+ if (sigaction(SIGINT, &sa, NULL) < 0)
631+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
632+ "sigaction(SIGINT)");
633+#endif
634+#ifdef SIGXCPU
635+ sa.sa_handler = SIG_DFL;
636+ if (sigaction(SIGXCPU, &sa, NULL) < 0)
637+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
638+ "sigaction(SIGXCPU)");
639+#endif
640+#ifdef SIGXFSZ
641+ sa.sa_handler = SIG_DFL;
642+ if (sigaction(SIGXFSZ, &sa, NULL) < 0)
643+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
644+ "sigaction(SIGXFSZ)");
645+#endif
646+#ifdef SIGPIPE
647+ sa.sa_handler = SIG_IGN;
648+ if (sigaction(SIGPIPE, &sa, NULL) < 0)
649+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
650+ "sigaction(SIGPIPE)");
651+#endif
652+
653+ /* we want to ignore HUPs and AP_SIG_GRACEFUL while we're busy
654+ * processing one */
655+ sigaddset(&sa.sa_mask, SIGHUP);
656+ sigaddset(&sa.sa_mask, AP_SIG_GRACEFUL);
657+ sa.sa_handler = restart;
658+ if (sigaction(SIGHUP, &sa, NULL) < 0)
659+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
660+ "sigaction(SIGHUP)");
661+ if (sigaction(AP_SIG_GRACEFUL, &sa, NULL) < 0)
662+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
663+ "sigaction(" AP_SIG_GRACEFUL_STRING ")");
664+#else
665+ if (!one_process)
666+ {
667+ apr_signal(SIGSEGV, sig_coredump);
668+#ifdef SIGBUS
669+ apr_signal(SIGBUS, sig_coredump);
670+#endif /* SIGBUS */
671+#ifdef SIGABORT
672+ apr_signal(SIGABORT, sig_coredump);
673+#endif /* SIGABORT */
674+#ifdef SIGABRT
675+ apr_signal(SIGABRT, sig_coredump);
676+#endif /* SIGABRT */
677+#ifdef SIGILL
678+ apr_signal(SIGILL, sig_coredump);
679+#endif /* SIGILL */
680+#ifdef SIGXCPU
681+ apr_signal(SIGXCPU, SIG_DFL);
682+#endif /* SIGXCPU */
683+#ifdef SIGXFSZ
684+ apr_signal(SIGXFSZ, SIG_DFL);
685+#endif /* SIGXFSZ */
686+ }
687+
688+ apr_signal(SIGTERM, sig_term);
689+#ifdef SIGHUP
690+ apr_signal(SIGHUP, restart);
691+#endif /* SIGHUP */
692+#ifdef AP_SIG_GRACEFUL
693+ apr_signal(AP_SIG_GRACEFUL, restart);
694+#endif /* AP_SIG_GRACEFUL */
695+#ifdef SIGPIPE
696+ apr_signal(SIGPIPE, SIG_IGN);
697+#endif /* SIGPIPE */
698+
699+#endif
700+}
701+
702+/*****************************************************************
703+ * Here follows a long bunch of generic server bookkeeping stuff...
704+ */
705+
706+int ap_graceful_stop_signalled(void)
707+{
708+ /* XXX - Does this really work? - Manoj */
709+ return is_graceful;
710+}
711+
712+/*****************************************************************
713+ * Child process main loop.
714+ */
715+
716+static void process_socket(apr_pool_t *p, apr_socket_t *sock, long conn_id,
717+ apr_bucket_alloc_t *bucket_alloc)
718+{
719+ conn_rec *current_conn;
720+ int sock_fd;
721+ apr_status_t rv;
722+ int thread_num = conn_id % thread_limit;
723+ ap_sb_handle_t *sbh;
724+
725+ if ((rv = apr_os_sock_get(&sock_fd, sock)) != APR_SUCCESS)
726+ {
727+ ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL, "apr_os_sock_get");
728+ }
729+
730+ _DBG("thread_num=%d sock=%ld sock_fd=%d\n", thread_num, sock, sock_fd);
731+
732+ switch (child_info_table[child_num].type)
733+ {
734+ case CHILD_TYPE_MULTIPLEXER:
735+ _DBG("type=MULTIPLEXER");
736+ break;
737+ case CHILD_TYPE_PROCESSOR:
738+ _DBG("type=PROCESSOR");
739+ break;
740+ default:
741+ _DBG("type UNKNOWN!");
742+ }
743+
744+ if (sock_fd >= FD_SETSIZE)
745+ {
746+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,
747+ "new file descriptor %d is too large; you probably need "
748+ "to rebuild Apache with a larger FD_SETSIZE "
749+ "(currently %d)",
750+ sock_fd, FD_SETSIZE);
751+ apr_socket_close(sock);
752+ _DBG("thread_num=%d: exiting with error", thread_num);
753+ return;
754+ }
755+
756+ if (thread_info_table[thread_num].sock_fd < 0)
757+ {
758+ ap_sock_disable_nagle(sock);
759+ }
760+
761+ ap_create_sb_handle(&sbh, p, conn_id / thread_limit, thread_num);
762+ _TRACE_CALL("ap_run_create_connection() [thread_num=%d]", thread_num);
763+ current_conn = ap_run_create_connection(p, ap_server_conf, sock, conn_id,
764+ sbh, bucket_alloc);
765+ _TRACE_RET("ap_run_create_connection() [thread_num=%d]", thread_num);
766+ if (current_conn)
767+ {
768+ _TRACE_CALL("ap_process_connection() [thread_num=%d]", thread_num);
769+ ap_process_connection(current_conn, sock);
770+ _TRACE_RET("ap_process_connection() [thread_num=%d]", thread_num);
771+ _TRACE_CALL("ap_lingering_close() [thread_num=%d]", thread_num);
772+ ap_lingering_close(current_conn);
773+ _TRACE_RET("ap_lingering_close() [thread_num=%d]", thread_num);
774+ }
775+}
776+
777+static metuxmpm_process_connection(conn_rec *conn)
778+{
779+ ap_filter_t *filter;
780+ apr_bucket_brigade *bb;
781+ core_net_rec *net;
782+
783+ _DBG("function entered");
784+
785+ /* -- fetch our sockets from the pool -- */
786+ apr_pool_userdata_get((void **)&bb, "metuxmpm_SOCKETS", conn->pool);
787+ if (bb != NULL)
788+ {
789+ /* -- find the 'core' filter and give the socket data to it -- */
790+ for (filter = conn->output_filters; filter != NULL; filter = filter->next)
791+ {
792+ if (!strcmp(filter->frec->name, "core")) break;
793+ }
794+ if (filter != NULL)
795+ {
796+ net = filter->ctx;
797+ net->in_ctx = apr_palloc(conn->pool, sizeof(*net->in_ctx));
798+ net->in_ctx->b = bb;
799+ }
800+ }
801+ _DBG("leaving (DECLINED)", 0);
802+ return DECLINED;
803+}
804+
805+
806+static void *worker_thread_proc(apr_thread_t *, void *);
807+
808+/* Starts a thread as long as we're below max_threads */
809+static int start_thread(void)
810+{
811+ apr_thread_t *thread;
812+ int rc;
813+ int cnt;
814+
815+ cnt = worker_thread_count_get ();
816+
817+ _DBG("thread count currently: %d", cnt);
818+
819+ if (cnt < max_threads - 1)
820+ {
821+ _TRACE_CALL("apr_thread_create()");
822+ rc = apr_thread_create(&thread, worker_thread_attr, worker_thread_proc,
823+ &worker_thread_free_ids[worker_thread_count], pchild);
824+ _TRACE_RET("apr_thread_create()");
825+ if (rc != APR_SUCCESS)
826+ {
827+ ap_log_error(APLOG_MARK, APLOG_ALERT, rc, ap_server_conf,
828+ "apr_thread_create: unable to create worker thread");
829+ /* In case system resources are maxxed out, we don't want
830+ Apache running away with the CPU trying to fork over and
831+ over and over again if we exit. */
832+ sleep(10);
833+ workers_may_exit = 1;
834+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
835+ return 0;
836+ }
837+ worker_thread_count_add ( 1 );
838+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
839+ _DBG("ok");
840+ return 1;
841+ }
842+
843+ /* we already have too many threads running */
844+ _DBG("too many running threads. aborting");
845+ if (!thread_overflow_reported)
846+ {
847+ ap_log_error(APLOG_MARK, APLOG_ERR, 0,
848+ ap_server_conf,
849+ "server reached MaxThreadsmetuxmpm setting, "
850+ "consider raising the MaxThreadsmetuxmpm or "
851+ "NumServers settings");
852+ thread_overflow_reported = 1;
853+ }
854+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
855+ return 0;
856+}
857+
858+/* Sets workers_may_exit if we received a character on the pipe_of_death */
859+static apr_status_t check_pipe_of_death
860+(
861+ void **csd,
862+ ap_listen_rec *lr,
863+ apr_pool_t *ptrans
864+)
865+{
866+ int ret;
867+ char pipe_read_char;
868+ apr_size_t n = 1;
869+
870+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
871+
872+ if (workers_may_exit) return APR_SUCCESS;
873+
874+ apr_thread_mutex_lock(pipe_of_death_mutex);
875+ ret = apr_recv(lr->sd, &pipe_read_char, &n);
876+ if (APR_STATUS_IS_EAGAIN(ret))
877+ {
878+ /* It lost the lottery. It must continue to suffer
879+ * through a life of servitude. */
880+ }
881+ else
882+ {
883+ if (pipe_read_char != AP_metuxmpm_CHAR_OF_DEATH)
884+ {
885+ _DBG("got wrong char %c", pipe_read_char);
886+ return APR_SUCCESS;
887+ }
888+ /* It won the lottery (or something else is very
889+ * wrong). Embrace death with open arms. */
890+ workers_may_exit = 1;
891+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
892+ }
893+ apr_thread_mutex_unlock(pipe_of_death_mutex);
894+ return APR_SUCCESS;
895+}
896+
897+static apr_status_t receive_from_multiplexer
898+(
899+ void **trans_sock, /* will be filled out w/ the received socket */
900+ ap_listen_rec *lr, /* listener to receive from */
901+ apr_pool_t *ptrans /* transaction wide pool */
902+)
903+{
904+ struct msghdr msg;
905+ struct cmsghdr *cmsg;
906+ char headers[HUGE_STRING_LEN];
907+ char *bodypart;
908+ apr_size_t bodypart_len;
909+ struct iovec iov[2];
910+ int ret, fd_tmp;
911+ apr_os_sock_t ctrl_sock_fd;
912+ apr_os_sock_t trans_sock_fd;
913+
914+ /* -- bucket's, brigades and their allocators */
915+ apr_bucket_alloc_t *alloc = apr_bucket_alloc_create(ptrans);
916+ apr_bucket_brigade *bb = apr_brigade_create(ptrans, alloc);
917+ apr_bucket *bucket;
918+
919+ /* prepare the buffers for receiving data from remote side */
920+ iov[0].iov_base = &bodypart_len;
921+ iov[0].iov_len = sizeof(bodypart_len);
922+ iov[1].iov_base = headers;
923+ iov[1].iov_len = HUGE_STRING_LEN;
924+
925+ cmsg = apr_palloc(ptrans, sizeof(*cmsg) + sizeof(trans_sock_fd));
926+ cmsg->cmsg_len = sizeof(*cmsg) + sizeof(trans_sock_fd);
927+
928+ msg.msg_name = NULL;
929+ msg.msg_namelen = 0;
930+ msg.msg_iov = iov;
931+ msg.msg_iovlen = 2;
932+ msg.msg_control = cmsg;
933+ msg.msg_controllen = cmsg->cmsg_len;
934+
935+ /* -- receive data from socket -- */
936+ apr_os_sock_get(&ctrl_sock_fd, lr->sd);
937+ _DBG("receiving from sock_fd=%d", ctrl_sock_fd);
938+ ret = recvmsg(ctrl_sock_fd, &msg, 0);
939+
940+ /* -- extract socket from the cmsg -- */
941+ memcpy(&trans_sock_fd, CMSG_DATA(cmsg), sizeof(trans_sock_fd));
942+ apr_os_sock_put((apr_socket_t **)trans_sock, &trans_sock_fd, ptrans);
943+ apr_os_sock_get(&fd_tmp, *trans_sock);
944+
945+
946+ _DBG("trans_sock=%ld fdx=%d sock_fd=%d",
947+ *trans_sock, trans_sock_fd, fd_tmp);
948+
949+ _DBG("headers=\"%s\"", headers);
950+
951+ /* -- store received data into an brigade and add
952+ it to the current transaction's pool -- */
953+ bucket = apr_bucket_eos_create(alloc);
954+ APR_BRIGADE_INSERT_HEAD(bb, bucket);
955+ bucket = apr_bucket_socket_create(*trans_sock, alloc);
956+ APR_BRIGADE_INSERT_HEAD(bb, bucket);
957+
958+ /* Receive the bodypart (if there is one) and insert it in the brigade */
959+ if (bodypart_len) {
960+ _DBG("Receiving the bodypart (bodypart_len=%d)", bodypart_len);
961+ bodypart = apr_palloc(ptrans, bodypart_len);
962+ ret = recv(ctrl_sock_fd, bodypart, HUGE_STRING_LEN, 0);
963+
964+ _DBG("bodypart=\"%s\"", bodypart);
965+ bucket = apr_bucket_heap_create(bodypart,
966+ bodypart_len, NULL, alloc);
967+ APR_BRIGADE_INSERT_HEAD(bb, bucket);
968+ } else {
969+ _DBG("There is no bodypart");
970+ }
971+
972+ bucket = apr_bucket_heap_create(headers,
973+ strlen(headers), NULL, alloc);
974+ /* DS: I really don't like that strlen here */
975+
976+ APR_BRIGADE_INSERT_HEAD(bb, bucket);
977+
978+ apr_pool_userdata_set(bb, "metuxmpm_SOCKETS", NULL, ptrans);
979+ _DBG("returning 0");
980+ return 0;
981+}
982+
983+/* idle_thread_count should be incremented before starting a worker_thread */
984+
985+static void *worker_thread_proc(apr_thread_t *thd, void *arg)
986+{
987+ apr_socket_t *sock;
988+ apr_pool_t *tpool; /* Pool for this thread */
989+ apr_pool_t *ptrans; /* Pool for per-transaction stuff */
990+ int srv;
991+ int thread_num = *((int *) arg);
992+ long conn_id = child_num * thread_limit + thread_num;
993+ apr_pollfd_t *pollset;
994+ apr_status_t rv;
995+ ap_listen_rec *lr_walk;
996+ int n;
997+ int thread_cnt;
998+ apr_bucket_alloc_t *bucket_alloc;
999+
1000+ _DBG("function starting");
1001+
1002+ /* === allocate thread pools etc === */
1003+ apr_thread_mutex_lock(thread_pool_parent_mutex);
1004+ apr_pool_create(&tpool, thread_pool_parent);
1005+ apr_thread_mutex_unlock(thread_pool_parent_mutex);
1006+ apr_pool_create(&ptrans, tpool);
1007+
1008+ (void) ap_update_child_status_from_indexes(child_num, thread_num,
1009+ SERVER_STARTING,
1010+ (request_rec *) NULL);
1011+
1012+ bucket_alloc = apr_bucket_alloc_create(apr_thread_pool_get(thd));
1013+
1014+ apr_thread_mutex_lock(idle_thread_count_mutex);
1015+ if (idle_thread_count < max_spare_threads)
1016+ {
1017+ idle_thread_count++;
1018+ _DBG("idle_thread_count: %d", idle_thread_count);
1019+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1020+ }
1021+ else
1022+ {
1023+ _DBG("too many idle threads: %d (max %d)", idle_thread_count, max_spare_threads );
1024+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1025+ goto worker_out;
1026+ }
1027+
1028+ while (!workers_may_exit)
1029+ {
1030+ apr_int16_t event;
1031+
1032+ _DBG("loop. conn_id=%d req_max=%d req_remain=%d",
1033+ conn_id, ap_max_requests_per_child, requests_this_child);
1034+
1035+ ((ap_max_requests_per_child != 0) &&
1036+ (requests_this_child < 1) && (workers_may_exit=1));
1037+
1038+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1039+ if (workers_may_exit) goto worker_out;
1040+
1041+ (void) ap_update_child_status_from_indexes(child_num, thread_num,
1042+ SERVER_READY,
1043+ (request_rec *) NULL);
1044+
1045+ THREAD_ACCEPT_LOCK;
1046+
1047+ /* -- setup pollset -- */
1048+ /* NOTE: we do _not_ do this upwards anylonger */
1049+ apr_poll_setup(&pollset, num_listensocks, tpool);
1050+ apr_poll_setup(&pollset, num_listensocks, ptrans);
1051+ for(lr_walk = ap_listeners; lr_walk != NULL; lr_walk = lr_walk->next)
1052+ {
1053+ int fd;
1054+ apr_poll_socket_add(pollset, lr_walk->sd, APR_POLLIN);
1055+ apr_os_sock_get(&fd, lr_walk->sd);
1056+ _DBG("adding fd %d to pollset", fd);
1057+ }
1058+
1059+ if (workers_may_exit) goto worker_out;
1060+ _TRACE_CALL("apr_poll()");
1061+ srv = apr_poll(pollset, num_listensocks, &n, -1);
1062+ _TRACE_RET("apr_poll()");
1063+
1064+ if (srv != APR_SUCCESS)
1065+ {
1066+ if (APR_STATUS_IS_EINTR(srv))
1067+ {
1068+ _DBG("apr_poll() has been interrupted", 0);
1069+ THREAD_ACCEPT_UNLOCK;
1070+ continue;
1071+ }
1072+
1073+ /* apr_poll() will only return errors in catastrophic
1074+ * circumstances. Let's try exiting gracefully, for now. */
1075+ ap_log_error(APLOG_MARK, APLOG_ERR, srv, (const server_rec *)
1076+ ap_server_conf, "apr_poll: (listen)");
1077+ workers_may_exit = 1;
1078+ _DBG("poll error!");
1079+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1080+ THREAD_ACCEPT_UNLOCK;
1081+ goto worker_out;
1082+ }
1083+
1084+ /* find a listener */
1085+ _DBG("looking for an listener");
1086+ for (lr_walk=ap_listeners; lr_walk!=NULL; lr_walk = lr_walk->next)
1087+ {
1088+ int fd_tmp;
1089+ apr_os_sock_get(&fd_tmp, lr_walk->sd);
1090+ _DBG(" ... trying w/ fd=%d", fd_tmp);
1091+ apr_poll_revents_get(&event, lr_walk->sd, pollset);
1092+ if (event & (APR_POLLIN))
1093+ {
1094+ THREAD_ACCEPT_UNLOCK;
1095+ goto got_fd;
1096+ }
1097+ if (event & (APR_POLLERR))
1098+ {
1099+ ap_log_error(APLOG_MARK, APLOG_EMERG, rv, ap_server_conf,
1100+ "got POLLERR in line 870");
1101+ }
1102+ }
1103+
1104+ THREAD_ACCEPT_UNLOCK;
1105+ _DBG("WARN: did not find the right listener");
1106+ sleep ( 1 );
1107+ continue;
1108+
1109+ got_fd:
1110+ _DBG("input available ... resetting socket.");
1111+ sock = NULL; /* important! */
1112+
1113+ _TRACE_CALL("accept_func()");
1114+ rv = lr_walk->accept_func((void*)&sock, lr_walk, ptrans);
1115+ _TRACE_RET("accept_func()");
1116+
1117+ if (rv == APR_EGENERAL)
1118+ {
1119+ /* E[NM]FILE, ENOMEM, etc */
1120+ _DBG("there was some error." );
1121+ workers_may_exit = 1;
1122+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1123+ break;
1124+ }
1125+
1126+ apr_thread_mutex_lock(idle_thread_count_mutex);
1127+ if (idle_thread_count > min_spare_threads)
1128+ {
1129+ idle_thread_count--;
1130+ }
1131+ else
1132+ {
1133+ if (!start_thread())
1134+ {
1135+ idle_thread_count--;
1136+ }
1137+ }
1138+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1139+
1140+ if (!setjmp(thread_info_table[thread_num].jmpbuffer))
1141+ {
1142+ _DBG("marked jmpbufffer");
1143+ _TRACE_CALL("process_socket()");
1144+ process_socket(ptrans, sock, conn_id, bucket_alloc);
1145+ _TRACE_RET("process_socket()");
1146+ }
1147+ else
1148+ {
1149+ _DBG("landed from longjmp");
1150+ thread_info_table[thread_num].sock_fd = AP_metuxmpm_THISCHILD;
1151+ }
1152+ requests_this_child--;
1153+ apr_pool_clear(ptrans);
1154+ }
1155+
1156+ _DBG("thread loop finished");
1157+worker_out:
1158+ _DBG("this thread's work is done ... workers_may_exit=%d");
1159+
1160+ /* == think about it == */
1161+ apr_thread_mutex_lock(idle_thread_count_mutex);
1162+ idle_thread_count--;
1163+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1164+
1165+ /* == */
1166+ apr_thread_mutex_lock(thread_pool_parent_mutex);
1167+ ap_update_child_status_from_indexes(child_num, thread_num, SERVER_DEAD,
1168+ (request_rec *) NULL);
1169+ apr_pool_destroy(tpool);
1170+ apr_thread_mutex_unlock(thread_pool_parent_mutex);
1171+
1172+ thread_cnt = worker_thread_count_add ( -1 );
1173+ worker_thread_free_ids[thread_cnt] = thread_num;
1174+ if (!thread_cnt)
1175+ {
1176+ /* All the threads have exited, now finish the shutdown process
1177+ * by signalling the sigwait thread */
1178+ _DBG("all workers have quit. killing myself (%d) with SIGTERM", my_pid);
1179+ kill(my_pid, SIGTERM);
1180+ }
1181+ else
1182+ {
1183+ _DBG("this is not the time to die - %d threads are still alive", thread_cnt);
1184+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1185+ }
1186+
1187+ apr_bucket_alloc_destroy(bucket_alloc);
1188+ _DBG("leaving. good bye");
1189+ return NULL;
1190+}
1191+
1192+
1193+
1194+/* Set group privileges.
1195+ *
1196+ * Note that we use the username as set in the config files, rather than
1197+ * the lookup of to uid --- the same uid may have multiple passwd entries,
1198+ * with different sets of groups for each.
1199+ */
1200+
1201+static int set_group_privs(uid_t uid, gid_t gid)
1202+{
1203+ if (!geteuid())
1204+ {
1205+ const char *name;
1206+
1207+ /* Get username if passed as a uid */
1208+
1209+ struct passwd *ent;
1210+
1211+ if ((ent = getpwuid(uid)) == NULL)
1212+ {
1213+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1214+ "getpwuid: couldn't determine user name from uid %u, "
1215+ "you probably need to modify the User directive",
1216+ (unsigned)uid);
1217+ return -1;
1218+ }
1219+
1220+ name = ent->pw_name;
1221+
1222+ /*
1223+ * Set the GID before initgroups(), since on some platforms
1224+ * setgid() is known to zap the group list.
1225+ */
1226+ if (setgid(gid) == -1)
1227+ {
1228+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1229+ "setgid: unable to set group id to Group %u",
1230+ (unsigned)gid);
1231+ return -1;
1232+ }
1233+
1234+ /* Reset `groups' attributes. */
1235+
1236+ if (initgroups(name, gid) == -1)
1237+ {
1238+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1239+ "initgroups: unable to set groups for User %s "
1240+ "and Group %u", name, (unsigned)gid);
1241+ return -1;
1242+ }
1243+ }
1244+ return 0;
1245+}
1246+
1247+
1248+static int metuxmpm_setup_child(int childnum)
1249+{
1250+ child_info_t *ug = &child_info_table[childnum];
1251+
1252+ if (ug->uid == -1 && ug->gid == -1) {
1253+ return unixd_setup_child();
1254+ }
1255+ if (set_group_privs(ug->uid, ug->gid)) {
1256+ return -1;
1257+ }
1258+ /* Only try to switch if we're running as root */
1259+ if (!geteuid()
1260+ && (
1261+#ifdef _OSD_POSIX
1262+ os_init_job_environment(server_conf, unixd_config.user_name,
1263+ one_process) != 0 ||
1264+#endif
1265+ setuid(ug->uid) == -1)) {
1266+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1267+ "setuid: unable to change to uid: %ld",
1268+ (long) ug->uid);
1269+ return -1;
1270+ }
1271+ return 0;
1272+}
1273+
1274+static int check_signal(int signum)
1275+{
1276+ _DBG("signum=%d", signum);
1277+ switch (signum) {
1278+ case SIGTERM:
1279+ case SIGINT:
1280+ just_die(signum);
1281+ return 1;
1282+ }
1283+ return 0;
1284+}
1285+
1286+typedef struct metuxmpm_header
1287+{
1288+ char *headers;
1289+ apr_pool_t *p;
1290+} metuxmpm_header;
1291+
1292+/* Send a single HTTP header field to the client. Note that this function
1293+ * is used in calls to table_do(), so their interfaces are co-dependent.
1294+ * In other words, don't change this one without checking table_do in alloc.c.
1295+ * It returns true unless there was a write error of some kind.
1296+ */
1297+static int metuxmpm_header_field(metuxmpm_header *h,
1298+ const char *fieldname, const char *fieldval)
1299+{
1300+ apr_pstrcat(h->p, h->headers, fieldname, ": ", fieldval, CRLF, NULL);
1301+ return 1;
1302+}
1303+
1304+static inline ap_listen_rec* listen_add ( apr_pool_t* pool, apr_socket_t *sock, void* accept_func )
1305+{
1306+ ap_listen_rec *lr_walk, *lr_new;
1307+
1308+ _DBG("function started");
1309+ /* -- create an new listener for this child -- */
1310+ lr_new = apr_palloc(pool, sizeof(*lr_new));
1311+ lr_new->sd = sock;
1312+ lr_new->active = 1;
1313+ lr_new->accept_func = accept_func;
1314+ lr_new->next = NULL;
1315+
1316+ /* -- add the new listener_rec into the list -- */
1317+ /* FIXME: should we somehow lock this list ? */
1318+ if (lr_walk = ap_listeners)
1319+ {
1320+ while (lr_walk->next) lr_walk = lr_walk->next;
1321+ lr_walk->next = lr_new;
1322+ }
1323+ else
1324+ {
1325+ ap_listeners = lr_walk = lr_new;
1326+ }
1327+ num_listensocks++;
1328+ return lr_new;
1329+}
1330+
1331+static inline void listen_clear ()
1332+{
1333+ ap_listen_rec *lr_walk;
1334+
1335+ _DBG("function started");
1336+
1337+ /* FIXME: should we somehow lock this list ? */
1338+ while (ap_listeners)
1339+ {
1340+ lr_walk = ap_listeners->next;
1341+ apr_socket_close(ap_listeners->sd);
1342+ ap_listeners = lr_walk;
1343+ }
1344+ num_listensocks=0;
1345+}
1346+
1347+/* -- main routine of an child process -- */
1348+static void child_main(int child_num_arg)
1349+{
1350+ int i;
1351+ apr_status_t rv;
1352+ apr_socket_t *sock = NULL;
1353+
1354+ my_pid = getpid();
1355+ child_num = child_num_arg;
1356+
1357+ _DBG("sock_fd_in=%d sock_fd_out=%d", child_info_table[child_num].input, child_info_table[child_num].output );
1358+
1359+ /* -- allocate an new pool for us -- */
1360+ apr_pool_create(&pchild, pconf);
1361+
1362+ switch (child_info_table[child_num].type)
1363+ {
1364+ case CHILD_TYPE_MULTIPLEXER:
1365+ _DBG("MULTIPLEXER %d", child_num);
1366+ break;
1367+
1368+ case CHILD_TYPE_PROCESSOR:
1369+ _DBG("PROCESSOR %d", child_num);
1370+
1371+ /* -- create new listener to receive from multiplexer -- */
1372+ apr_os_sock_put(&sock, &child_info_table[child_num].input, pconf);
1373+ listen_clear ();
1374+ listen_add ( pconf, sock, receive_from_multiplexer );
1375+ break;
1376+
1377+ default:
1378+ _DBG("unspecified child type for %d sleeping a while ...", child_num);
1379+ sleep ( 5 );
1380+ return;
1381+ }
1382+ /*stuff to do before we switch id's, so we have permissions.*/
1383+
1384+ /* -- init child process (uid switching etc) -- */
1385+ (metuxmpm_setup_child(child_num) && clean_child_exit(APEXIT_CHILDFATAL));
1386+ ap_run_child_init(pchild, ap_server_conf);
1387+
1388+ /*done with init critical section */
1389+
1390+ apr_setup_signal_thread();
1391+
1392+ requests_this_child = ap_max_requests_per_child;
1393+
1394+ /* Setup worker threads */
1395+
1396+ _DBG("setting up worker threads ... " );
1397+ ((threads_to_start > max_threads) && (threads_to_start = max_threads));
1398+ idle_thread_count = threads_to_start;
1399+ workers_may_exit = 0;
1400+ worker_thread_count = 0;
1401+ worker_thread_free_ids = (int *)apr_pcalloc(pchild, thread_limit * sizeof(int));
1402+ for (i = 0; i < max_threads; i++)
1403+ {
1404+ worker_thread_free_ids[i] = i;
1405+ }
1406+ apr_pool_create(&thread_pool_parent, pchild);
1407+ apr_thread_mutex_create(&thread_pool_parent_mutex,
1408+ APR_THREAD_MUTEX_DEFAULT, pchild);
1409+ apr_thread_mutex_create(&idle_thread_count_mutex,
1410+ APR_THREAD_MUTEX_DEFAULT, pchild);
1411+ apr_thread_mutex_create(&worker_thread_count_mutex,
1412+ APR_THREAD_MUTEX_DEFAULT, pchild);
1413+ apr_thread_mutex_create(&pipe_of_death_mutex,
1414+ APR_THREAD_MUTEX_DEFAULT, pchild);
1415+ apr_thread_mutex_create(&thread_accept_mutex,
1416+ APR_THREAD_MUTEX_DEFAULT, pchild);
1417+
1418+ apr_threadattr_create(&worker_thread_attr, pchild);
1419+ apr_threadattr_detach_set(worker_thread_attr, 1);
1420+
1421+ /* We are creating worker threads right now */
1422+ for (i=0; i < threads_to_start; i++)
1423+ {
1424+ /* start_thread shouldn't fail here */
1425+ _TRACE_CALL("start_thread()");
1426+ if (!start_thread()) break;
1427+ _TRACE_RET("start_thread()");
1428+ }
1429+
1430+ _TRACE_CALL("apr_signal_thread()");
1431+ apr_signal_thread(check_signal);
1432+ _TRACE_RET("apr_signal_thread");
1433+}
1434+
1435+static int make_child(server_rec *s, int slot)
1436+{
1437+ int pid;
1438+
1439+ switch (child_info_table[slot].type)
1440+ {
1441+ case CHILD_TYPE_MULTIPLEXER: break;
1442+ case CHILD_TYPE_PROCESSOR: break;
1443+ default:
1444+ _DBG("no valid client in slot %d", slot);
1445+ sleep(1);
1446+ return 0;
1447+ }
1448+
1449+ if (slot + 1 > ap_max_daemons_limit)
1450+ {
1451+ ap_max_daemons_limit = slot + 1;
1452+ }
1453+
1454+ (void) ap_update_child_status_from_indexes(slot, 0, SERVER_STARTING,
1455+ (request_rec *) NULL);
1456+
1457+ if ((pid = fork()) == -1)
1458+ {
1459+ ap_log_error(APLOG_MARK, APLOG_ERR, errno, s,
1460+ "fork: Unable to fork new process");
1461+ /* In case system resources are maxxed out, we don't want
1462+ * Apache running away with the CPU trying to fork over and
1463+ * over and over again. */
1464+ sleep(10);
1465+
1466+ return -1;
1467+ }
1468+
1469+ if (!pid)
1470+ {
1471+#ifdef HAVE_BINDPROCESSOR
1472+ /* By default, AIX binds to a single processor. This bit unbinds
1473+ * children which will then bind to another CPU.
1474+ */
1475+ int status = bindprocessor(BINDPROCESS, (int)getpid(),
1476+ PROCESSOR_CLASS_ANY);
1477+ if (status != OK) {
1478+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
1479+ ap_server_conf, "processor unbind failed %d", status);
1480+ }
1481+#endif
1482+
1483+ RAISE_SIGSTOP(MAKE_CHILD);
1484+
1485+ /* XXX - For an unthreaded server, a signal handler will be necessary
1486+ * apr_signal(SIGTERM, just_die);
1487+ */
1488+ child_main(slot);
1489+ clean_child_exit(0);
1490+ }
1491+ /* else */
1492+ ap_child_table[slot].pid = pid;
1493+ ap_child_table[slot].status = SERVER_ALIVE;
1494+
1495+ return 0;
1496+}
1497+
1498+/* start up a bunch of children */
1499+static int startup_children(int number_to_start)
1500+{
1501+ int i;
1502+
1503+ for (i = 0; number_to_start && i < num_childs; ++i)
1504+ {
1505+ if (ap_child_table[i].pid) continue;
1506+ if (make_child(ap_server_conf, i) < 0) break;
1507+ --number_to_start;
1508+ }
1509+ return number_to_start;
1510+}
1511+
1512+
1513+/*
1514+ * spawn_rate is the number of children that will be spawned on the
1515+ * next maintenance cycle if there aren't enough servers. It is
1516+ * doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
1517+ * without the need to spawn.
1518+ */
1519+static int spawn_rate = 1;
1520+#ifndef MAX_SPAWN_RATE
1521+#define MAX_SPAWN_RATE (32)
1522+#endif
1523+static int hold_off_on_exponential_spawning;
1524+
1525+static void perform_child_maintenance(void)
1526+{
1527+ int i;
1528+ int free_length;
1529+ int free_slots[MAX_SPAWN_RATE];
1530+ int last_non_dead = -1;
1531+
1532+ /* initialize the free_list */
1533+ free_length = 0;
1534+
1535+ for (i = 0; i < num_childs; ++i)
1536+ {
1537+ if (ap_child_table[i].pid == 0)
1538+ {
1539+ if (free_length < spawn_rate)
1540+ {
1541+ free_slots[free_length] = i;
1542+ ++free_length;
1543+ }
1544+ }
1545+ else
1546+ {
1547+ last_non_dead = i;
1548+ }
1549+
1550+ if (i >= ap_max_daemons_limit && free_length >= spawn_rate)
1551+ {
1552+ break;
1553+ }
1554+ }
1555+ ap_max_daemons_limit = last_non_dead + 1;
1556+
1557+ if (free_length > 0)
1558+ {
1559+ for (i = 0; i < free_length; ++i)
1560+ {
1561+ _TRACE_CALL("make_child()");
1562+ make_child(ap_server_conf, free_slots[i]);
1563+ _TRACE_RET("make_child()");
1564+ }
1565+ /* the next time around we want to spawn twice as many if this
1566+ * wasn't good enough, but not if we've just done a graceful
1567+ */
1568+ if (hold_off_on_exponential_spawning)
1569+ {
1570+ --hold_off_on_exponential_spawning;
1571+ }
1572+ else if (spawn_rate < MAX_SPAWN_RATE)
1573+ {
1574+ spawn_rate *= 2;
1575+ }
1576+ }
1577+ else
1578+ {
1579+ spawn_rate = 1;
1580+ }
1581+}
1582+
1583+static void server_main_loop(int remaining_children_to_start)
1584+{
1585+ apr_exit_why_e exitwhy;
1586+ apr_proc_t pid;
1587+ int child_slot;
1588+ int status;
1589+ int i;
1590+ static int l=0;
1591+
1592+ while (!restart_pending && !shutdown_pending)
1593+ {
1594+ ap_wait_or_timeout(&exitwhy, &status, &pid, pconf);
1595+
1596+ if (pid.pid != -1)
1597+ {
1598+ if (ap_process_child_status(&pid, exitwhy, status)==APEXIT_CHILDFATAL)
1599+ {
1600+ _DBG("shutdown pending ...");
1601+ shutdown_pending = 1;
1602+ child_fatal = 1;
1603+ return;
1604+ }
1605+ /* non-fatal death... note that it's gone in the child table and
1606+ * clean out the status table. */
1607+ _DBG("child has #%d died ...", child_slot);
1608+ child_slot = -1;
1609+ for (i = 0; i < ap_max_daemons_limit; ++i)
1610+ {
1611+ if (ap_child_table[i].pid == pid.pid)
1612+ {
1613+ child_slot = i;
1614+ break;
1615+ }
1616+ }
1617+ if (child_slot >= 0)
1618+ {
1619+ ap_child_table[child_slot].pid = 0;
1620+ ap_update_child_status_from_indexes(child_slot, i, SERVER_DEAD,
1621+ (request_rec *) NULL);
1622+
1623+
1624+ if (remaining_children_to_start && (child_slot < num_childs))
1625+ {
1626+ /* we're still doing a 1-for-1 replacement of dead
1627+ * children with new children
1628+ */
1629+ _DBG("replacing by new child ...");
1630+ make_child(ap_server_conf, child_slot);
1631+ --remaining_children_to_start;
1632+ }
1633+#if APR_HAS_OTHER_CHILD
1634+ }
1635+ else if (apr_proc_other_child_read(&pid, status) == 0)
1636+ {
1637+ /* handled */
1638+#endif
1639+ }
1640+ else if (is_graceful)
1641+ {
1642+ /* Great, we've probably just lost a slot in the
1643+ * child table. Somehow we don't know about this
1644+ * child.
1645+ */
1646+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
1647+ ap_server_conf,
1648+ "long lost child came home! (pid %ld)",
1649+ (long)pid.pid);
1650+ }
1651+ /* Don't perform idle maintenance when a child dies,
1652+ * only do it when there's a timeout. Remember only a
1653+ * finite number of children can die, and it's pretty
1654+ * pathological for a lot to die suddenly.
1655+ */
1656+ continue;
1657+ }
1658+ else if (remaining_children_to_start)
1659+ {
1660+ /* we hit a 1 second timeout in which none of the previous
1661+ * generation of children needed to be reaped... so assume
1662+ * they're all done, and pick up the slack if any is left.
1663+ */
1664+ _TRACE_CALL("startup_children()");
1665+ remaining_children_to_start = startup_children(remaining_children_to_start);
1666+ _TRACE_RET("startup_children()");
1667+ /* In any event we really shouldn't do the code below because
1668+ * few of the servers we just started are in the IDLE state
1669+ * yet, so we'd mistakenly create an extra server.
1670+ */
1671+ continue;
1672+ }
1673+
1674+ perform_child_maintenance();
1675+ }
1676+}
1677+
1678+int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
1679+{
1680+ int remaining_children_to_start;
1681+ int i;
1682+ int fd;
1683+ apr_status_t rv;
1684+ apr_size_t one = 1;
1685+ apr_socket_t *sock = NULL;
1686+
1687+ ap_log_pid(pconf, ap_pid_fname);
1688+
1689+ first_server_limit = server_limit;
1690+ first_thread_limit = thread_limit;
1691+ if (changed_limit_at_restart)
1692+ {
1693+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
1694+ "WARNING: Attempt to change ServerLimit or ThreadLimit "
1695+ "ignored during restart");
1696+ changed_limit_at_restart = 0;
1697+ }
1698+
1699+ ap_server_conf = s;
1700+
1701+ /* Initialize cross-process accept lock */
1702+ ap_lock_fname = apr_psprintf(_pconf, "%s.%u",
1703+ ap_server_root_relative(_pconf, ap_lock_fname),
1704+ my_pid);
1705+ rv = ACCEPT_PROC_MUTEX_CREATE;
1706+ if (rv != APR_SUCCESS)
1707+ {
1708+ ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
1709+ "Couldn't create cross-process lock");
1710+ return 1;
1711+ }
1712+
1713+ if (!is_graceful)
1714+ {
1715+ if (ap_run_pre_mpm(s->process->pool, SB_SHARED) != OK)
1716+ {
1717+ return 1;
1718+ }
1719+ }
1720+ /* Initialize the child table */
1721+ if (!is_graceful)
1722+ {
1723+ for (i = 0; i < server_limit; i++)
1724+ {
1725+ ap_child_table[i].pid = 0;
1726+ }
1727+ }
1728+
1729+ /* We need to put the new listeners at the end of the ap_listeners
1730+ * list. If we don't, then the pool will be cleared before the
1731+ * open_logs phase is called for the second time, and ap_listeners
1732+ * will have only invalid data. If that happens, then the sockets
1733+ * that we opened using make_sock() will be lost, and the server
1734+ * won't start.
1735+ */
1736+ apr_os_file_get(&fd, pipe_of_death_in);
1737+ apr_os_sock_put(&sock, &fd, pconf);
1738+
1739+ listen_add ( pconf, sock, check_pipe_of_death );
1740+ set_signals();
1741+
1742+ /* If we're doing a graceful_restart then we're going to see a lot
1743+ * of children exiting immediately when we get into the main loop
1744+ * below (because we just sent them AP_SIG_GRACEFUL). This happens
1745+ * pretty rapidly... and for each one that exits we'll start a new one
1746+ * until we reach at least daemons_min_free. But we may be permitted to
1747+ * start more than that, so we'll just keep track of how many we're
1748+ * supposed to start up without the 1 second penalty between each fork.
1749+ */
1750+ remaining_children_to_start = num_childs;
1751+ if (!is_graceful) {
1752+ remaining_children_to_start = \
1753+ startup_children(remaining_children_to_start);
1754+ }
1755+ else {
1756+ /* give the system some time to recover before kicking into
1757+ * exponential mode */
1758+ hold_off_on_exponential_spawning = 10;
1759+ }
1760+
1761+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
1762+ "%s configured -- resuming normal operations",
1763+ ap_get_server_version());
1764+ ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
1765+ "Server built: %s", ap_get_server_built());
1766+#ifdef AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
1767+#ifdef NO_SERIALIZED_ACCEPT
1768+ _DBG("AcceptMutex: n/a (compiled w/ NO_SERIALIZED_ACCEPT)", 0 );
1769+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
1770+ "AcceptMutex: n/a (compiled w/ NO_SERIALIZED_ACCEPT)" );
1771+#else
1772+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
1773+ "AcceptMutex: %s (default: %s)",
1774+ apr_proc_mutex_name(process_accept_mutex),
1775+ apr_proc_mutex_defname());
1776+#endif
1777+#endif
1778+ restart_pending = shutdown_pending = 0;
1779+
1780+ server_main_loop(remaining_children_to_start);
1781+
1782+ if (shutdown_pending)
1783+ {
1784+ /* Time to gracefully shut down:
1785+ * Kill child processes, tell them to call child_exit, etc...
1786+ */
1787+ if (unixd_killpg(getpgrp(), SIGTERM) < 0)
1788+ {
1789+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
1790+ "killpg SIGTERM");
1791+ }
1792+ ap_reclaim_child_processes(1); /* Start with SIGTERM */
1793+
1794+ if (!child_fatal)
1795+ {
1796+ /* cleanup pid file on normal shutdown */
1797+ const char *pidfile = NULL;
1798+ pidfile = ap_server_root_relative (pconf, ap_pid_fname);
1799+ if (pidfile != NULL && unlink(pidfile) == 0) {
1800+ ap_log_error(APLOG_MARK, APLOG_INFO, 0,
1801+ ap_server_conf,
1802+ "removed PID file %s (pid=%ld)",
1803+ pidfile, (long)getpid());
1804+ }
1805+
1806+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1807+ ap_server_conf, "caught SIGTERM, shutting down");
1808+ }
1809+ return 1;
1810+ }
1811+
1812+ /* we've been told to restart */
1813+ apr_signal(SIGHUP, SIG_IGN);
1814+
1815+ if (one_process) return 1; /* not worth thinking about */
1816+
1817+ if (is_graceful)
1818+ {
1819+ char char_of_death = AP_metuxmpm_CHAR_OF_DEATH;
1820+
1821+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1822+ ap_server_conf, AP_SIG_GRACEFUL_STRING " received. "
1823+ "Doing graceful restart");
1824+
1825+ /* This is mostly for debugging... so that we know what is still
1826+ * gracefully dealing with existing request.
1827+ */
1828+
1829+ for (i = 0; i < num_childs; ++i)
1830+ {
1831+ ((ap_child_table[i].pid) && (ap_child_table[i].status = SERVER_DYING));
1832+ }
1833+
1834+ /* give the children the signal to die */
1835+ for (i = 0; i < num_childs;)
1836+ {
1837+ if ((rv = apr_file_write(pipe_of_death_out, &char_of_death,&one)) != APR_SUCCESS)
1838+ {
1839+ if (APR_STATUS_IS_EINTR(rv)) continue;
1840+ ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf,
1841+ "write pipe_of_death");
1842+ }
1843+ i++;
1844+ }
1845+ }
1846+ else
1847+ {
1848+ /* Kill 'em all. Since the child acts the same on the parents SIGTERM
1849+ * and a SIGHUP, we may as well use the same signal, because some user
1850+ * pthreads are stealing signals from us left and right.
1851+ */
1852+ if (unixd_killpg(getpgrp(), SIGTERM) < 0)
1853+ {
1854+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
1855+ "killpg SIGTERM");
1856+ }
1857+ ap_reclaim_child_processes(1); /* Start with SIGTERM */
1858+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1859+ ap_server_conf, "SIGHUP received. Attempting to restart");
1860+ }
1861+ return 0;
1862+}
1863+
1864+/* This really should be a post_config hook, but the error log is already
1865+ * redirected by that point, so we need to do this in the open_logs phase.
1866+ */
1867+static int metuxmpm_open_logs(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
1868+{
1869+ apr_status_t rv;
1870+
1871+ pconf = p;
1872+ ap_server_conf = s;
1873+
1874+ _DBG("port=%d", ap_server_conf->port);
1875+
1876+ if ((num_listensocks = ap_setup_listeners(ap_server_conf)) < 1) {
1877+ ap_log_error(APLOG_MARK, APLOG_ALERT|APLOG_STARTUP, 0,
1878+ NULL, "metuxmpm_open_logs(): no listening sockets available, shutting down");
1879+ return DONE;
1880+ }
1881+
1882+ ap_log_pid(pconf, ap_pid_fname);
1883+
1884+ if ((rv = ap_mpm_pod_open(pconf, &pod))) {
1885+ ap_log_error(APLOG_MARK, APLOG_CRIT|APLOG_STARTUP, rv, NULL,
1886+ "Could not open pipe-of-death.");
1887+ return DONE;
1888+ }
1889+
1890+ if ((rv = apr_file_pipe_create(&pipe_of_death_in, &pipe_of_death_out,
1891+ pconf)) != APR_SUCCESS) {
1892+ ap_log_error(APLOG_MARK, APLOG_ERR, rv,
1893+ (const server_rec*) ap_server_conf,
1894+ "apr_file_pipe_create (apipe_of_death)");
1895+ exit(1);
1896+ }
1897+ if ((rv = apr_file_pipe_timeout_set(pipe_of_death_in, 0)) != APR_SUCCESS) {
1898+ ap_log_error(APLOG_MARK, APLOG_ERR, rv,
1899+ (const server_rec*) ap_server_conf,
1900+ "apr_file_pipe_timeout_set (pipe_of_death)");
1901+ exit(1);
1902+ }
1903+
1904+ return OK;
1905+}
1906+
1907+static int metuxmpm_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
1908+{
1909+ static int restart_num = 0;
1910+ int no_detach, debug, foreground;
1911+ ap_directive_t *pdir;
1912+ int i;
1913+ int tmp_server_limit = DEFAULT_SERVER_LIMIT;
1914+ int tmp_thread_limit = DEFAULT_THREAD_LIMIT;
1915+ apr_status_t rv;
1916+
1917+ debug = ap_exists_config_define("DEBUG");
1918+
1919+ if (debug) {
1920+ foreground = one_process = 1;
1921+ no_detach = 0;
1922+ }
1923+ else {
1924+ one_process = ap_exists_config_define("ONE_PROCESS");
1925+ no_detach = ap_exists_config_define("NO_DETACH");
1926+ foreground = ap_exists_config_define("FOREGROUND");
1927+ }
1928+
1929+ /* FIXME */
1930+/* no_detach = 0;
1931+ foreground = 0; */
1932+
1933+ /* sigh, want this only the second time around */
1934+ if (restart_num++ == 1)
1935+ {
1936+ is_graceful = 0;
1937+
1938+ if (!one_process && !foreground)
1939+ {
1940+ rv = apr_proc_detach(no_detach ? APR_PROC_DETACH_FOREGROUND
1941+ : APR_PROC_DETACH_DAEMONIZE);
1942+ if (rv != APR_SUCCESS) {
1943+ ap_log_error(APLOG_MARK, APLOG_CRIT, rv, NULL,
1944+ "apr_proc_detach failed");
1945+ return HTTP_INTERNAL_SERVER_ERROR;
1946+ }
1947+ }
1948+
1949+ my_pid = getpid();
1950+ }
1951+
1952+ unixd_pre_config(ptemp);
1953+ ap_listen_pre_config();
1954+// num_childs = DEFAULT_NUM_DAEMON;
1955+ num_childs = 0;
1956+ threads_to_start = DEFAULT_START_THREAD;
1957+ min_spare_threads = DEFAULT_MIN_SPARE_THREAD;
1958+ max_spare_threads = DEFAULT_MAX_SPARE_THREAD;
1959+ max_threads = thread_limit;
1960+ ap_pid_fname = DEFAULT_PIDLOG;
1961+ ap_lock_fname = DEFAULT_LOCKFILE;
1962+ ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
1963+
1964+ apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
1965+
1966+ /* we need to know ServerLimit and ThreadLimit before we start processing
1967+ * the tree because we need to already have allocated child_info_table
1968+ */
1969+ for (pdir = ap_conftree; pdir != NULL; pdir = pdir->next)
1970+ {
1971+ if (!strcasecmp(pdir->directive, "ServerLimit"))
1972+ {
1973+ if (atoi(pdir->args) > tmp_server_limit)
1974+ {
1975+ tmp_server_limit = atoi(pdir->args);
1976+ if (tmp_server_limit > MAX_SERVER_LIMIT)
1977+ {
1978+ tmp_server_limit = MAX_SERVER_LIMIT;
1979+ }
1980+ }
1981+ }
1982+ else if (!strcasecmp(pdir->directive, "ThreadLimit"))
1983+ {
1984+ if (atoi(pdir->args) > tmp_thread_limit)
1985+ {
1986+ tmp_thread_limit = atoi(pdir->args);
1987+ if (tmp_thread_limit > MAX_THREAD_LIMIT)
1988+ {
1989+ tmp_thread_limit = MAX_THREAD_LIMIT;
1990+ }
1991+ }
1992+ }
1993+ }
1994+
1995+ /* -- now setup the child information table -- */
1996+ child_info_table = (child_info_t *)apr_pcalloc(p, tmp_server_limit * sizeof(child_info_t));
1997+ child_info_table_size = tmp_server_limit; /* FIXME: remove tmp_server_limit */
1998+ for (i = 0; i < tmp_server_limit; i++)
1999+ {
2000+ child_info_table[i].uid = -1;
2001+ child_info_table[i].gid = -1;
2002+ child_info_table[i].input = -1;
2003+ child_info_table[i].output = -1;
2004+ child_info_table[i].type = -1;
2005+ child_info_table[i].id = i;
2006+ }
2007+
2008+ return OK;
2009+}
2010+
2011+#undef NO_BODY
2012+
2013+static int pass_request(request_rec *r)
2014+{
2015+ int rv;
2016+ struct msghdr msg;
2017+ struct cmsghdr *cmsg;
2018+ int sock_fd;
2019+ char *bodypart = NULL;
2020+ struct iovec iov[2];
2021+ conn_rec *c = r->connection;
2022+ apr_bucket_brigade *bb = apr_brigade_create(r->pool, c->bucket_alloc);
2023+ apr_bucket_brigade *bodypart_bb = NULL;
2024+ apr_size_t len = 0;
2025+ apr_size_t bodypart_len = 0;
2026+ metuxmpm_header h;
2027+ apr_bucket *bucket;
2028+ const apr_array_header_t *headers_in_array;
2029+ const apr_table_entry_t *headers_in;
2030+ int counter;
2031+
2032+ apr_socket_t *thesock = ap_get_module_config(r->connection->conn_config, &core_module);
2033+ metuxmpm_server_conf *sconf = metuxmpm_SERVER_CONF(r->server->module_config);
2034+
2035+ if ((!r->the_request) || (!strlen(r->the_request)))
2036+ {
2037+ _DBG("empty request. dropping it (%ld)", r->the_request);
2038+ return -1;
2039+ }
2040+
2041+ if (!sconf->child)
2042+ {
2043+ _DBG("server %s in child %d has no child_info assiocated",
2044+ r->hostname, child_num);
2045+ return -1;
2046+ }
2047+
2048+ _DBG("passing request to another child. Vhost: %s, child %d %d",
2049+ apr_table_get(r->headers_in, "Host"), child_num, sconf->child->output);
2050+ _DBG("r->the_request=\"%s\" len=%d", r->the_request, strlen(r->the_request));
2051+
2052+ ap_get_brigade(r->connection->input_filters, bb, AP_MODE_EXHAUSTIVE, APR_NONBLOCK_READ, len);
2053+
2054+ /* Scan the brigade looking for heap-buckets */
2055+
2056+ _DBG("Scanning the brigade");
2057+ bucket = APR_BRIGADE_FIRST(bb);
2058+ while (bucket != APR_BRIGADE_SENTINEL(bb) &&
2059+ APR_BUCKET_IS_HEAP(bucket)) {
2060+ _DBG("HEAP BUCKET is found, length=%d", bucket->length);
2061+ bucket = APR_BUCKET_NEXT(bucket);
2062+ if (!APR_BUCKET_IS_HEAP(bucket)) {
2063+ _DBG("NON-HEAP BUCKET is found, extracting the part of brigade before it");
2064+ bodypart_bb = bb;
2065+ bb = apr_brigade_split(bodypart_bb, bucket);
2066+ /* Do we need to apr_destroy_brigade(bb) here?
2067+ * Yeah, I know we do apr_pool_destroy(r->pool) before return, but
2068+ * ap_get_brigade is in non-blocking mode (however len is zero).
2069+ */
2070+ if (apr_brigade_pflatten(bodypart_bb, &bodypart, &bodypart_len, r->pool) != APR_SUCCESS) {
2071+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2072+ "Unable to flatten brigade, declining request");
2073+ apr_pool_destroy(r->pool);
2074+ return DECLINED;
2075+ }
2076+ _DBG("Brigade is flattened as bodypart (bodypart_len=%d)", bodypart_len);
2077+ }
2078+ }
2079+ _DBG("Scanning is finished");
2080+
2081+ apr_os_sock_get(&sock_fd, thesock);
2082+
2083+ h.p = r->pool;
2084+
2085+ headers_in_array = apr_table_elts(r->headers_in);
2086+ headers_in = (const apr_table_entry_t *) headers_in_array->elts;
2087+
2088+ h.headers = apr_pstrcat(h.p, r->the_request, CRLF, NULL);
2089+ for (counter = 0; counter < headers_in_array->nelts; counter++) {
2090+ if (headers_in[counter].key == NULL
2091+ || headers_in[counter].val == NULL) {
2092+ continue;
2093+ }
2094+ h.headers = apr_pstrcat(h.p, h.headers, headers_in[counter].key, ": ",
2095+ headers_in[counter].val, CRLF, NULL);
2096+
2097+ }
2098+ h.headers = apr_pstrcat(h.p, h.headers, CRLF, NULL);
2099+ ap_xlate_proto_to_ascii(h.headers, strlen(h.headers));
2100+
2101+ iov[0].iov_base = &bodypart_len;
2102+ iov[0].iov_len = sizeof(bodypart_len);
2103+ iov[1].iov_base = h.headers;
2104+ iov[1].iov_len = strlen(h.headers) + 1;
2105+
2106+ msg.msg_name = NULL;
2107+ msg.msg_namelen = 0;
2108+ msg.msg_iov = iov;
2109+ msg.msg_iovlen = 2;
2110+
2111+ cmsg = apr_palloc(r->pool, sizeof(*cmsg) + sizeof(sock_fd));
2112+ cmsg->cmsg_len = sizeof(*cmsg) + sizeof(sock_fd);
2113+ cmsg->cmsg_level = SOL_SOCKET;
2114+ cmsg->cmsg_type = SCM_RIGHTS;
2115+
2116+ memcpy(CMSG_DATA(cmsg), &sock_fd, sizeof(sock_fd));
2117+
2118+ msg.msg_control = cmsg;
2119+ msg.msg_controllen = cmsg->cmsg_len;
2120+
2121+ _DBG("Writing message to %d, passing sock_fd: %d", sconf->child->output, sock_fd);
2122+ _DBG("headers=\"%s\"", h.headers);
2123+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2124+ "Writing message to %d, passing sd: %d", sconf->child->output, sock_fd);
2125+
2126+ if ((rv = sendmsg(sconf->child->output, &msg, 0)) == -1)
2127+ {
2128+ apr_pool_destroy(r->pool);
2129+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2130+ "Writing message failed %d %d", rv, errno);
2131+ return -1;
2132+ }
2133+
2134+ _DBG("Writing message succeeded %d", rv);
2135+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2136+ "Writing message succeeded %d", rv);
2137+
2138+ if (bodypart_len) {
2139+ _DBG("Passing bodypart (bodypart_len=%d) \"%s\"", bodypart_len, bodypart);
2140+ if ((rv = send(sconf->child->output, bodypart, bodypart_len, 0)) == -1) {
2141+ apr_pool_destroy(r->pool);
2142+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2143+ "Writing message failed %d %d", rv, errno);
2144+ return -1;
2145+ }
2146+ _DBG("Writing message succeeded %d", rv);
2147+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2148+ "Writing message succeeded %d", rv);
2149+ } else {
2150+ _DBG("No bodypart");
2151+ }
2152+
2153+ /* -- close the socket at our site -- */
2154+ apr_socket_close(thesock);
2155+ /* DS: What is the purpose of this?
2156+ * apr_socket_close(sconf->child->output) seems more reasonable
2157+ */
2158+ _DBG("closing socket %d at our side", sock_fd);
2159+ apr_pool_destroy(r->pool);
2160+ return 1;
2161+}
2162+
2163+static int metuxmpm_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *server_list)
2164+{
2165+ int i;
2166+ server_rec *sr_walk;
2167+ metuxmpm_server_conf *sconf;
2168+
2169+ for (sr_walk = server_list; sr_walk; sr_walk = sr_walk->next)
2170+ {
2171+ sconf = metuxmpm_SERVER_CONF(sr_walk->module_config);
2172+ if (sconf->child)
2173+ {
2174+ _DBG("server \"%s\" child=%d fd_in=%d fd_out=%d",
2175+ sr_walk->server_hostname,
2176+ sconf->child->id,
2177+ sconf->child->input,
2178+ sconf->child->output );
2179+ }
2180+ else
2181+ {
2182+ _DBG("server \"%s\" has no child assiocated.",
2183+ sr_walk->server_hostname);
2184+ }
2185+ }
2186+
2187+ thread_info_table = (thread_info_t *)apr_pcalloc(p, thread_limit * sizeof(thread_info_t));
2188+ for (i = 0; i < thread_limit; i++)
2189+ {
2190+ thread_info_table[i].sock_fd = AP_metuxmpm_THISCHILD;
2191+ thread_info_table[i].status = 0;
2192+ }
2193+ ap_child_table = (ap_ctable *)apr_pcalloc(p, server_limit * sizeof(ap_ctable));
2194+
2195+ return OK;
2196+}
2197+
2198+static int metuxmpm_post_read(request_rec *r)
2199+{
2200+ int thread_num = r->connection->id % thread_limit;
2201+ metuxmpm_server_conf *sconf = metuxmpm_SERVER_CONF(r->server->module_config);
2202+
2203+ if (!strlen(r->the_request))
2204+ {
2205+ _DBG("corrupt request. aborting");
2206+ return DECLINED;
2207+ }
2208+
2209+ if (thread_info_table[thread_num].sock_fd != AP_metuxmpm_THISCHILD)
2210+ {
2211+ apr_socket_t *sock = NULL;
2212+
2213+ apr_os_sock_put(&sock, &thread_info_table[thread_num].sock_fd,
2214+ r->connection->pool);
2215+ ap_sock_disable_nagle(sock);
2216+ ap_set_module_config(r->connection->conn_config, &core_module, sock);
2217+ _DBG("not the right socket? ");
2218+ return OK;
2219+ }
2220+
2221+ switch (child_info_table[child_num].type)
2222+ {
2223+ case CHILD_TYPE_MULTIPLEXER:
2224+ {
2225+ _DBG("MULTIPLEXER => Determining if request should be passed. "
2226+ "Child Num: %d, dest-child: %d, hostname from server: %s r->hostname=%s r->the_request=\"%s\"",
2227+ child_num, sconf->child->id, r->server->server_hostname, r->hostname, r->the_request);
2228+
2229+ if (sconf->child->id != child_num)
2230+ {
2231+ _DBG("Passing request.");
2232+ if (pass_request(r) == -1)
2233+ {
2234+ ap_log_error(APLOG_MARK, APLOG_ERR, 0,
2235+ ap_server_conf, "Could not pass request to proper "
2236+ "child, request will not be honoured.");
2237+ return DECLINED;
2238+ }
2239+ _DBG("doing longjmp");
2240+ longjmp(thread_info_table[thread_num].jmpbuffer, 1);
2241+ _DBG("request declined at our site");
2242+ return DECLINED;
2243+ _DBG("OUH! we should never reach this point");
2244+ }
2245+ _DBG("eeeh?! the server is assigned to the multiplexer! ... dropping request");
2246+ return DECLINED;
2247+ }
2248+ case CHILD_TYPE_PROCESSOR:
2249+ {
2250+ _DBG("PROCESSOR %d", child_num );
2251+ if (sconf->child->id != child_num)
2252+ {
2253+ _DBG("hmmpf! this server is not assigned to us! what did the mux have smoked ?!");
2254+ }
2255+ _DBG("request for %s / (server %s) seems to be for us", r->hostname, r->server->server_hostname );
2256+ return OK;
2257+ }
2258+ default:
2259+ {
2260+ _DBG("unspecified child type %d in %d, dropping request", child_info_table[child_num].type, child_num );
2261+ return OK;
2262+ }
2263+ }
2264+ _DBG("THIS POINT SHOULD NOT BE REACHED!");
2265+ return OK;
2266+}
2267+
2268+static void metuxmpm_hooks(apr_pool_t *p)
2269+{
2270+ /* The metuxmpm open_logs phase must run before the core's, or stderr
2271+ * will be redirected to a file, and the messages won't print to the
2272+ * console.
2273+ */
2274+ static const char *const aszSucc[] = {"core.c", NULL};
2275+ one_process = 0;
2276+
2277+ ap_hook_open_logs(metuxmpm_open_logs, NULL, aszSucc, APR_HOOK_MIDDLE);
2278+ ap_hook_pre_config(metuxmpm_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
2279+ ap_hook_post_config(metuxmpm_post_config, NULL, NULL, APR_HOOK_MIDDLE);
2280+
2281+ /* Both of these must be run absolutely first. If this request isn't for
2282+ * this server then we need to forward it to the proper child. No sense
2283+ * tying up this server running more post_read request hooks if it is
2284+ * just going to be forwarded along. The process_connection hook allows
2285+ * metuxmpm to receive the passed request correctly, by automatically
2286+ * filling in the core_input_filter's ctx pointer.
2287+ */
2288+ ap_hook_post_read_request(metuxmpm_post_read, NULL, NULL,
2289+ APR_HOOK_REALLY_FIRST);
2290+ ap_hook_process_connection(metuxmpm_process_connection, NULL, NULL,
2291+ APR_HOOK_REALLY_FIRST);
2292+}
2293+
2294+//static const char *cf_NumServers(cmd_parms *cmd, void *dummy,
2295+// const char *arg)
2296+//{
2297+// const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2298+// if (err != NULL) return err;
2299+//
2300+// num_childs = atoi(arg);
2301+// if (num_childs > server_limit) {
2302+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2303+// "WARNING: NumServers of %d exceeds ServerLimit value "
2304+// "of %d servers,", num_childs, server_limit);
2305+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2306+// " lowering NumServers to %d. To increase, please "
2307+// "see the", server_limit);
2308+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2309+// " ServerLimit directive.");
2310+// num_childs = server_limit;
2311+// }
2312+// else if (num_childs < 1)
2313+// {
2314+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2315+// "WARNING: Require NumServers > 0, setting to 1");
2316+// num_childs = 1;
2317+// }
2318+// return NULL;
2319+//}
2320+
2321+static const char *cf_StartThreads(cmd_parms *cmd, void *dummy,
2322+ const char *arg)
2323+{
2324+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2325+ if (err != NULL) return err;
2326+
2327+ threads_to_start = atoi(arg);
2328+ if (threads_to_start > thread_limit) {
2329+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2330+ "WARNING: StartThreads of %d exceeds ThreadLimit value"
2331+ " of %d threads,", threads_to_start,
2332+ thread_limit);
2333+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2334+ " lowering StartThreads to %d. To increase, please"
2335+ " see the", thread_limit);
2336+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2337+ " ThreadLimit directive.");
2338+ }
2339+ else if (threads_to_start < 1) {
2340+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2341+ "WARNING: Require StartThreads > 0, setting to 1");
2342+ threads_to_start = 1;
2343+ }
2344+ return NULL;
2345+}
2346+
2347+static const char *cf_MinSpareThreads(cmd_parms *cmd, void *dummy,
2348+ const char *arg)
2349+{
2350+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2351+ if (err != NULL) return err;
2352+
2353+ min_spare_threads = atoi(arg);
2354+ if (min_spare_threads <= 0)
2355+ {
2356+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2357+ "WARNING: detected MinSpareThreads set to non-positive.");
2358+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2359+ "Resetting to 1 to avoid almost certain Apache failure.");
2360+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2361+ "Please read the documentation.");
2362+ min_spare_threads = 1;
2363+ }
2364+
2365+ return NULL;
2366+}
2367+
2368+static const char *cf_MaxSpareThreads(cmd_parms *cmd, void *dummy,
2369+ const char *arg)
2370+{
2371+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2372+ if (err != NULL) return err;
2373+
2374+ max_spare_threads = atoi(arg);
2375+ if (max_spare_threads >= thread_limit)
2376+ {
2377+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2378+ "WARNING: detected MinSpareThreads set higher than");
2379+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2380+ "ThreadLimit. Resetting to %d", thread_limit);
2381+ max_spare_threads = thread_limit;
2382+ }
2383+ return NULL;
2384+}
2385+
2386+static const char *cf_MaxThreadsmetuxmpm(cmd_parms *cmd, void *dummy, const char *arg)
2387+{
2388+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2389+ if (err != NULL) return err;
2390+
2391+ max_threads = atoi(arg);
2392+ if (max_threads > thread_limit)
2393+ {
2394+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2395+ "WARNING: detected MaxThreadsmetuxmpm set higher than");
2396+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2397+ "ThreadLimit. Resetting to %d", thread_limit);
2398+ max_threads = thread_limit;
2399+ }
2400+ return NULL;
2401+}
2402+
2403+static const char* child_add ( int type, const char* user_name, const char* group_name )
2404+{
2405+ _DBG("%d: %s.%s", num_childs, user_name, group_name);
2406+ if (num_childs<server_limit)
2407+ {
2408+ int socks[2];
2409+
2410+ child_info_table[num_childs].uid = ap_uname2id(user_name);
2411+ child_info_table[num_childs].gid = ap_gname2id(group_name);
2412+ child_info_table[num_childs].type = type;
2413+
2414+ socketpair(PF_UNIX, SOCK_STREAM, 0, socks);
2415+ child_info_table[num_childs].input = socks[0];
2416+ child_info_table[num_childs].output = socks[1];
2417+
2418+ _DBG("[%d] uid=%d gid=%d type=%d fd_in=%d fd_out=%d",
2419+ num_childs,
2420+ child_info_table[num_childs].uid,
2421+ child_info_table[num_childs].gid,
2422+ child_info_table[num_childs].type,
2423+ child_info_table[num_childs].input,
2424+ child_info_table[num_childs].output
2425+ );
2426+
2427+ if (child_info_table[num_childs].uid == 0 ||
2428+ child_info_table[num_childs].gid == 0)
2429+ {
2430+ _DBG("Assigning root user/group to a child.");
2431+ }
2432+ num_childs++;
2433+ return NULL;
2434+ }
2435+
2436+ return "Trying to use more child ID's than NumServers. "
2437+ "Increase NumServers in your config file.";
2438+}
2439+
2440+/* we define an Processor w/ specific uid/gid */
2441+static const char *cf_Processor(
2442+ cmd_parms *cmd, void *dummy, const char *user_name, const char *group_name)
2443+{
2444+ _DBG("%d: %s.%s", num_childs, user_name, group_name);
2445+ return child_add ( CHILD_TYPE_PROCESSOR, user_name, group_name );
2446+}
2447+
2448+/* we define an Multiplexer child w/ specific uid/gid */
2449+static const char *cf_Multiplexer(
2450+ cmd_parms *cmd, void *dummy, const char *user_name, const char *group_name)
2451+{
2452+ _DBG("%d: %s.%s", num_childs, user_name, group_name);
2453+ return child_add ( CHILD_TYPE_MULTIPLEXER, user_name, group_name );
2454+}
2455+
2456+/* process the config file option AssignUserId */
2457+/* -- FIXME: perhaps we could add childs from here automatically -- */
2458+static const char * cf_AssignUserId
2459+(
2460+ cmd_parms *cmd,
2461+ void *dummy,
2462+ const char *user_name,
2463+ const char *group_name
2464+)
2465+{
2466+ int i;
2467+ int matching = 0;
2468+ int uid = ap_uname2id(user_name);
2469+ int gid = ap_gname2id(group_name);
2470+ const char *errstr;
2471+
2472+ metuxmpm_server_conf *sconf
2473+ = metuxmpm_SERVER_CONF(cmd->server->module_config);
2474+
2475+ sconf->fullsockname =
2476+ apr_pstrcat(cmd->pool, sconf->sockname, ".", user_name,":", group_name, NULL);
2477+
2478+ _DBG("user=\"%s\" (%d) group=\"%s\" (%d) numchilds=%d", user_name, uid, group_name, gid, num_childs );
2479+
2480+ for (i = 0; i < num_childs; i++)
2481+ {
2482+ _DBG("trying %d: %d.%d / %d", i,
2483+ child_info_table[i].uid, child_info_table[i].gid, child_info_table[i].type );
2484+
2485+ if ((uid == child_info_table[i].uid) &&
2486+ (gid == child_info_table[i].gid) &&
2487+ (child_info_table[i].type == CHILD_TYPE_PROCESSOR))
2488+ {
2489+ /* create an socket for this child, if it has no one */
2490+ /* FIXME: we should do it anywhere else, for _all_ childs */
2491+ sconf->child = &child_info_table[i];
2492+ _DBG("assigning server to child %d; "
2493+ "UID: %d, GID: %d, input=%d, output=%d",
2494+ i, uid, gid, sconf->child->input, sconf->child->output);
2495+ return NULL;
2496+ }
2497+ }
2498+
2499+ _DBG("assigning server to child FAILED %d; UID: %d, GID: %d ", i, uid, gid);
2500+ return "Unable to find process with matching uid/gid.";
2501+}
2502+
2503+static const char *cf_ServerLimit (cmd_parms *cmd, void *dummy, const char *arg)
2504+{
2505+ int tmp_server_limit;
2506+
2507+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2508+ if (err != NULL) return err;
2509+
2510+ tmp_server_limit = atoi(arg);
2511+ /* you cannot change ServerLimit across a restart; ignore
2512+ * any such attempts
2513+ */
2514+ if (first_server_limit && tmp_server_limit != server_limit)
2515+ {
2516+ /* how do we log a message? the error log is a bit bucket at this
2517+ * point; we'll just have to set a flag so that ap_mpm_run()
2518+ * logs a warning later
2519+ */
2520+ changed_limit_at_restart = 1;
2521+ return NULL;
2522+ }
2523+ server_limit = tmp_server_limit;
2524+
2525+ if (server_limit > MAX_SERVER_LIMIT)
2526+ {
2527+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2528+ "WARNING: ServerLimit of %d exceeds compile time limit "
2529+ "of %d servers,", server_limit, MAX_SERVER_LIMIT);
2530+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2531+ " lowering ServerLimit to %d.", MAX_SERVER_LIMIT);
2532+ server_limit = MAX_SERVER_LIMIT;
2533+ }
2534+ else if (server_limit < 1)
2535+ {
2536+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2537+ "WARNING: Require ServerLimit > 0, setting to 1");
2538+ server_limit = 1;
2539+ }
2540+ return NULL;
2541+}
2542+
2543+static const char *cf_ThreadLimit (cmd_parms *cmd, void *dummy, const char *arg)
2544+{
2545+ int tmp_thread_limit;
2546+
2547+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2548+ if (err != NULL) return err;
2549+
2550+ tmp_thread_limit = atoi(arg);
2551+ /* you cannot change ThreadLimit across a restart; ignore
2552+ * any such attempts
2553+ */
2554+ if (first_thread_limit && tmp_thread_limit != thread_limit)
2555+ {
2556+ /* how do we log a message? the error log is a bit bucket at this
2557+ * point; we'll just have to set a flag so that ap_mpm_run()
2558+ * logs a warning later
2559+ */
2560+ changed_limit_at_restart = 1;
2561+ return NULL;
2562+ }
2563+ thread_limit = tmp_thread_limit;
2564+
2565+ if (thread_limit > MAX_THREAD_LIMIT)
2566+ {
2567+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2568+ "WARNING: ThreadLimit of %d exceeds compile time limit "
2569+ "of %d servers,", thread_limit, MAX_THREAD_LIMIT);
2570+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2571+ " lowering ThreadLimit to %d.", MAX_THREAD_LIMIT);
2572+ thread_limit = MAX_THREAD_LIMIT;
2573+ }
2574+ else if (thread_limit < 1)
2575+ {
2576+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2577+ "WARNING: Require ThreadLimit > 0, setting to 1");
2578+ thread_limit = 1;
2579+ }
2580+ return NULL;
2581+}
2582+
2583+static const command_rec metuxmpm_cmds[] = {
2584+UNIX_DAEMON_COMMANDS,
2585+LISTEN_COMMANDS,
2586+AP_INIT_TAKE1("StartThreads", cf_StartThreads, NULL, RSRC_CONF,
2587+ "Number of threads each child creates"),
2588+AP_INIT_TAKE1("MinSpareThreads", cf_MinSpareThreads, NULL, RSRC_CONF,
2589+ "Minimum number of idle threads per child, to handle "
2590+ "request spikes"),
2591+AP_INIT_TAKE1("MaxSpareThreads", cf_MaxSpareThreads, NULL, RSRC_CONF,
2592+ "Maximum number of idle threads per child"),
2593+AP_INIT_TAKE1("MaxThreadsmetuxmpm", cf_MaxThreadsmetuxmpm, NULL, RSRC_CONF,
2594+ "Maximum number of threads per child"),
2595+AP_INIT_TAKE2("Multiplexer", cf_Multiplexer, NULL, RSRC_CONF,
2596+ "Specify an Multiplexer Child configuration."),
2597+AP_INIT_TAKE2("Processor", cf_Processor, NULL, RSRC_CONF,
2598+ "Specify a User and Group for a specific child process."),
2599+AP_INIT_TAKE2("AssignUserID", cf_AssignUserId, NULL, RSRC_CONF,
2600+ "Tie a virtual host to a specific child process."),
2601+AP_INIT_TAKE1("ServerLimit", cf_ServerLimit, NULL, RSRC_CONF,
2602+ "Maximum value of NumServers for this run of Apache"),
2603+AP_INIT_TAKE1("ThreadLimit", cf_ThreadLimit, NULL, RSRC_CONF,
2604+ "Maximum worker threads in a server for this run of Apache"),
2605+{ NULL }
2606+};
2607+
2608+/* == allocate an private server config structure == */
2609+static void *metuxmpm_create_config(apr_pool_t *p, server_rec *s)
2610+{
2611+ metuxmpm_server_conf *c = (metuxmpm_server_conf *)
2612+ apr_pcalloc(p, sizeof(metuxmpm_server_conf));
2613+ c->child = NULL;
2614+ return c;
2615+}
2616+
2617+module AP_MODULE_DECLARE_DATA mpm_metuxmpm_module =
2618+{
2619+ MPM20_MODULE_STUFF,
2620+ ap_mpm_rewrite_args, /* hook to run before apache parses args */
2621+ NULL, /* create per-directory config structure */
2622+ NULL, /* merge per-directory config structures */
2623+ metuxmpm_create_config, /* create per-server config structure */
2624+ NULL, /* merge per-server config structures */
2625+ metuxmpm_cmds, /* command apr_table_t */
2626+ metuxmpm_hooks /* register_hooks */
2627+};
2628+
2629diff -ruN httpd-2.0.47/server/mpm/experimental/metuxmpm/mpm.h httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/mpm.h
2630--- httpd-2.0.47/server/mpm/experimental/metuxmpm/mpm.h 1970-01-01 01:00:00.000000000 +0100
2631+++ httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/mpm.h 2003-09-19 20:18:32.000000000 +0200
2632@@ -0,0 +1,100 @@
2633+/* ====================================================================
2634+ * The Apache Software License, Version 1.1
2635+ *
2636+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
2637+ * reserved.
2638+ *
2639+ * Redistribution and use in source and binary forms, with or without
2640+ * modification, are permitted provided that the following conditions
2641+ * are met:
2642+ *
2643+ * 1. Redistributions of source code must retain the above copyright
2644+ * notice, this list of conditions and the following disclaimer.
2645+ *
2646+ * 2. Redistributions in binary form must reproduce the above copyright
2647+ * notice, this list of conditions and the following disclaimer in
2648+ * the documentation and/or other materials provided with the
2649+ * distribution.
2650+ *
2651+ * 3. The end-user documentation included with the redistribution,
2652+ * if any, must include the following acknowledgment:
2653+ * "This product includes software developed by the
2654+ * Apache Software Foundation (http://www.apache.org/)."
2655+ * Alternately, this acknowledgment may appear in the software itself,
2656+ * if and wherever such third-party acknowledgments normally appear.
2657+ *
2658+ * 4. The names "Apache" and "Apache Software Foundation" must
2659+ * not be used to endorse or promote products derived from this
2660+ * software without prior written permission. For written
2661+ * permission, please contact apache@apache.org.
2662+ *
2663+ * 5. Products derived from this software may not be called "Apache",
2664+ * nor may "Apache" appear in their name, without prior written
2665+ * permission of the Apache Software Foundation.
2666+ *
2667+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
2668+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
2669+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2670+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
2671+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2672+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2673+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
2674+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2675+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2676+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
2677+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2678+ * SUCH DAMAGE.
2679+ * ====================================================================
2680+ *
2681+ * This software consists of voluntary contributions made by many
2682+ * individuals on behalf of the Apache Software Foundation. For more
2683+ * information on the Apache Software Foundation, please see
2684+ * <http://www.apache.org/>.
2685+ *
2686+ * Portions of this software are based upon public domain software
2687+ * originally written at the National Center for Supercomputing Applications,
2688+ * University of Illinois, Urbana-Champaign.
2689+ */
2690+
2691+#include "httpd.h"
2692+#include "mpm_default.h"
2693+#include "unixd.h"
2694+
2695+#ifndef APACHE_MPM_METUXMPM_H
2696+#define APACHE_MPM_METUXMPM_H
2697+
2698+#define METUXMPM_MPM
2699+
2700+#define MPM_NAME "metuxmpm"
2701+
2702+#define AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
2703+#define AP_MPM_WANT_WAIT_OR_TIMEOUT
2704+#define AP_MPM_WANT_PROCESS_CHILD_STATUS
2705+#define AP_MPM_WANT_SET_PIDFILE
2706+#define AP_MPM_WANT_SET_SCOREBOARD
2707+#define AP_MPM_WANT_SET_LOCKFILE
2708+#define AP_MPM_WANT_SET_MAX_REQUESTS
2709+#define AP_MPM_WANT_SET_COREDUMPDIR
2710+#define AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
2711+#define AP_MPM_WANT_SIGNAL_SERVER
2712+#define AP_MPM_USES_POD
2713+
2714+#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
2715+#define MPM_NOTE_CHILD_KILLED(i) (MPM_CHILD_PID(i) = 0)
2716+#define MPM_ACCEPT_FUNC unixd_accept
2717+
2718+/* Table of child status */
2719+#define SERVER_DEAD 0
2720+#define SERVER_DYING 1
2721+#define SERVER_ALIVE 2
2722+
2723+typedef struct ap_ctable{
2724+ pid_t pid;
2725+ unsigned char status;
2726+} ap_ctable;
2727+
2728+extern int ap_threads_per_child;
2729+extern int ap_max_daemons_limit;
2730+extern server_rec *ap_server_conf;
2731+
2732+#endif /* APACHE_MPM_METUXMPM_H */
2733diff -ruN httpd-2.0.47/server/mpm/experimental/metuxmpm/mpm_default.h httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/mpm_default.h
2734--- httpd-2.0.47/server/mpm/experimental/metuxmpm/mpm_default.h 1970-01-01 01:00:00.000000000 +0100
2735+++ httpd-2.0.47-metuxmpm-r7/server/mpm/experimental/metuxmpm/mpm_default.h 2003-09-19 20:18:32.000000000 +0200
2736@@ -0,0 +1,115 @@
2737+/* ====================================================================
2738+ * The Apache Software License, Version 1.1
2739+ *
2740+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
2741+ * reserved.
2742+ *
2743+ * Redistribution and use in source and binary forms, with or without
2744+ * modification, are permitted provided that the following conditions
2745+ * are met:
2746+ *
2747+ * 1. Redistributions of source code must retain the above copyright
2748+ * notice, this list of conditions and the following disclaimer.
2749+ *
2750+ * 2. Redistributions in binary form must reproduce the above copyright
2751+ * notice, this list of conditions and the following disclaimer in
2752+ * the documentation and/or other materials provided with the
2753+ * distribution.
2754+ *
2755+ * 3. The end-user documentation included with the redistribution,
2756+ * if any, must include the following acknowledgment:
2757+ * "This product includes software developed by the
2758+ * Apache Software Foundation (http://www.apache.org/)."
2759+ * Alternately, this acknowledgment may appear in the software itself,
2760+ * if and wherever such third-party acknowledgments normally appear.
2761+ *
2762+ * 4. The names "Apache" and "Apache Software Foundation" must
2763+ * not be used to endorse or promote products derived from this
2764+ * software without prior written permission. For written
2765+ * permission, please contact apache@apache.org.
2766+ *
2767+ * 5. Products derived from this software may not be called "Apache",
2768+ * nor may "Apache" appear in their name, without prior written
2769+ * permission of the Apache Software Foundation.
2770+ *
2771+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
2772+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
2773+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2774+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
2775+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2776+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2777+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
2778+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2779+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2780+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
2781+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2782+ * SUCH DAMAGE.
2783+ * ====================================================================
2784+ *
2785+ * This software consists of voluntary contributions made by many
2786+ * individuals on behalf of the Apache Software Foundation. For more
2787+ * information on the Apache Software Foundation, please see
2788+ * <http://www.apache.org/>.
2789+ *
2790+ * Portions of this software are based upon public domain software
2791+ * originally written at the National Center for Supercomputing Applications,
2792+ * University of Illinois, Urbana-Champaign.
2793+ */
2794+
2795+#ifndef APACHE_MPM_DEFAULT_H
2796+#define APACHE_MPM_DEFAULT_H
2797+
2798+#define NO_SERIALIZED_ACCEPT
2799+
2800+/* Number of threads to spawn off by default --- also, if fewer than
2801+ * this free when the caretaker checks, it will spawn more.
2802+ */
2803+#ifndef DEFAULT_START_THREAD
2804+#define DEFAULT_START_THREAD 5
2805+#endif
2806+
2807+/* Maximum number of *free* server threads --- more than this, and
2808+ * they will die off.
2809+ */
2810+
2811+#ifndef DEFAULT_MAX_SPARE_THREAD
2812+#define DEFAULT_MAX_SPARE_THREAD 10
2813+#endif
2814+
2815+/* Minimum --- fewer than this, and more will be created */
2816+
2817+#ifndef DEFAULT_MIN_SPARE_THREAD
2818+#define DEFAULT_MIN_SPARE_THREAD 5
2819+#endif
2820+
2821+/* Number of servers to spawn off by default
2822+ */
2823+#ifndef DEFAULT_NUM_DAEMON
2824+#define DEFAULT_NUM_DAEMON 2
2825+#endif
2826+
2827+/* File used for accept locking, when we use a file */
2828+#ifndef DEFAULT_LOCKFILE
2829+#define DEFAULT_LOCKFILE DEFAULT_REL_RUNTIMEDIR "/accept.lock"
2830+#endif
2831+
2832+/* Where the main/parent process's pid is logged */
2833+#ifndef DEFAULT_PIDLOG
2834+#define DEFAULT_PIDLOG DEFAULT_REL_RUNTIMEDIR "/httpd.pid"
2835+#endif
2836+
2837+/*
2838+ * Interval, in microseconds, between scoreboard maintenance.
2839+ */
2840+#ifndef SCOREBOARD_MAINTENANCE_INTERVAL
2841+#define SCOREBOARD_MAINTENANCE_INTERVAL 1000000
2842+#endif
2843+
2844+/* Number of requests to try to handle in a single process. If <= 0,
2845+ * the children don't die off.
2846+ */
2847+#ifndef DEFAULT_MAX_REQUESTS_PER_CHILD
2848+#define DEFAULT_MAX_REQUESTS_PER_CHILD 10000
2849+#endif
2850+
2851+#endif /* AP_MPM_DEFAULT_H */
2852diff -ruN httpd-2.0.47/srclib/apr/network_io/unix/sockets.c httpd-2.0.47-metuxmpm-r7/srclib/apr/network_io/unix/sockets.c
2853--- httpd-2.0.47/srclib/apr/network_io/unix/sockets.c 2003-05-30 14:50:39.000000000 +0200
2854+++ httpd-2.0.47-metuxmpm-r7/srclib/apr/network_io/unix/sockets.c 2003-09-19 20:18:32.000000000 +0200
2855@@ -387,7 +387,36 @@
2856 set_socket_vars(*sock, APR_INET, SOCK_STREAM, 0);
2857 (*sock)->timeout = -1;
2858 }
2859- (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
2860+// (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
2861+ if (1)
2862+ {
2863+ /* fixup socket's peer information.
2864+ we need it for the muxmpm. enrico weigelt, metux ITS
2865+ <weigelt@metux.de>
2866+ */
2867+ /* XXX next line looks bogus w.r.t. AF_INET6 support */
2868+
2869+ /* adjust remote address */
2870+ (*sock)->remote_addr->salen = sizeof((*sock)->remote_addr->sa);
2871+ getpeername(
2872+ *thesock,
2873+ (struct sockaddr*)&((*sock)->remote_addr->sa),
2874+ &((*sock)->remote_addr->salen)
2875+ );
2876+ (*sock)->remote_addr->port = ntohs((*sock)->remote_addr->sa.sin.sin_port);
2877+
2878+ /* XXX assumes sin_port and sin6_port at same offset */
2879+
2880+ /* adjust local address */
2881+ getsockname(
2882+ *thesock,
2883+ (struct sockaddr*)&((*sock)->local_addr->sa),
2884+ &((*sock)->local_addr->salen)
2885+ );
2886+ (*sock)->local_addr->port = ntohs((*sock)->local_addr->sa.sin.sin_port);
2887+ (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 0;
2888+ }
2889+
2890 (*sock)->remote_addr_unknown = 1;
2891 (*sock)->socketdes = *thesock;
2892 return APR_SUCCESS;
The most widely used Web server on the Internet
This page took 0.324803 seconds and 4 git commands to generate.