]> git.pld-linux.org Git - packages/apache.git/blame - httpd-2.0.48-metuxmpm-r8.patch
projects / packages / apache.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- fixed upstream
[packages/apache.git] / httpd-2.0.48-metuxmpm-r8.patch
CommitLineData
81a3ef12
AM		 1diff -urN httpd-2.2.0.org/server/mpm/config.m4 httpd-2.2.0/server/mpm/config.m4
2--- httpd-2.2.0.org/server/mpm/config.m4 2005-10-30 18:05:26.000000000 +0100
3+++ httpd-2.2.0/server/mpm/config.m4 2005-12-02 22:06:33.105676750 +0100
4a17dc3c
AM		 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.
81a3ef12
AM		 8- MPM={beos|event|worker|prefork|mpmt_os2}),[
9+ MPM={beos|event|worker|prefork|mpmt_os2|metuxmpm}),[
4a17dc3c
AM		 10 APACHE_MPM=$withval
11 ],[
12 if test "x$APACHE_MPM" = "x"; then
81a3ef12 13@@ -14,7 +14,7 @@
4a17dc3c 14
81a3ef12
AM		 15 ap_mpm_is_threaded ()
16 {
17- if test "$apache_cv_mpm" = "worker" -o "$apache_cv_mpm" = "event" ; then
18+ if test "$apache_cv_mpm" = "worker" -o "$apache_cv_mpm" = "event" -o "$apache_cv_mpm" = "metuxmpm"; then
19 return 0
20 else
21 return 1
22@@ -23,7 +23,7 @@
4a17dc3c 23
81a3ef12
AM		 24 ap_mpm_is_experimental ()
25 {
26- if test "$apache_cv_mpm" = "event" ; then
27+ if test "$apache_cv_mpm" = "event" -o "$apache_cv_mpm" = "metuxmpm"; then
28 return 0
29 else
30 return 1
31diff -urN httpd-2.2.0.org/server/mpm/experimental/metuxmpm/config5.m4 httpd-2.2.0/server/mpm/experimental/metuxmpm/config5.m4
32--- httpd-2.2.0.org/server/mpm/experimental/metuxmpm/config5.m4 1970-01-01 01:00:00.000000000 +0100
33+++ httpd-2.2.0/server/mpm/experimental/metuxmpm/config5.m4 2005-12-02 22:05:16.484888250 +0100
4a17dc3c
AM		 34@@ -0,0 +1,6 @@
35+dnl ## XXX - Need a more thorough check of the proper flags to use
36+
37+if test "$MPM_NAME" = "metuxmpm" ; then
38+ AC_CHECK_FUNCS(pthread_kill)
39+ APACHE_FAST_OUTPUT(server/mpm/$MPM_SUBDIR_NAME/Makefile)
40+fi
81a3ef12
AM		 41diff -urN httpd-2.2.0.org/server/mpm/experimental/metuxmpm/Makefile.in httpd-2.2.0/server/mpm/experimental/metuxmpm/Makefile.in
42--- httpd-2.2.0.org/server/mpm/experimental/metuxmpm/Makefile.in 1970-01-01 01:00:00.000000000 +0100
43+++ httpd-2.2.0/server/mpm/experimental/metuxmpm/Makefile.in 2005-12-02 22:05:16.480888000 +0100
44@@ -0,0 +1,5 @@
45+
46+LTLIBRARY_NAME = libmetuxmpm.la
47+LTLIBRARY_SOURCES = metuxmpm.c
48+
49+include $(top_srcdir)/build/ltlib.mk
50diff -urN httpd-2.2.0.org/server/mpm/experimental/metuxmpm/metuxmpm.c httpd-2.2.0/server/mpm/experimental/metuxmpm/metuxmpm.c
51--- httpd-2.2.0.org/server/mpm/experimental/metuxmpm/metuxmpm.c 1970-01-01 01:00:00.000000000 +0100
52+++ httpd-2.2.0/server/mpm/experimental/metuxmpm/metuxmpm.c 2005-12-02 22:35:32.190362750 +0100
53@@ -0,0 +1,2599 @@
4a17dc3c
AM		 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(text,par...)
202+# define _TRACE_RET(text,par...)
203+# define _TRACE_CALL(text,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 256
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+/* === configuration stuff === */
282+/* the server limit is also the size of the server table */
283+static int cf_server_limit = DEFAULT_SERVER_LIMIT;
284+
285+/* -- server process information -- */
286+typedef struct
287+{
288+ uid_t uid;
289+ gid_t gid;
290+ int input; /* The socket descriptor */
291+ int output; /* The socket descriptor */
292+ int type;
293+ int id; /* index in child_info_table */
294+ const char *chroot_dir; /* can be null */
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",0); \
405+ apr_thread_mutex_lock(thread_accept_mutex); \
406+ _DBG("got thread_accept_mutex locked",0);
407+
408+#define THREAD_ACCEPT_UNLOCK \
409+ _DBG("unlocking thread_accept_mutex",0); \
410+ apr_thread_mutex_unlock(thread_accept_mutex); \
411+ _DBG("got thread_accept_mutex unlocked",0);
412+#else
413+
414+#define THREAD_ACCEPT_LOCK \
415+ _DBG("omitted locking thread_accept_mutex",0);
416+
417+#define THREAD_ACCEPT_UNLOCK \
418+ _DBG("omitted unlocking thread_accept_mutex",0);
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 %d",child_num);
736+ break;
737+ case CHILD_TYPE_PROCESSOR:
738+ _DBG("type=PROCESSOR %d",child_num);
739+ break;
740+ default:
741+ _DBG("type UNKNOWN! %d",child_num);
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",0);
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()",0);
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()",0);
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",0);
840+ return 1;
841+ }
842+
843+ /* we already have too many threads running */
844+ _DBG("too many running threads. aborting",0);
845+ if (!thread_overflow_reported)
846+ {
847+ ap_log_error(APLOG_MARK, APLOG_ERR, 0,
848+ ap_server_conf,
849+ "server reached MaxThreadsPerChild setting, "
850+ "consider raising the MaxThreadsPerChild 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);
81a3ef12 875+ ret = apr_socket_recv(lr->sd, &pipe_read_char, &n);
4a17dc3c
AM		 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",0);
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",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",0);
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 */
81a3ef12
AM		 1049+ apr_pollset_create(&pollset, num_listensocks, tpool, 0);
1050+ apr_pollset_create(&pollset, num_listensocks, ptrans, 0);
4a17dc3c
AM		 1051+ for(lr_walk = ap_listeners; lr_walk != NULL; lr_walk = lr_walk->next)
1052+ {
1053+ int fd;
81a3ef12
AM		 1054+ apr_pollfd_t new_pollfd;
1055+ new_pollfd.desc_type = APR_POLL_SOCKET;
1056+ new_pollfd.reqevents = APR_POLLIN;
1057+ new_pollfd.desc.s = lr_walk->sd;
1058+ new_pollfd.client_data = lr_walk;
1059+ apr_pollset_add(pollset, &new_pollfd);
4a17dc3c
AM		 1060+ apr_os_sock_get(&fd, lr_walk->sd);
1061+ _DBG("adding fd %d to pollset", fd);
1062+ }
1063+
1064+ if (workers_may_exit) goto worker_out;
1065+ _TRACE_CALL("apr_poll()",0);
1066+ srv = apr_poll(pollset, num_listensocks, &n, -1);
1067+ _TRACE_RET("apr_poll()",0);
1068+
1069+ if (srv != APR_SUCCESS)
1070+ {
1071+ if (APR_STATUS_IS_EINTR(srv))
1072+ {
1073+ _DBG("apr_poll() has been interrupted", 0);
1074+ THREAD_ACCEPT_UNLOCK;
1075+ continue;
1076+ }
1077+
1078+ /* apr_poll() will only return errors in catastrophic
1079+ * circumstances. Let's try exiting gracefully, for now. */
1080+ ap_log_error(APLOG_MARK, APLOG_ERR, srv, (const server_rec *)
1081+ ap_server_conf, "apr_poll: (listen)");
1082+ workers_may_exit = 1;
1083+ _DBG("poll error!",0);
1084+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1085+ THREAD_ACCEPT_UNLOCK;
1086+ goto worker_out;
1087+ }
1088+
1089+ /* find a listener */
1090+ _DBG("looking for an listener",0);
1091+ for (lr_walk=ap_listeners; lr_walk!=NULL; lr_walk = lr_walk->next)
1092+ {
1093+ int fd_tmp;
1094+ apr_os_sock_get(&fd_tmp, lr_walk->sd);
1095+ _DBG(" ... trying w/ fd=%d", fd_tmp);
1096+ apr_poll_revents_get(&event, lr_walk->sd, pollset);
1097+ if (event & (APR_POLLIN))
1098+ {
1099+ THREAD_ACCEPT_UNLOCK;
1100+ goto got_fd;
1101+ }
1102+ if (event & (APR_POLLERR))
1103+ {
1104+ ap_log_error(APLOG_MARK, APLOG_EMERG, rv, ap_server_conf,
1105+ "got POLLERR in line 870");
1106+ }
1107+ }
1108+
1109+ THREAD_ACCEPT_UNLOCK;
1110+ _DBG("WARN: did not find the right listener",0);
1111+ sleep ( 1 );
1112+ continue;
1113+
1114+ got_fd:
1115+ _DBG("input available ... resetting socket.",0);
1116+ sock = NULL; /* important! */
1117+
1118+ _TRACE_CALL("accept_func()",0);
1119+ rv = lr_walk->accept_func((void*)&sock, lr_walk, ptrans);
1120+ _TRACE_RET("accept_func()",0);
1121+
1122+ if (rv == APR_EGENERAL)
1123+ {
1124+ /* E[NM]FILE, ENOMEM, etc */
1125+ _DBG("there was some error." ,0);
1126+ workers_may_exit = 1;
1127+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1128+ break;
1129+ }
1130+
1131+ apr_thread_mutex_lock(idle_thread_count_mutex);
1132+ if (idle_thread_count > min_spare_threads)
1133+ {
1134+ idle_thread_count--;
1135+ }
1136+ else
1137+ {
1138+ if (!start_thread())
1139+ {
1140+ idle_thread_count--;
1141+ }
1142+ }
1143+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1144+
1145+ if (!setjmp(thread_info_table[thread_num].jmpbuffer))
1146+ {
1147+ _DBG("marked jmpbufffer",0);
1148+ _TRACE_CALL("process_socket()",0);
1149+ process_socket(ptrans, sock, conn_id, bucket_alloc);
1150+ _TRACE_RET("process_socket()",0);
1151+ }
1152+ else
1153+ {
1154+ _DBG("landed from longjmp",0);
1155+ thread_info_table[thread_num].sock_fd = AP_metuxmpm_THISCHILD;
1156+ }
1157+ requests_this_child--;
1158+ apr_pool_clear(ptrans);
1159+ }
1160+
1161+ _DBG("thread loop finished",0);
1162+worker_out:
1163+ _DBG("this thread's work is done ... workers_may_exit=%d",workers_may_exit);
1164+
1165+ /* == think about it == */
1166+ apr_thread_mutex_lock(idle_thread_count_mutex);
1167+ idle_thread_count--;
1168+ apr_thread_mutex_unlock(idle_thread_count_mutex);
1169+
1170+ /* == */
1171+ apr_thread_mutex_lock(thread_pool_parent_mutex);
1172+ ap_update_child_status_from_indexes(child_num, thread_num, SERVER_DEAD,
1173+ (request_rec *) NULL);
1174+ apr_pool_destroy(tpool);
1175+ apr_thread_mutex_unlock(thread_pool_parent_mutex);
1176+
1177+ thread_cnt = worker_thread_count_add ( -1 );
1178+ worker_thread_free_ids[thread_cnt] = thread_num;
1179+ if (!thread_cnt)
1180+ {
1181+ /* All the threads have exited, now finish the shutdown process
1182+ * by signalling the sigwait thread */
1183+ _DBG("all workers have quit. killing myself (%d) with SIGTERM", my_pid);
1184+ kill(my_pid, SIGTERM);
1185+ }
1186+ else
1187+ {
1188+ _DBG("this is not the time to die - %d threads are still alive", thread_cnt);
1189+ _DBG("WATCH: workers_may_exit=%d", workers_may_exit);
1190+ }
1191+
1192+ apr_bucket_alloc_destroy(bucket_alloc);
1193+ _DBG("leaving. good bye",0);
1194+ return NULL;
1195+}
1196+
1197+
1198+
1199+/* Set group privileges.
1200+ *
1201+ * Note that we use the username as set in the config files, rather than
1202+ * the lookup of to uid --- the same uid may have multiple passwd entries,
1203+ * with different sets of groups for each.
1204+ */
1205+
1206+static int set_group_privs(uid_t uid, gid_t gid)
1207+{
1208+ if (!geteuid())
1209+ {
1210+ const char *name;
1211+
1212+ /* Get username if passed as a uid */
1213+
1214+ struct passwd *ent;
1215+
1216+ if ((ent = getpwuid(uid)) == NULL)
1217+ {
1218+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1219+ "getpwuid: couldn't determine user name from uid %u, "
1220+ "you probably need to modify the User directive",
1221+ (unsigned)uid);
1222+ return -1;
1223+ }
1224+
1225+ name = ent->pw_name;
1226+
1227+ /*
1228+ * Set the GID before initgroups(), since on some platforms
1229+ * setgid() is known to zap the group list.
1230+ */
1231+ if (setgid(gid) == -1)
1232+ {
1233+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1234+ "setgid: unable to set group id to Group %u",
1235+ (unsigned)gid);
1236+ return -1;
1237+ }
1238+
1239+ /* Reset `groups' attributes. */
1240+
1241+ if (initgroups(name, gid) == -1)
1242+ {
1243+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1244+ "initgroups: unable to set groups for User %s "
1245+ "and Group %u", name, (unsigned)gid);
1246+ return -1;
1247+ }
1248+ }
1249+ return 0;
1250+}
1251+
1252+
1253+static int metuxmpm_setup_child(int childnum)
1254+{
1255+ child_info_t *ug = &child_info_table[childnum];
1256+
1257+ if (ug->uid == -1 && ug->gid == -1) {
1258+ return unixd_setup_child();
1259+ }
1260+ if (set_group_privs(ug->uid, ug->gid)) {
1261+ return -1;
1262+ }
1263+ /* Only try to switch if we're running as root */
1264+ if (!geteuid()
1265+ && (
1266+#ifdef _OSD_POSIX
1267+ os_init_job_environment(server_conf, unixd_config.user_name,
1268+ one_process) != 0 ||
1269+#endif
1270+ setuid(ug->uid) == -1)) {
1271+ ap_log_error(APLOG_MARK, APLOG_ALERT, errno, NULL,
1272+ "setuid: unable to change to uid: %ld",
1273+ (long) ug->uid);
1274+ return -1;
1275+ }
1276+ return 0;
1277+}
1278+
1279+static int check_signal(int signum)
1280+{
1281+ _DBG("signum=%d", signum);
1282+ switch (signum) {
1283+ case SIGTERM:
1284+ case SIGINT:
1285+ just_die(signum);
1286+ return 1;
1287+ }
1288+ return 0;
1289+}
1290+
1291+typedef struct metuxmpm_header
1292+{
1293+ char *headers;
1294+ apr_pool_t *p;
1295+} metuxmpm_header;
1296+
1297+/* Send a single HTTP header field to the client. Note that this function
1298+ * is used in calls to table_do(), so their interfaces are co-dependent.
1299+ * In other words, don't change this one without checking table_do in alloc.c.
1300+ * It returns true unless there was a write error of some kind.
1301+ */
1302+static int metuxmpm_header_field(metuxmpm_header *h,
1303+ const char *fieldname, const char *fieldval)
1304+{
1305+ apr_pstrcat(h->p, h->headers, fieldname, ": ", fieldval, CRLF, NULL);
1306+ return 1;
1307+}
1308+
1309+static inline ap_listen_rec* listen_add ( apr_pool_t* pool, apr_socket_t *sock, void* accept_func )
1310+{
1311+ ap_listen_rec *lr_walk, *lr_new;
1312+
1313+ _DBG("function started",0);
1314+ /* -- create an new listener for this child -- */
1315+ lr_new = apr_palloc(pool, sizeof(*lr_new));
1316+ lr_new->sd = sock;
1317+ lr_new->active = 1;
1318+ lr_new->accept_func = accept_func;
1319+ lr_new->next = NULL;
1320+
1321+ /* -- add the new listener_rec into the list -- */
1322+ /* FIXME: should we somehow lock this list ? */
1323+ if (lr_walk = ap_listeners)
1324+ {
1325+ while (lr_walk->next) lr_walk = lr_walk->next;
1326+ lr_walk->next = lr_new;
1327+ }
1328+ else
1329+ {
1330+ ap_listeners = lr_walk = lr_new;
1331+ }
1332+ num_listensocks++;
1333+ return lr_new;
1334+}
1335+
1336+static inline void listen_clear ()
1337+{
1338+ ap_listen_rec *lr_walk;
1339+
1340+ _DBG("function started",0);
1341+
1342+ /* FIXME: should we somehow lock this list ? */
1343+ while (ap_listeners)
1344+ {
1345+ lr_walk = ap_listeners->next;
1346+ apr_socket_close(ap_listeners->sd);
1347+ ap_listeners = lr_walk;
1348+ }
1349+ num_listensocks=0;
1350+}
1351+
1352+/* -- main routine of an child process -- */
1353+static void child_main(int child_num_arg)
1354+{
1355+ int i;
1356+ apr_status_t rv;
1357+ apr_socket_t *sock = NULL;
1358+
1359+ my_pid = getpid();
1360+ child_num = child_num_arg;
1361+
1362+ _DBG("sock_fd_in=%d sock_fd_out=%d", child_info_table[child_num].input, child_info_table[child_num].output );
1363+
1364+ /* -- allocate an new pool for us -- */
1365+ apr_pool_create(&pchild, pconf);
1366+ if (child_info_table[child_num].chroot_dir){
1367+ _DBG("chroot to %s",child_info_table[child_num].chroot_dir);
1368+ if (chroot(child_info_table[child_num].chroot_dir)){
1369+ _DBG("chroot failure %s",child_info_table[child_num].chroot_dir);
1370+ return;
1371+ }
1372+ }
1373+
1374+ switch (child_info_table[child_num].type)
1375+ {
1376+ case CHILD_TYPE_MULTIPLEXER:
1377+ _DBG("MULTIPLEXER %d", child_num);
1378+ break;
1379+
1380+ case CHILD_TYPE_PROCESSOR:
1381+ _DBG("PROCESSOR %d", child_num);
1382+
1383+ /* -- create new listener to receive from multiplexer -- */
1384+ apr_os_sock_put(&sock, &child_info_table[child_num].input, pconf);
1385+ listen_clear ();
1386+ listen_add ( pconf, sock, receive_from_multiplexer );
1387+ break;
1388+
1389+ default:
1390+ _DBG("unspecified child type for %d sleeping a while ...", child_num);
1391+ sleep ( 5 );
1392+ return;
1393+ }
1394+ /*stuff to do before we switch id's, so we have permissions.*/
1395+
1396+ /* -- init child process (uid switching etc) -- */
1397+ (metuxmpm_setup_child(child_num) && clean_child_exit(APEXIT_CHILDFATAL));
1398+ ap_run_child_init(pchild, ap_server_conf);
1399+
1400+ /*done with init critical section */
1401+
1402+ apr_setup_signal_thread();
1403+
1404+ requests_this_child = ap_max_requests_per_child;
1405+
1406+ /* Setup worker threads */
1407+
1408+ _DBG("setting up worker threads ... " ,0);
1409+ ((threads_to_start > max_threads) && (threads_to_start = max_threads));
1410+ idle_thread_count = threads_to_start;
1411+ workers_may_exit = 0;
1412+ worker_thread_count = 0;
1413+ worker_thread_free_ids = (int *)apr_pcalloc(pchild, thread_limit * sizeof(int));
1414+ for (i = 0; i < max_threads; i++)
1415+ {
1416+ worker_thread_free_ids[i] = i;
1417+ }
1418+ apr_pool_create(&thread_pool_parent, pchild);
1419+ apr_thread_mutex_create(&thread_pool_parent_mutex,
1420+ APR_THREAD_MUTEX_DEFAULT, pchild);
1421+ apr_thread_mutex_create(&idle_thread_count_mutex,
1422+ APR_THREAD_MUTEX_DEFAULT, pchild);
1423+ apr_thread_mutex_create(&worker_thread_count_mutex,
1424+ APR_THREAD_MUTEX_DEFAULT, pchild);
1425+ apr_thread_mutex_create(&pipe_of_death_mutex,
1426+ APR_THREAD_MUTEX_DEFAULT, pchild);
1427+ apr_thread_mutex_create(&thread_accept_mutex,
1428+ APR_THREAD_MUTEX_DEFAULT, pchild);
1429+
1430+ apr_threadattr_create(&worker_thread_attr, pchild);
1431+ apr_threadattr_detach_set(worker_thread_attr, 1);
1432+
1433+ /* We are creating worker threads right now */
1434+ for (i=0; i < threads_to_start; i++)
1435+ {
1436+ /* start_thread shouldn't fail here */
1437+ _TRACE_CALL("start_thread()",0);
1438+ if (!start_thread()) break;
1439+ _TRACE_RET("start_thread()",0);
1440+ }
1441+
1442+ _TRACE_CALL("apr_signal_thread()",0);
1443+ apr_signal_thread(check_signal);
1444+ _TRACE_RET("apr_signal_thread",0);
1445+}
1446+
1447+static int make_child(server_rec *s, int slot)
1448+{
1449+ int pid;
1450+
1451+ switch (child_info_table[slot].type)
1452+ {
1453+ case CHILD_TYPE_MULTIPLEXER: break;
1454+ case CHILD_TYPE_PROCESSOR: break;
1455+ default:
1456+ _DBG("no valid client in slot %d", slot);
1457+ sleep(1);
1458+ return 0;
1459+ }
1460+
1461+ if (slot + 1 > ap_max_daemons_limit)
1462+ {
1463+ ap_max_daemons_limit = slot + 1;
1464+ }
1465+
1466+ (void) ap_update_child_status_from_indexes(slot, 0, SERVER_STARTING,
1467+ (request_rec *) NULL);
1468+
1469+ if ((pid = fork()) == -1)
1470+ {
1471+ ap_log_error(APLOG_MARK, APLOG_ERR, errno, s,
1472+ "fork: Unable to fork new process");
1473+ /* In case system resources are maxxed out, we don't want
1474+ * Apache running away with the CPU trying to fork over and
1475+ * over and over again. */
1476+ sleep(10);
1477+
1478+ return -1;
1479+ }
1480+
1481+ if (!pid)
1482+ {
1483+#ifdef HAVE_BINDPROCESSOR
1484+ /* By default, AIX binds to a single processor. This bit unbinds
1485+ * children which will then bind to another CPU.
1486+ */
1487+ int status = bindprocessor(BINDPROCESS, (int)getpid(),
1488+ PROCESSOR_CLASS_ANY);
1489+ if (status != OK) {
1490+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
1491+ ap_server_conf, "processor unbind failed %d", status);
1492+ }
1493+#endif
1494+
1495+ RAISE_SIGSTOP(MAKE_CHILD);
1496+
1497+ /* XXX - For an unthreaded server, a signal handler will be necessary
1498+ * apr_signal(SIGTERM, just_die);
1499+ */
1500+ child_main(slot);
1501+ clean_child_exit(0);
1502+ }
1503+ /* else */
1504+ ap_scoreboard_image->parent[slot].pid = pid;
1505+
1506+ ap_child_table[slot].pid = pid;
1507+ ap_child_table[slot].status = SERVER_ALIVE;
1508+
1509+ return 0;
1510+}
1511+
1512+/* start up a bunch of children */
1513+static int startup_children(int number_to_start)
1514+{
1515+ int i;
1516+
1517+ for (i = 0; number_to_start && i < num_childs; ++i)
1518+ {
1519+ if (ap_child_table[i].pid) continue;
1520+ if (make_child(ap_server_conf, i) < 0) break;
1521+ --number_to_start;
1522+ }
1523+ return number_to_start;
1524+}
1525+
1526+
1527+/*
1528+ * spawn_rate is the number of children that will be spawned on the
1529+ * next maintenance cycle if there aren't enough servers. It is
1530+ * doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
1531+ * without the need to spawn.
1532+ */
1533+static int spawn_rate = 1;
1534+#ifndef MAX_SPAWN_RATE
1535+#define MAX_SPAWN_RATE (32)
1536+#endif
1537+static int hold_off_on_exponential_spawning;
1538+
1539+static void perform_child_maintenance(void)
1540+{
1541+ int i;
1542+ int free_length;
1543+ int free_slots[MAX_SPAWN_RATE];
1544+ int last_non_dead = -1;
1545+
1546+ /* initialize the free_list */
1547+ free_length = 0;
1548+
1549+ for (i = 0; i < num_childs; ++i)
1550+ {
1551+ if (ap_child_table[i].pid == 0)
1552+ {
1553+ if (free_length < spawn_rate)
1554+ {
1555+ free_slots[free_length] = i;
1556+ ++free_length;
1557+ }
1558+ }
1559+ else
1560+ {
1561+ last_non_dead = i;
1562+ }
1563+
1564+ if (i >= ap_max_daemons_limit && free_length >= spawn_rate)
1565+ {
1566+ break;
1567+ }
1568+ }
1569+ ap_max_daemons_limit = last_non_dead + 1;
1570+
1571+ if (free_length > 0)
1572+ {
1573+ for (i = 0; i < free_length; ++i)
1574+ {
1575+ _TRACE_CALL("make_child()",0);
1576+ make_child(ap_server_conf, free_slots[i]);
1577+ _TRACE_RET("make_child()",0);
1578+ }
1579+ /* the next time around we want to spawn twice as many if this
1580+ * wasn't good enough, but not if we've just done a graceful
1581+ */
1582+ if (hold_off_on_exponential_spawning)
1583+ {
1584+ --hold_off_on_exponential_spawning;
1585+ }
1586+ else if (spawn_rate < MAX_SPAWN_RATE)
1587+ {
1588+ spawn_rate *= 2;
1589+ }
1590+ }
1591+ else
1592+ {
1593+ spawn_rate = 1;
1594+ }
1595+}
1596+
1597+static void server_main_loop(int remaining_children_to_start)
1598+{
1599+ apr_exit_why_e exitwhy;
1600+ apr_proc_t pid;
1601+ int child_slot;
1602+ int status;
1603+ int i;
1604+ static int l=0;
1605+
1606+ while (!restart_pending && !shutdown_pending)
1607+ {
1608+ ap_wait_or_timeout(&exitwhy, &status, &pid, pconf);
1609+
1610+ if (pid.pid != -1)
1611+ {
1612+ if (ap_process_child_status(&pid, exitwhy, status)==APEXIT_CHILDFATAL)
1613+ {
1614+ _DBG("shutdown pending ...",0);
1615+ shutdown_pending = 1;
1616+ child_fatal = 1;
1617+ return;
1618+ }
1619+ /* non-fatal death... note that it's gone in the child table and
1620+ * clean out the status table. */
1621+ _DBG("child has #%d died ...", child_slot);
1622+ child_slot = -1;
1623+ for (i = 0; i < ap_max_daemons_limit; ++i)
1624+ {
1625+ if (ap_child_table[i].pid == pid.pid)
1626+ {
1627+ child_slot = i;
1628+ break;
1629+ }
1630+ }
1631+ if (child_slot >= 0)
1632+ {
1633+ ap_child_table[child_slot].pid = 0;
1634+ ap_update_child_status_from_indexes(child_slot, i, SERVER_DEAD,
1635+ (request_rec *) NULL);
1636+
1637+
1638+ if (remaining_children_to_start && (child_slot < num_childs))
1639+ {
1640+ /* we're still doing a 1-for-1 replacement of dead
1641+ * children with new children
1642+ */
1643+ _DBG("replacing by new child ...",0);
1644+ make_child(ap_server_conf, child_slot);
1645+ --remaining_children_to_start;
1646+ }
1647+#if APR_HAS_OTHER_CHILD
1648+ }
81a3ef12 1649+ else if (apr_proc_other_child_alert(&pid, APR_OC_REASON_DEATH, status) == 0)
4a17dc3c
AM		 1650+ {
1651+ /* handled */
1652+#endif
1653+ }
1654+ else if (is_graceful)
1655+ {
1656+ /* Great, we've probably just lost a slot in the
1657+ * child table. Somehow we don't know about this
1658+ * child.
1659+ */
1660+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
1661+ ap_server_conf,
1662+ "long lost child came home! (pid %ld)",
1663+ (long)pid.pid);
1664+ }
1665+ /* Don't perform idle maintenance when a child dies,
1666+ * only do it when there's a timeout. Remember only a
1667+ * finite number of children can die, and it's pretty
1668+ * pathological for a lot to die suddenly.
1669+ */
1670+ continue;
1671+ }
1672+ else if (remaining_children_to_start)
1673+ {
1674+ /* we hit a 1 second timeout in which none of the previous
1675+ * generation of children needed to be reaped... so assume
1676+ * they're all done, and pick up the slack if any is left.
1677+ */
1678+ _TRACE_CALL("startup_children()",0);
1679+ remaining_children_to_start = startup_children(remaining_children_to_start);
1680+ _TRACE_RET("startup_children()",0);
1681+ /* In any event we really shouldn't do the code below because
1682+ * few of the servers we just started are in the IDLE state
1683+ * yet, so we'd mistakenly create an extra server.
1684+ */
1685+ continue;
1686+ }
1687+
1688+ perform_child_maintenance();
1689+ }
1690+}
1691+
1692+int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
1693+{
1694+ int remaining_children_to_start;
1695+ int i;
1696+ int fd;
1697+ apr_status_t rv;
1698+ apr_size_t one = 1;
1699+ apr_socket_t *sock = NULL;
1700+
1701+ ap_log_pid(pconf, ap_pid_fname);
1702+
1703+ first_server_limit = server_limit;
1704+ first_thread_limit = thread_limit;
1705+ if (changed_limit_at_restart)
1706+ {
1707+ ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
1708+ "WARNING: Attempt to change ServerLimit or ThreadLimit "
1709+ "ignored during restart");
1710+ changed_limit_at_restart = 0;
1711+ }
1712+
1713+ ap_server_conf = s;
1714+
1715+ /* Initialize cross-process accept lock */
1716+ ap_lock_fname = apr_psprintf(_pconf, "%s.%u",
1717+ ap_server_root_relative(_pconf, ap_lock_fname),
1718+ my_pid);
1719+ rv = ACCEPT_PROC_MUTEX_CREATE;
1720+ if (rv != APR_SUCCESS)
1721+ {
1722+ ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
1723+ "Couldn't create cross-process lock");
1724+ return 1;
1725+ }
1726+
1727+ if (!is_graceful)
1728+ {
1729+ if (ap_run_pre_mpm(s->process->pool, SB_SHARED) != OK)
1730+ {
1731+ return 1;
1732+ }
1733+ }
1734+ /* Initialize the child table */
1735+ if (!is_graceful)
1736+ {
1737+ for (i = 0; i < server_limit; i++)
1738+ {
1739+ ap_child_table[i].pid = 0;
1740+ }
1741+ }
1742+
1743+ /* We need to put the new listeners at the end of the ap_listeners
1744+ * list. If we don't, then the pool will be cleared before the
1745+ * open_logs phase is called for the second time, and ap_listeners
1746+ * will have only invalid data. If that happens, then the sockets
1747+ * that we opened using make_sock() will be lost, and the server
1748+ * won't start.
1749+ */
1750+ apr_os_file_get(&fd, pipe_of_death_in);
1751+ apr_os_sock_put(&sock, &fd, pconf);
1752+
1753+ listen_add ( pconf, sock, check_pipe_of_death );
1754+ set_signals();
1755+
1756+ /* If we're doing a graceful_restart then we're going to see a lot
1757+ * of children exiting immediately when we get into the main loop
1758+ * below (because we just sent them AP_SIG_GRACEFUL). This happens
1759+ * pretty rapidly... and for each one that exits we'll start a new one
1760+ * until we reach at least daemons_min_free. But we may be permitted to
1761+ * start more than that, so we'll just keep track of how many we're
1762+ * supposed to start up without the 1 second penalty between each fork.
1763+ */
1764+ remaining_children_to_start = num_childs;
1765+ if (!is_graceful) {
1766+ remaining_children_to_start = \
1767+ startup_children(remaining_children_to_start);
1768+ }
1769+ else {
1770+ /* give the system some time to recover before kicking into
1771+ * exponential mode */
1772+ hold_off_on_exponential_spawning = 10;
1773+ }
1774+
1775+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
1776+ "%s configured -- resuming normal operations",
1777+ ap_get_server_version());
1778+ ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
1779+ "Server built: %s", ap_get_server_built());
1780+#ifdef AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
1781+#ifdef NO_SERIALIZED_ACCEPT
1782+ _DBG("AcceptMutex: n/a (compiled w/ NO_SERIALIZED_ACCEPT)", 0 );
1783+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
1784+ "AcceptMutex: n/a (compiled w/ NO_SERIALIZED_ACCEPT)" );
1785+#else
1786+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
1787+ "AcceptMutex: %s (default: %s)",
1788+ apr_proc_mutex_name(process_accept_mutex),
1789+ apr_proc_mutex_defname());
1790+#endif
1791+#endif
1792+ restart_pending = shutdown_pending = 0;
1793+
1794+ server_main_loop(remaining_children_to_start);
1795+
1796+ if (shutdown_pending)
1797+ {
1798+ /* Time to gracefully shut down:
1799+ * Kill child processes, tell them to call child_exit, etc...
1800+ */
1801+ if (unixd_killpg(getpgrp(), SIGTERM) < 0)
1802+ {
1803+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
1804+ "killpg SIGTERM");
1805+ }
1806+ ap_reclaim_child_processes(1); /* Start with SIGTERM */
1807+
1808+ if (!child_fatal)
1809+ {
1810+ /* cleanup pid file on normal shutdown */
1811+ const char *pidfile = NULL;
1812+ pidfile = ap_server_root_relative (pconf, ap_pid_fname);
1813+ if (pidfile != NULL && unlink(pidfile) == 0) {
1814+ ap_log_error(APLOG_MARK, APLOG_INFO, 0,
1815+ ap_server_conf,
1816+ "removed PID file %s (pid=%ld)",
1817+ pidfile, (long)getpid());
1818+ }
1819+
1820+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1821+ ap_server_conf, "caught SIGTERM, shutting down");
1822+ }
1823+ return 1;
1824+ }
1825+
1826+ /* we've been told to restart */
1827+ apr_signal(SIGHUP, SIG_IGN);
1828+
1829+ if (one_process) return 1; /* not worth thinking about */
1830+
1831+ if (is_graceful)
1832+ {
1833+ char char_of_death = AP_metuxmpm_CHAR_OF_DEATH;
1834+
1835+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1836+ ap_server_conf, AP_SIG_GRACEFUL_STRING " received. "
1837+ "Doing graceful restart");
1838+
1839+ /* This is mostly for debugging... so that we know what is still
1840+ * gracefully dealing with existing request.
1841+ */
1842+
1843+ for (i = 0; i < num_childs; ++i)
1844+ {
1845+ ((ap_child_table[i].pid) && (ap_child_table[i].status = SERVER_DYING));
1846+ }
1847+
1848+ /* give the children the signal to die */
1849+ for (i = 0; i < num_childs;)
1850+ {
1851+ if ((rv = apr_file_write(pipe_of_death_out, &char_of_death,&one)) != APR_SUCCESS)
1852+ {
1853+ if (APR_STATUS_IS_EINTR(rv)) continue;
1854+ ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf,
1855+ "write pipe_of_death");
1856+ }
1857+ i++;
1858+ }
1859+ }
1860+ else
1861+ {
1862+ /* Kill 'em all. Since the child acts the same on the parents SIGTERM
1863+ * and a SIGHUP, we may as well use the same signal, because some user
1864+ * pthreads are stealing signals from us left and right.
1865+ */
1866+ if (unixd_killpg(getpgrp(), SIGTERM) < 0)
1867+ {
1868+ ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf,
1869+ "killpg SIGTERM");
1870+ }
1871+ ap_reclaim_child_processes(1); /* Start with SIGTERM */
1872+ ap_log_error(APLOG_MARK, APLOG_NOTICE, 0,
1873+ ap_server_conf, "SIGHUP received. Attempting to restart");
1874+ }
1875+ return 0;
1876+}
1877+
1878+/* This really should be a post_config hook, but the error log is already
1879+ * redirected by that point, so we need to do this in the open_logs phase.
1880+ */
1881+static int metuxmpm_open_logs(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
1882+{
1883+ apr_status_t rv;
1884+
1885+ pconf = p;
1886+ ap_server_conf = s;
1887+
1888+ _DBG("port=%d", ap_server_conf->port);
1889+
1890+ if ((num_listensocks = ap_setup_listeners(ap_server_conf)) < 1) {
1891+ ap_log_error(APLOG_MARK, APLOG_ALERT|APLOG_STARTUP, 0,
1892+ NULL, "metuxmpm_open_logs(): no listening sockets available, shutting down");
1893+ return DONE;
1894+ }
1895+
1896+ ap_log_pid(pconf, ap_pid_fname);
1897+
1898+ if ((rv = ap_mpm_pod_open(pconf, &pod))) {
1899+ ap_log_error(APLOG_MARK, APLOG_CRIT|APLOG_STARTUP, rv, NULL,
1900+ "Could not open pipe-of-death.");
1901+ return DONE;
1902+ }
1903+
1904+ if ((rv = apr_file_pipe_create(&pipe_of_death_in, &pipe_of_death_out,
1905+ pconf)) != APR_SUCCESS) {
1906+ ap_log_error(APLOG_MARK, APLOG_ERR, rv,
1907+ (const server_rec*) ap_server_conf,
1908+ "apr_file_pipe_create (apipe_of_death)");
1909+ exit(1);
1910+ }
1911+ if ((rv = apr_file_pipe_timeout_set(pipe_of_death_in, 0)) != APR_SUCCESS) {
1912+ ap_log_error(APLOG_MARK, APLOG_ERR, rv,
1913+ (const server_rec*) ap_server_conf,
1914+ "apr_file_pipe_timeout_set (pipe_of_death)");
1915+ exit(1);
1916+ }
1917+
1918+ return OK;
1919+}
1920+
1921+static int metuxmpm_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
1922+{
1923+ static int restart_num = 0;
1924+ int no_detach, debug, foreground;
1925+ ap_directive_t *pdir;
1926+ int i;
1927+ int tmp_server_limit = DEFAULT_SERVER_LIMIT;
1928+ int tmp_thread_limit = DEFAULT_THREAD_LIMIT;
1929+ apr_status_t rv;
1930+
1931+ debug = ap_exists_config_define("DEBUG");
1932+
1933+ if (debug) {
1934+ foreground = one_process = 1;
1935+ no_detach = 0;
1936+ }
1937+ else {
1938+ one_process = ap_exists_config_define("ONE_PROCESS");
1939+ no_detach = ap_exists_config_define("NO_DETACH");
1940+ foreground = ap_exists_config_define("FOREGROUND");
1941+ }
1942+
1943+ /* FIXME */
1944+/* no_detach = 0;
1945+ foreground = 0; */
1946+
1947+ /* sigh, want this only the second time around */
1948+ if (restart_num++ == 1)
1949+ {
1950+ is_graceful = 0;
1951+
1952+ if (!one_process && !foreground)
1953+ {
1954+ rv = apr_proc_detach(no_detach ? APR_PROC_DETACH_FOREGROUND
1955+ : APR_PROC_DETACH_DAEMONIZE);
1956+ if (rv != APR_SUCCESS) {
1957+ ap_log_error(APLOG_MARK, APLOG_CRIT, rv, NULL,
1958+ "apr_proc_detach failed");
1959+ return HTTP_INTERNAL_SERVER_ERROR;
1960+ }
1961+ }
1962+
1963+ my_pid = getpid();
1964+ }
1965+
1966+ unixd_pre_config(ptemp);
1967+ ap_listen_pre_config();
1968+// num_childs = DEFAULT_NUM_DAEMON;
1969+ num_childs = 0;
1970+ threads_to_start = DEFAULT_START_THREAD;
1971+ min_spare_threads = DEFAULT_MIN_SPARE_THREAD;
1972+ max_spare_threads = DEFAULT_MAX_SPARE_THREAD;
1973+ max_threads = thread_limit;
1974+ ap_pid_fname = DEFAULT_PIDLOG;
1975+ ap_lock_fname = DEFAULT_LOCKFILE;
1976+ ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
1977+
1978+ apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
1979+
1980+ /* we need to know ServerLimit and ThreadLimit before we start processing
1981+ * the tree because we need to already have allocated child_info_table
1982+ */
1983+ for (pdir = ap_conftree; pdir != NULL; pdir = pdir->next)
1984+ {
1985+ if (!strcasecmp(pdir->directive, "ServerLimit"))
1986+ {
1987+ if (atoi(pdir->args) > tmp_server_limit)
1988+ {
1989+ tmp_server_limit = atoi(pdir->args);
1990+ if (tmp_server_limit > MAX_SERVER_LIMIT)
1991+ {
1992+ tmp_server_limit = MAX_SERVER_LIMIT;
1993+ }
1994+ }
1995+ }
1996+ else if (!strcasecmp(pdir->directive, "ThreadLimit"))
1997+ {
1998+ if (atoi(pdir->args) > tmp_thread_limit)
1999+ {
2000+ tmp_thread_limit = atoi(pdir->args);
2001+ if (tmp_thread_limit > MAX_THREAD_LIMIT)
2002+ {
2003+ tmp_thread_limit = MAX_THREAD_LIMIT;
2004+ }
2005+ }
2006+ }
2007+ }
2008+
2009+ /* -- now setup the child information table -- */
2010+ child_info_table = (child_info_t *)apr_pcalloc(p, tmp_server_limit * sizeof(child_info_t));
2011+ child_info_table_size = tmp_server_limit; /* FIXME: remove tmp_server_limit */
2012+ for (i = 0; i < tmp_server_limit; i++)
2013+ {
2014+ child_info_table[i].uid = -1;
2015+ child_info_table[i].gid = -1;
2016+ child_info_table[i].input = -1;
2017+ child_info_table[i].output = -1;
2018+ child_info_table[i].type = -1;
2019+ child_info_table[i].id = i;
2020+ }
2021+
2022+ return OK;
2023+}
2024+
2025+#undef NO_BODY
2026+
2027+static int pass_request(request_rec *r)
2028+{
2029+ int rv;
2030+ struct msghdr msg;
2031+ struct cmsghdr *cmsg;
2032+ int sock_fd;
2033+ char *bodypart = NULL;
2034+ struct iovec iov[2];
2035+ conn_rec *c = r->connection;
2036+ apr_bucket_brigade *bb = apr_brigade_create(r->pool, c->bucket_alloc);
2037+ apr_bucket_brigade *bodypart_bb = NULL;
2038+ apr_size_t len = 0;
2039+ apr_size_t bodypart_len = 0;
2040+ metuxmpm_header h;
2041+ apr_bucket *bucket;
2042+ const apr_array_header_t *headers_in_array;
2043+ const apr_table_entry_t *headers_in;
2044+ int counter;
2045+
2046+ apr_socket_t *thesock = ap_get_module_config(r->connection->conn_config, &core_module);
2047+ metuxmpm_server_conf *sconf = metuxmpm_SERVER_CONF(r->server->module_config);
2048+
2049+ if ((!r->the_request) || (!strlen(r->the_request)))
2050+ {
2051+ _DBG("empty request. dropping it (%ld)", r->the_request);
2052+ return -1;
2053+ }
2054+
2055+ if (!sconf->child)
2056+ {
2057+ _DBG("server %s in child %d has no child_info assiocated",
2058+ r->hostname, child_num);
2059+ return -1;
2060+ }
2061+
2062+ _DBG("passing request to another child. Vhost: %s, child %d %d",
2063+ apr_table_get(r->headers_in, "Host"), child_num, sconf->child->output);
2064+ _DBG("r->the_request=\"%s\" len=%d", r->the_request, strlen(r->the_request));
2065+
2066+ ap_get_brigade(r->connection->input_filters, bb, AP_MODE_EXHAUSTIVE, APR_NONBLOCK_READ, len);
2067+
2068+ /* Scan the brigade looking for heap-buckets */
2069+
2070+ _DBG("Scanning the brigade",0);
2071+ bucket = APR_BRIGADE_FIRST(bb);
2072+ while (bucket != APR_BRIGADE_SENTINEL(bb) &&
2073+ APR_BUCKET_IS_HEAP(bucket)) {
2074+ _DBG("HEAP BUCKET is found, length=%d", bucket->length);
2075+ bucket = APR_BUCKET_NEXT(bucket);
2076+ if (!APR_BUCKET_IS_HEAP(bucket)) {
2077+ _DBG("NON-HEAP BUCKET is found, extracting the part of brigade before it",0);
2078+ bodypart_bb = bb;
2079+ bb = apr_brigade_split(bodypart_bb, bucket);
2080+ /* Do we need to apr_destroy_brigade(bb) here?
2081+ * Yeah, I know we do apr_pool_destroy(r->pool) before return, but
2082+ * ap_get_brigade is in non-blocking mode (however len is zero).
2083+ */
2084+ if (apr_brigade_pflatten(bodypart_bb, &bodypart, &bodypart_len, r->pool) != APR_SUCCESS) {
2085+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2086+ "Unable to flatten brigade, declining request");
2087+ apr_pool_destroy(r->pool);
2088+ return DECLINED;
2089+ }
2090+ _DBG("Brigade is flattened as bodypart (bodypart_len=%d)", bodypart_len);
2091+ }
2092+ }
2093+ _DBG("Scanning is finished",0);
2094+
2095+ apr_os_sock_get(&sock_fd, thesock);
2096+
2097+ h.p = r->pool;
2098+
2099+ headers_in_array = apr_table_elts(r->headers_in);
2100+ headers_in = (const apr_table_entry_t *) headers_in_array->elts;
2101+
2102+ h.headers = apr_pstrcat(h.p, r->the_request, CRLF, NULL);
2103+ for (counter = 0; counter < headers_in_array->nelts; counter++) {
2104+ if (headers_in[counter].key == NULL
2105+ || headers_in[counter].val == NULL) {
2106+ continue;
2107+ }
2108+ h.headers = apr_pstrcat(h.p, h.headers, headers_in[counter].key, ": ",
2109+ headers_in[counter].val, CRLF, NULL);
2110+
2111+ }
2112+ h.headers = apr_pstrcat(h.p, h.headers, CRLF, NULL);
2113+ ap_xlate_proto_to_ascii(h.headers, strlen(h.headers));
2114+
2115+ iov[0].iov_base = &bodypart_len;
2116+ iov[0].iov_len = sizeof(bodypart_len);
2117+ iov[1].iov_base = h.headers;
2118+ iov[1].iov_len = strlen(h.headers) + 1;
2119+
2120+ msg.msg_name = NULL;
2121+ msg.msg_namelen = 0;
2122+ msg.msg_iov = iov;
2123+ msg.msg_iovlen = 2;
2124+
2125+ cmsg = apr_palloc(r->pool, sizeof(*cmsg) + sizeof(sock_fd));
2126+ cmsg->cmsg_len = sizeof(*cmsg) + sizeof(sock_fd);
2127+ cmsg->cmsg_level = SOL_SOCKET;
2128+ cmsg->cmsg_type = SCM_RIGHTS;
2129+
2130+ memcpy(CMSG_DATA(cmsg), &sock_fd, sizeof(sock_fd));
2131+
2132+ msg.msg_control = cmsg;
2133+ msg.msg_controllen = cmsg->cmsg_len;
2134+
2135+ _DBG("Writing message to %d, passing sock_fd: %d", sconf->child->output, sock_fd);
2136+ _DBG("headers=\"%s\"", h.headers);
2137+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2138+ "Writing message to %d, passing sd: %d", sconf->child->output, sock_fd);
2139+
2140+ if ((rv = sendmsg(sconf->child->output, &msg, 0)) == -1)
2141+ {
2142+ apr_pool_destroy(r->pool);
2143+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2144+ "Writing message failed %d %d", rv, errno);
2145+ return -1;
2146+ }
2147+
2148+ _DBG("Writing message succeeded %d", rv);
2149+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2150+ "Writing message succeeded %d", rv);
2151+
2152+ if (bodypart_len) {
2153+ _DBG("Passing bodypart (bodypart_len=%d) \"%s\"", bodypart_len, bodypart);
2154+ if ((rv = send(sconf->child->output, bodypart, bodypart_len, 0)) == -1) {
2155+ apr_pool_destroy(r->pool);
2156+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2157+ "Writing message failed %d %d", rv, errno);
2158+ return -1;
2159+ }
2160+ _DBG("Writing message succeeded %d", rv);
2161+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf,
2162+ "Writing message succeeded %d", rv);
2163+ } else {
2164+ _DBG("No bodypart",0);
2165+ }
2166+
2167+ /* -- close the socket at our site -- */
2168+ apr_socket_close(thesock);
2169+ /* DS: What is the purpose of this?
2170+ * apr_socket_close(sconf->child->output) seems more reasonable
2171+ */
2172+ _DBG("closing socket %d at our side", sock_fd);
2173+ apr_pool_destroy(r->pool);
2174+ return 1;
2175+}
2176+
2177+static int metuxmpm_post_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *server_list)
2178+{
2179+ int i;
2180+ server_rec *sr_walk;
2181+ metuxmpm_server_conf *sconf;
2182+
2183+ for (sr_walk = server_list; sr_walk; sr_walk = sr_walk->next)
2184+ {
2185+ sconf = metuxmpm_SERVER_CONF(sr_walk->module_config);
2186+ if (sconf->child)
2187+ {
2188+ _DBG("server \"%s\" child=%d fd_in=%d fd_out=%d",
2189+ sr_walk->server_hostname,
2190+ sconf->child->id,
2191+ sconf->child->input,
2192+ sconf->child->output );
2193+ }
2194+ else
2195+ {
2196+ _DBG("server \"%s\" has no child assiocated.",
2197+ sr_walk->server_hostname);
2198+ }
2199+ }
2200+
2201+ thread_info_table = (thread_info_t *)apr_pcalloc(p, thread_limit * sizeof(thread_info_t));
2202+ for (i = 0; i < thread_limit; i++)
2203+ {
2204+ thread_info_table[i].sock_fd = AP_metuxmpm_THISCHILD;
2205+ thread_info_table[i].status = 0;
2206+ }
2207+ ap_child_table = (ap_ctable *)apr_pcalloc(p, server_limit * sizeof(ap_ctable));
2208+
2209+ return OK;
2210+}
2211+
2212+static int metuxmpm_post_read(request_rec *r)
2213+{
2214+ int thread_num = r->connection->id % thread_limit;
2215+ metuxmpm_server_conf *sconf = metuxmpm_SERVER_CONF(r->server->module_config);
2216+
2217+ if (!strlen(r->the_request))
2218+ {
2219+ _DBG("corrupt request. aborting",0);
2220+ return DECLINED;
2221+ }
2222+
2223+ if (thread_info_table[thread_num].sock_fd != AP_metuxmpm_THISCHILD)
2224+ {
2225+ apr_socket_t *sock = NULL;
2226+
2227+ apr_os_sock_put(&sock, &thread_info_table[thread_num].sock_fd,
2228+ r->connection->pool);
2229+ ap_sock_disable_nagle(sock);
2230+ ap_set_module_config(r->connection->conn_config, &core_module, sock);
2231+ _DBG("not the right socket? ",0);
2232+ return OK;
2233+ }
2234+
2235+ switch (child_info_table[child_num].type)
2236+ {
2237+ case CHILD_TYPE_MULTIPLEXER:
2238+ {
2239+ _DBG("MULTIPLEXER => Determining if request should be passed. "
2240+ "Child Num: %d, dest-child: %d, hostname from server: %s r->hostname=%s r->the_request=\"%s\"",
2241+ child_num, sconf->child->id, r->server->server_hostname, r->hostname, r->the_request);
2242+
2243+ if (sconf->child->id != child_num)
2244+ {
2245+ _DBG("Passing request.",0);
2246+ if (pass_request(r) == -1)
2247+ {
2248+ ap_log_error(APLOG_MARK, APLOG_ERR, 0,
2249+ ap_server_conf, "Could not pass request to proper "
2250+ "child, request will not be honoured.");
2251+ return DECLINED;
2252+ }
2253+ _DBG("doing longjmp",0);
2254+ longjmp(thread_info_table[thread_num].jmpbuffer, 1);
2255+ _DBG("request declined at our site",0);
2256+ return DECLINED;
2257+ _DBG("OUH! we should never reach this point",0);
2258+ }
2259+ _DBG("eeeh?! the server is assigned to the multiplexer! ... dropping request",0);
2260+ return DECLINED;
2261+ }
2262+ case CHILD_TYPE_PROCESSOR:
2263+ {
2264+ _DBG("PROCESSOR %d", child_num );
2265+ if (sconf->child->id != child_num)
2266+ {
2267+ _DBG("hmmpf! this server is not assigned to us! what did the mux have smoked ?!",0);
2268+ }
2269+ _DBG("request for %s / (server %s) seems to be for us", r->hostname, r->server->server_hostname );
2270+ return OK;
2271+ }
2272+ default:
2273+ {
2274+ _DBG("unspecified child type %d in %d, dropping request", child_info_table[child_num].type, child_num );
2275+ return OK;
2276+ }
2277+ }
2278+ _DBG("THIS POINT SHOULD NOT BE REACHED!",0);
2279+ return OK;
2280+}
2281+
2282+static void metuxmpm_hooks(apr_pool_t *p)
2283+{
2284+ /* The metuxmpm open_logs phase must run before the core's, or stderr
2285+ * will be redirected to a file, and the messages won't print to the
2286+ * console.
2287+ */
2288+ static const char *const aszSucc[] = {"core.c", NULL};
2289+ one_process = 0;
2290+
2291+ ap_hook_open_logs(metuxmpm_open_logs, NULL, aszSucc, APR_HOOK_MIDDLE);
2292+ ap_hook_pre_config(metuxmpm_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
2293+ ap_hook_post_config(metuxmpm_post_config, NULL, NULL, APR_HOOK_MIDDLE);
2294+
2295+ /* Both of these must be run absolutely first. If this request isn't for
2296+ * this server then we need to forward it to the proper child. No sense
2297+ * tying up this server running more post_read request hooks if it is
2298+ * just going to be forwarded along. The process_connection hook allows
2299+ * metuxmpm to receive the passed request correctly, by automatically
2300+ * filling in the core_input_filter's ctx pointer.
2301+ */
2302+ ap_hook_post_read_request(metuxmpm_post_read, NULL, NULL,
2303+ APR_HOOK_REALLY_FIRST);
2304+ ap_hook_process_connection(metuxmpm_process_connection, NULL, NULL,
2305+ APR_HOOK_REALLY_FIRST);
2306+}
2307+
2308+//static const char *cf_NumServers(cmd_parms *cmd, void *dummy,
2309+// const char *arg)
2310+//{
2311+// const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2312+// if (err != NULL) return err;
2313+//
2314+// num_childs = atoi(arg);
2315+// if (num_childs > server_limit) {
2316+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2317+// "WARNING: NumServers of %d exceeds ServerLimit value "
2318+// "of %d servers,", num_childs, server_limit);
2319+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2320+// " lowering NumServers to %d. To increase, please "
2321+// "see the", server_limit);
2322+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2323+// " ServerLimit directive.");
2324+// num_childs = server_limit;
2325+// }
2326+// else if (num_childs < 1)
2327+// {
2328+// ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2329+// "WARNING: Require NumServers > 0, setting to 1");
2330+// num_childs = 1;
2331+// }
2332+// return NULL;
2333+//}
2334+
2335+static const char *cf_StartThreads(cmd_parms *cmd, void *dummy,
2336+ const char *arg)
2337+{
2338+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2339+ if (err != NULL) return err;
2340+
2341+ threads_to_start = atoi(arg);
2342+ if (threads_to_start > thread_limit) {
2343+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2344+ "WARNING: StartThreads of %d exceeds ThreadLimit value"
2345+ " of %d threads,", threads_to_start,
2346+ thread_limit);
2347+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2348+ " lowering StartThreads to %d. To increase, please"
2349+ " see the", thread_limit);
2350+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2351+ " ThreadLimit directive.");
2352+ }
2353+ else if (threads_to_start < 1) {
2354+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2355+ "WARNING: Require StartThreads > 0, setting to 1");
2356+ threads_to_start = 1;
2357+ }
2358+ return NULL;
2359+}
2360+
2361+static const char *cf_MinSpareThreads(cmd_parms *cmd, void *dummy,
2362+ const char *arg)
2363+{
2364+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2365+ if (err != NULL) return err;
2366+
2367+ min_spare_threads = atoi(arg);
2368+ if (min_spare_threads <= 0)
2369+ {
2370+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2371+ "WARNING: detected MinSpareThreads set to non-positive.");
2372+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2373+ "Resetting to 1 to avoid almost certain Apache failure.");
2374+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2375+ "Please read the documentation.");
2376+ min_spare_threads = 1;
2377+ }
2378+
2379+ return NULL;
2380+}
2381+
2382+static const char *cf_MaxSpareThreads(cmd_parms *cmd, void *dummy,
2383+ const char *arg)
2384+{
2385+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2386+ if (err != NULL) return err;
2387+
2388+ max_spare_threads = atoi(arg);
2389+ if (max_spare_threads >= thread_limit)
2390+ {
2391+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2392+ "WARNING: detected MinSpareThreads set higher than");
2393+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2394+ "ThreadLimit. Resetting to %d", thread_limit);
2395+ max_spare_threads = thread_limit;
2396+ }
2397+ return NULL;
2398+}
2399+
2400+static const char *cf_MaxThreadsPerChild(cmd_parms *cmd, void *dummy, const char *arg)
2401+{
2402+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2403+ if (err != NULL) return err;
2404+
2405+ max_threads = atoi(arg);
2406+ if (max_threads > thread_limit)
2407+ {
2408+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2409+ "WARNING: detected MaxThreadsPerChild set higher than");
2410+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2411+ "ThreadLimit. Resetting to %d", thread_limit);
2412+ max_threads = thread_limit;
2413+ }
2414+ return NULL;
2415+}
2416+
2417+static const char* child_add ( int type, const char* user_name, const char* group_name ,const char* chroot_dir )
2418+{
2419+ _DBG("%d: %s.%s %s", num_childs, user_name, group_name, chroot_dir);
2420+ if (num_childs<server_limit)
2421+ {
2422+ int socks[2];
2423+ int l;
2424+
2425+ child_info_table[num_childs].uid = ap_uname2id(user_name);
2426+ child_info_table[num_childs].gid = ap_gname2id(group_name);
2427+ child_info_table[num_childs].type = type;
2428+ socketpair(PF_UNIX, SOCK_STREAM, 0, socks);
2429+ child_info_table[num_childs].input = socks[0];
2430+ child_info_table[num_childs].output = socks[1];
2431+ child_info_table[num_childs].chroot_dir = 0;
2432+ if (chroot_dir){
2433+ l = strlen(chroot_dir);
2434+ if (l > 0){
2435+ child_info_table[num_childs].chroot_dir = chroot_dir;
2436+ /* should copy the contents */
2437+ /* do we need to check its existence? */
2438+ }
2439+ }
2440+
2441+ _DBG("[%d] uid=%d gid=%d type=%d fd_in=%d fd_out=%d,chroot_dir=%s",
2442+ num_childs,
2443+ child_info_table[num_childs].uid,
2444+ child_info_table[num_childs].gid,
2445+ child_info_table[num_childs].type,
2446+ child_info_table[num_childs].input,
2447+ child_info_table[num_childs].output,
2448+ child_info_table[num_childs].chroot_dir
2449+ );
2450+
2451+ if (child_info_table[num_childs].uid == 0 ||
2452+ child_info_table[num_childs].gid == 0)
2453+ {
2454+ _DBG("Assigning root user/group to a child.",0);
2455+ }
2456+ num_childs++;
2457+ return NULL;
2458+ }
2459+
2460+ return "Trying to use more child ID's than NumServers. "
2461+ "Increase NumServers in your config file.";
2462+}
2463+
2464+/* we define an Processor w/ specific uid/gid */
2465+static const char *cf_Processor(
2466+ cmd_parms *cmd, void *dummy, const char *user_name, const char *group_name, const char *chroot_dir)
2467+{
2468+ _DBG("%d: %s.%s %s", num_childs, user_name, group_name, chroot_dir);
2469+ return child_add ( CHILD_TYPE_PROCESSOR, user_name, group_name, chroot_dir );
2470+}
2471+
2472+/* we define an Multiplexer child w/ specific uid/gid */
2473+static const char *cf_Multiplexer(
2474+ cmd_parms *cmd, void *dummy, const char *user_name, const char *group_name, const char *chroot_dir)
2475+{
2476+ _DBG("%d: %s.%s %s", num_childs, user_name, group_name, chroot_dir);
2477+ return child_add ( CHILD_TYPE_MULTIPLEXER, user_name, group_name, chroot_dir );
2478+}
2479+
2480+/* process the config file option AssignUserId */
2481+/* -- FIXME: perhaps we could add childs from here automatically -- */
2482+static const char * cf_AssignUserId
2483+(
2484+ cmd_parms *cmd,
2485+ void *dummy,
2486+ const char *user_name,
2487+ const char *group_name
2488+)
2489+{
2490+ int i;
2491+ int matching = 0;
2492+ int uid = ap_uname2id(user_name);
2493+ int gid = ap_gname2id(group_name);
2494+ const char *errstr;
2495+
2496+ metuxmpm_server_conf *sconf
2497+ = metuxmpm_SERVER_CONF(cmd->server->module_config);
2498+
2499+ sconf->fullsockname =
2500+ apr_pstrcat(cmd->pool, sconf->sockname, ".", user_name,":", group_name, NULL);
2501+
2502+ _DBG("user=\"%s\" (%d) group=\"%s\" (%d) numchilds=%d", user_name, uid, group_name, gid, num_childs );
2503+
2504+ for (i = 0; i < num_childs; i++)
2505+ {
2506+ _DBG("trying %d: %d.%d / %d", i,
2507+ child_info_table[i].uid, child_info_table[i].gid, child_info_table[i].type );
2508+
2509+ if ((uid == child_info_table[i].uid) &&
2510+ (gid == child_info_table[i].gid) &&
2511+ (child_info_table[i].type == CHILD_TYPE_PROCESSOR))
2512+ {
2513+ /* create an socket for this child, if it has no one */
2514+ /* FIXME: we should do it anywhere else, for _all_ childs */
2515+ sconf->child = &child_info_table[i];
2516+ _DBG("assigning server to child %d; "
2517+ "UID: %d, GID: %d, input=%d, output=%d",
2518+ i, uid, gid, sconf->child->input, sconf->child->output);
2519+ return NULL;
2520+ }
2521+ }
2522+
2523+ _DBG("assigning server to child FAILED %d; UID: %d, GID: %d ", i, uid, gid);
2524+ return "Unable to find process with matching uid/gid.";
2525+}
2526+
2527+static const char *cf_ServerLimit (cmd_parms *cmd, void *dummy, const char *arg)
2528+{
2529+ int tmp_server_limit;
2530+
2531+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2532+ if (err != NULL) return err;
2533+
2534+ tmp_server_limit = atoi(arg);
2535+ /* you cannot change ServerLimit across a restart; ignore
2536+ * any such attempts
2537+ */
2538+ if (first_server_limit && tmp_server_limit != server_limit)
2539+ {
2540+ /* how do we log a message? the error log is a bit bucket at this
2541+ * point; we'll just have to set a flag so that ap_mpm_run()
2542+ * logs a warning later
2543+ */
2544+ changed_limit_at_restart = 1;
2545+ return NULL;
2546+ }
2547+ server_limit = tmp_server_limit;
2548+
2549+ if (server_limit > MAX_SERVER_LIMIT)
2550+ {
2551+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2552+ "WARNING: ServerLimit of %d exceeds compile time limit "
2553+ "of %d servers,", server_limit, MAX_SERVER_LIMIT);
2554+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2555+ " lowering ServerLimit to %d.", MAX_SERVER_LIMIT);
2556+ server_limit = MAX_SERVER_LIMIT;
2557+ }
2558+ else if (server_limit < 1)
2559+ {
2560+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2561+ "WARNING: Require ServerLimit > 0, setting to 1");
2562+ server_limit = 1;
2563+ }
2564+ return NULL;
2565+}
2566+
2567+static const char *cf_ThreadLimit (cmd_parms *cmd, void *dummy, const char *arg)
2568+{
2569+ int tmp_thread_limit;
2570+
2571+ const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
2572+ if (err != NULL) return err;
2573+
2574+ tmp_thread_limit = atoi(arg);
2575+ /* you cannot change ThreadLimit across a restart; ignore
2576+ * any such attempts
2577+ */
2578+ if (first_thread_limit && tmp_thread_limit != thread_limit)
2579+ {
2580+ /* how do we log a message? the error log is a bit bucket at this
2581+ * point; we'll just have to set a flag so that ap_mpm_run()
2582+ * logs a warning later
2583+ */
2584+ changed_limit_at_restart = 1;
2585+ return NULL;
2586+ }
2587+ thread_limit = tmp_thread_limit;
2588+
2589+ if (thread_limit > MAX_THREAD_LIMIT)
2590+ {
2591+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2592+ "WARNING: ThreadLimit of %d exceeds compile time limit "
2593+ "of %d servers,", thread_limit, MAX_THREAD_LIMIT);
2594+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2595+ " lowering ThreadLimit to %d.", MAX_THREAD_LIMIT);
2596+ thread_limit = MAX_THREAD_LIMIT;
2597+ }
2598+ else if (thread_limit < 1)
2599+ {
2600+ ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
2601+ "WARNING: Require ThreadLimit > 0, setting to 1");
2602+ thread_limit = 1;
2603+ }
2604+ return NULL;
2605+}
2606+
2607+static const command_rec metuxmpm_cmds[] = {
2608+UNIX_DAEMON_COMMANDS,
2609+LISTEN_COMMANDS,
2610+AP_INIT_TAKE1("StartThreads", cf_StartThreads, NULL, RSRC_CONF,
2611+ "Number of threads each child creates"),
2612+AP_INIT_TAKE1("MinSpareThreads", cf_MinSpareThreads, NULL, RSRC_CONF,
2613+ "Minimum number of idle threads per child, to handle "
2614+ "request spikes"),
2615+AP_INIT_TAKE1("MaxSpareThreads", cf_MaxSpareThreads, NULL, RSRC_CONF,
2616+ "Maximum number of idle threads per child"),
2617+AP_INIT_TAKE1("MaxThreadsPerChild", cf_MaxThreadsPerChild, NULL, RSRC_CONF,
2618+ "Maximum number of threads per child"),
2619+AP_INIT_TAKE23("Multiplexer", cf_Multiplexer, NULL, RSRC_CONF,
2620+ "Specify an Multiplexer Child configuration."),
2621+AP_INIT_TAKE23("Processor", cf_Processor, NULL, RSRC_CONF,
2622+ "Specify a User and Group for a specific child process."),
2623+AP_INIT_TAKE2("AssignUserID", cf_AssignUserId, NULL, RSRC_CONF,
2624+ "Tie a virtual host to a specific child process."),
2625+AP_INIT_TAKE1("ServerLimit", cf_ServerLimit, NULL, RSRC_CONF,
2626+ "Maximum value of NumServers for this run of Apache"),
2627+AP_INIT_TAKE1("ThreadLimit", cf_ThreadLimit, NULL, RSRC_CONF,
2628+ "Maximum worker threads in a server for this run of Apache"),
2629+{ NULL }
2630+};
2631+
2632+/* == allocate an private server config structure == */
2633+static void *metuxmpm_create_config(apr_pool_t *p, server_rec *s)
2634+{
2635+ metuxmpm_server_conf *c = (metuxmpm_server_conf *)
2636+ apr_pcalloc(p, sizeof(metuxmpm_server_conf));
2637+ c->child = NULL;
2638+ return c;
2639+}
2640+
2641+module AP_MODULE_DECLARE_DATA mpm_metuxmpm_module =
2642+{
2643+ MPM20_MODULE_STUFF,
2644+ ap_mpm_rewrite_args, /* hook to run before apache parses args */
2645+ NULL, /* create per-directory config structure */
2646+ NULL, /* merge per-directory config structures */
2647+ metuxmpm_create_config, /* create per-server config structure */
2648+ NULL, /* merge per-server config structures */
2649+ metuxmpm_cmds, /* command apr_table_t */
2650+ metuxmpm_hooks /* register_hooks */
2651+};
2652+
81a3ef12
AM		 2653diff -urN httpd-2.2.0.org/server/mpm/experimental/metuxmpm/mpm_default.h httpd-2.2.0/server/mpm/experimental/metuxmpm/mpm_default.h
2654--- httpd-2.2.0.org/server/mpm/experimental/metuxmpm/mpm_default.h 1970-01-01 01:00:00.000000000 +0100
2655+++ httpd-2.2.0/server/mpm/experimental/metuxmpm/mpm_default.h 2005-12-02 22:05:16.488888500 +0100
2656@@ -0,0 +1,115 @@
4a17dc3c
AM		 2657+/* ====================================================================
2658+ * The Apache Software License, Version 1.1
2659+ *
2660+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
2661+ * reserved.
2662+ *
2663+ * Redistribution and use in source and binary forms, with or without
2664+ * modification, are permitted provided that the following conditions
2665+ * are met:
2666+ *
2667+ * 1. Redistributions of source code must retain the above copyright
2668+ * notice, this list of conditions and the following disclaimer.
2669+ *
2670+ * 2. Redistributions in binary form must reproduce the above copyright
2671+ * notice, this list of conditions and the following disclaimer in
2672+ * the documentation and/or other materials provided with the
2673+ * distribution.
2674+ *
2675+ * 3. The end-user documentation included with the redistribution,
2676+ * if any, must include the following acknowledgment:
2677+ * "This product includes software developed by the
2678+ * Apache Software Foundation (http://www.apache.org/)."
2679+ * Alternately, this acknowledgment may appear in the software itself,
2680+ * if and wherever such third-party acknowledgments normally appear.
2681+ *
2682+ * 4. The names "Apache" and "Apache Software Foundation" must
2683+ * not be used to endorse or promote products derived from this
2684+ * software without prior written permission. For written
2685+ * permission, please contact apache@apache.org.
2686+ *
2687+ * 5. Products derived from this software may not be called "Apache",
2688+ * nor may "Apache" appear in their name, without prior written
2689+ * permission of the Apache Software Foundation.
2690+ *
2691+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
2692+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
2693+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2694+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
2695+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2696+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2697+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
2698+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2699+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2700+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
2701+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2702+ * SUCH DAMAGE.
2703+ * ====================================================================
2704+ *
2705+ * This software consists of voluntary contributions made by many
2706+ * individuals on behalf of the Apache Software Foundation. For more
2707+ * information on the Apache Software Foundation, please see
2708+ * <http://www.apache.org/>.
2709+ *
2710+ * Portions of this software are based upon public domain software
2711+ * originally written at the National Center for Supercomputing Applications,
2712+ * University of Illinois, Urbana-Champaign.
2713+ */
2714+
81a3ef12
AM		 2715+#ifndef APACHE_MPM_DEFAULT_H
2716+#define APACHE_MPM_DEFAULT_H
4a17dc3c 2717+
81a3ef12 2718+#define NO_SERIALIZED_ACCEPT
4a17dc3c 2719+
81a3ef12
AM		 2720+/* Number of threads to spawn off by default --- also, if fewer than
2721+ * this free when the caretaker checks, it will spawn more.
2722+ */
2723+#ifndef DEFAULT_START_THREAD
2724+#define DEFAULT_START_THREAD 5
2725+#endif
4a17dc3c 2726+
81a3ef12
AM		 2727+/* Maximum number of *free* server threads --- more than this, and
2728+ * they will die off.
2729+ */
4a17dc3c 2730+
81a3ef12
AM		 2731+#ifndef DEFAULT_MAX_SPARE_THREAD
2732+#define DEFAULT_MAX_SPARE_THREAD 10
2733+#endif
4a17dc3c 2734+
81a3ef12 2735+/* Minimum --- fewer than this, and more will be created */
4a17dc3c 2736+
81a3ef12
AM		 2737+#ifndef DEFAULT_MIN_SPARE_THREAD
2738+#define DEFAULT_MIN_SPARE_THREAD 5
2739+#endif
4a17dc3c 2740+
81a3ef12
AM		 2741+/* Number of servers to spawn off by default
2742+ */
2743+#ifndef DEFAULT_NUM_DAEMON
2744+#define DEFAULT_NUM_DAEMON 2
2745+#endif
4a17dc3c 2746+
81a3ef12
AM		 2747+/* File used for accept locking, when we use a file */
2748+#ifndef DEFAULT_LOCKFILE
2749+#define DEFAULT_LOCKFILE DEFAULT_REL_RUNTIMEDIR "/accept.lock"
2750+#endif
4a17dc3c 2751+
81a3ef12
AM		 2752+/* Where the main/parent process's pid is logged */
2753+#ifndef DEFAULT_PIDLOG
2754+#define DEFAULT_PIDLOG DEFAULT_REL_RUNTIMEDIR "/httpd.pid"
2755+#endif
2756+
2757+/*
2758+ * Interval, in microseconds, between scoreboard maintenance.
2759+ */
2760+#ifndef SCOREBOARD_MAINTENANCE_INTERVAL
2761+#define SCOREBOARD_MAINTENANCE_INTERVAL 1000000
2762+#endif
2763+
2764+/* Number of requests to try to handle in a single process. If <= 0,
2765+ * the children don't die off.
2766+ */
2767+#ifndef DEFAULT_MAX_REQUESTS_PER_CHILD
2768+#define DEFAULT_MAX_REQUESTS_PER_CHILD 10000
2769+#endif
2770+
2771+#endif /* AP_MPM_DEFAULT_H */
2772diff -urN httpd-2.2.0.org/server/mpm/experimental/metuxmpm/mpm.h httpd-2.2.0/server/mpm/experimental/metuxmpm/mpm.h
2773--- httpd-2.2.0.org/server/mpm/experimental/metuxmpm/mpm.h 1970-01-01 01:00:00.000000000 +0100
2774+++ httpd-2.2.0/server/mpm/experimental/metuxmpm/mpm.h 2005-12-02 22:05:16.484888250 +0100
2775@@ -0,0 +1,100 @@
4a17dc3c
AM		 2776+/* ====================================================================
2777+ * The Apache Software License, Version 1.1
2778+ *
2779+ * Copyright (c) 2000-2002 The Apache Software Foundation. All rights
2780+ * reserved.
2781+ *
2782+ * Redistribution and use in source and binary forms, with or without
2783+ * modification, are permitted provided that the following conditions
2784+ * are met:
2785+ *
2786+ * 1. Redistributions of source code must retain the above copyright
2787+ * notice, this list of conditions and the following disclaimer.
2788+ *
2789+ * 2. Redistributions in binary form must reproduce the above copyright
2790+ * notice, this list of conditions and the following disclaimer in
2791+ * the documentation and/or other materials provided with the
2792+ * distribution.
2793+ *
2794+ * 3. The end-user documentation included with the redistribution,
2795+ * if any, must include the following acknowledgment:
2796+ * "This product includes software developed by the
2797+ * Apache Software Foundation (http://www.apache.org/)."
2798+ * Alternately, this acknowledgment may appear in the software itself,
2799+ * if and wherever such third-party acknowledgments normally appear.
2800+ *
2801+ * 4. The names "Apache" and "Apache Software Foundation" must
2802+ * not be used to endorse or promote products derived from this
2803+ * software without prior written permission. For written
2804+ * permission, please contact apache@apache.org.
2805+ *
2806+ * 5. Products derived from this software may not be called "Apache",
2807+ * nor may "Apache" appear in their name, without prior written
2808+ * permission of the Apache Software Foundation.
2809+ *
2810+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
2811+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
2812+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
2813+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
2814+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2815+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2816+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
2817+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
2818+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2819+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
2820+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2821+ * SUCH DAMAGE.
2822+ * ====================================================================
2823+ *
2824+ * This software consists of voluntary contributions made by many
2825+ * individuals on behalf of the Apache Software Foundation. For more
2826+ * information on the Apache Software Foundation, please see
2827+ * <http://www.apache.org/>.
2828+ *
2829+ * Portions of this software are based upon public domain software
2830+ * originally written at the National Center for Supercomputing Applications,
2831+ * University of Illinois, Urbana-Champaign.
2832+ */
2833+
81a3ef12
AM		 2834+#include "httpd.h"
2835+#include "mpm_default.h"
2836+#include "unixd.h"
4a17dc3c 2837+
81a3ef12
AM		 2838+#ifndef APACHE_MPM_METUXMPM_H
2839+#define APACHE_MPM_METUXMPM_H
4a17dc3c 2840+
81a3ef12 2841+#define METUXMPM_MPM
4a17dc3c 2842+
81a3ef12 2843+#define MPM_NAME "metuxmpm"
4a17dc3c 2844+
81a3ef12
AM		 2845+#define AP_MPM_WANT_RECLAIM_CHILD_PROCESSES
2846+#define AP_MPM_WANT_WAIT_OR_TIMEOUT
2847+#define AP_MPM_WANT_PROCESS_CHILD_STATUS
2848+#define AP_MPM_WANT_SET_PIDFILE
2849+#define AP_MPM_WANT_SET_SCOREBOARD
2850+#define AP_MPM_WANT_SET_LOCKFILE
2851+#define AP_MPM_WANT_SET_MAX_REQUESTS
2852+#define AP_MPM_WANT_SET_COREDUMPDIR
2853+#define AP_MPM_WANT_SET_ACCEPT_LOCK_MECH
2854+#define AP_MPM_WANT_SIGNAL_SERVER
2855+#define AP_MPM_USES_POD
4a17dc3c 2856+
81a3ef12
AM		 2857+#define MPM_CHILD_PID(i) (ap_scoreboard_image->parent[i].pid)
2858+#define MPM_NOTE_CHILD_KILLED(i) (MPM_CHILD_PID(i) = 0)
2859+#define MPM_ACCEPT_FUNC unixd_accept
4a17dc3c 2860+
81a3ef12
AM		 2861+/* Table of child status */
2862+#define SERVER_DEAD 0
2863+#define SERVER_DYING 1
2864+#define SERVER_ALIVE 2
4a17dc3c 2865+
81a3ef12
AM		 2866+typedef struct ap_ctable{
2867+ pid_t pid;
2868+ unsigned char status;
2869+} ap_ctable;
4a17dc3c 2870+
81a3ef12
AM		 2871+extern int ap_threads_per_child;
2872+extern int ap_max_daemons_limit;
2873+extern server_rec *ap_server_conf;
4a17dc3c 2874+
81a3ef12
AM		 2875+#endif /* APACHE_MPM_METUXMPM_H */
2876diff -urN httpd-2.2.0.org/srclib/apr/network_io/unix/sockets.c httpd-2.2.0/srclib/apr/network_io/unix/sockets.c
2877--- httpd-2.2.0.org/srclib/apr/network_io/unix/sockets.c 2005-09-09 10:21:17.000000000 +0200
2878+++ httpd-2.2.0/srclib/apr/network_io/unix/sockets.c 2005-12-02 22:05:16.488888500 +0100
2879@@ -416,7 +416,36 @@
4a17dc3c
AM		 2880 set_socket_vars(*sock, APR_INET, SOCK_STREAM, 0);
2881 (*sock)->timeout = -1;
2882 }
2883- (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
2884+// (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
2885+ if (1)
2886+ {
2887+ /* fixup socket's peer information.
2888+ we need it for the muxmpm. enrico weigelt, metux ITS
2889+ <weigelt@metux.de>
2890+ */
2891+ /* XXX next line looks bogus w.r.t. AF_INET6 support */
2892+
2893+ /* adjust remote address */
2894+ (*sock)->remote_addr->salen = sizeof((*sock)->remote_addr->sa);
2895+ getpeername(
2896+ *thesock,
2897+ (struct sockaddr*)&((*sock)->remote_addr->sa),
2898+ &((*sock)->remote_addr->salen)
2899+ );
2900+ (*sock)->remote_addr->port = ntohs((*sock)->remote_addr->sa.sin.sin_port);
2901+
2902+ /* XXX assumes sin_port and sin6_port at same offset */
2903+
2904+ /* adjust local address */
2905+ getsockname(
2906+ *thesock,
2907+ (struct sockaddr*)&((*sock)->local_addr->sa),
2908+ &((*sock)->local_addr->salen)
2909+ );
2910+ (*sock)->local_addr->port = ntohs((*sock)->local_addr->sa.sin.sin_port);
2911+ (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 0;
2912+ }
2913+
2914 (*sock)->remote_addr_unknown = 1;
2915 (*sock)->socketdes = *thesock;
2916 return APR_SUCCESS;
81a3ef12 2917
The most widely used Web server on the Internet
This page took 0.448985 seconds and 4 git commands to generate.