Hi,
Our company has been trying to benchmark(using ab) a large number of connections
to the web server(THREADED) on Solaris. The problem is we are often getting timeouts
(apr_poll: The timeout specified has expired (70007))
Originally we suspected the database connection in our module or in mod_perl was causing the problems,
so we retested with a dummy module call mod_foo ( attached ) but we still get timeouts.
Is this a know issue is the module api in threaded Apache ?
Reason for using threaded is we are implimenting connection pooling in our database, this gives MUCH
faster connection and through put times. This can't be done to the same level using preforked apache.
Full version information details of the benchmark are below:
% uname -a
SunOS sun642 5.9 Generic_112233-12 sun4u sparc SUNW,Ultra-4
Apache installation with the mpm worker threads:
% ./configure --with-mpm=worker --prefix=/usr/local/apache22
same behavior with the following option for Solaris/SPARC platform: --enable-nonportable-atomics=yes
% httpd -V
Server version: Apache/2.2.3
Server built: Jan 31 2007 01:00:53
Server's Module Magic Number: 20051115:3
Server loaded: APR 1.2.7, APR-Util 1.2.7
Compiled using: APR 1.2.7, APR-Util 1.2.7
Architecture: 32-bit
Server MPM: Worker
threaded: yes (fixed thread count)
forked: yes (variable process count)
Server compiled with....
-D APACHE_MPM_DIR="server/mpm/worker"
-D APR_HAS_SENDFILE
-D APR_HAS_MMAP
-D APR_HAVE_IPV6 (IPv4-mapped addresses enabled)
-D APR_USE_FCNTL_SERIALIZE
-D APR_USE_PTHREAD_SERIALIZE
-D SINGLE_LISTEN_UNSERIALIZED_ACCEPT
-D APR_HAS_OTHER_CHILD
-D AP_HAVE_RELIABLE_PIPED_LOGS
-D DYNAMIC_MODULE_LIMIT=128
-D HTTPD_ROOT="/usr/local/apache22"
-D SUEXEC_BIN="/usr/local/apache22/bin/suexec"
-D DEFAULT_SCOREBOARD="logs/apache_runtime_status"
-D DEFAULT_ERRORLOG="logs/error_log"
-D AP_TYPES_CONFIG_FILE="conf/mime.types"
-D SERVER_CONFIG_FILE="conf/httpd.conf"
% httpd -l
Compiled in modules:
core.c
mod_authn_file.c
mod_authn_default.c
mod_authz_host.c
mod_authz_groupfile.c
mod_authz_user.c
mod_authz_default.c
mod_auth_basic.c
mod_include.c
mod_filter.c
mod_log_config.c
mod_env.c
mod_setenvif.c
worker.c
http_core.c
mod_mime.c
mod_status.c
mod_autoindex.c
mod_asis.c
mod_cgid.c
mod_negotiation.c
mod_dir.c
mod_actions.c
mod_userdir.c
mod_alias.c
mod_so.c
Same behavior with the default or other values in the config files, so it's not necessary to provide them.
So, in the /usr/local/apache22/conf/extra/httpd-mpm.conf the following lines are still commented:
#include /usr/local/apache22/conf/extra/http-worker.conf
#include /usr/local/apache22/conf/extra/http-default.conf
The default ab.c timeout is 30 seconds:
apr_interval_time_t aprtimeout = apr_time_from_sec(30); /* timeout value */
mod_foo provided installation:
% cd /home/antslab/fourjs_apachebenchmark/httpd-2.2.3/modules/experimental/mod_foo.c
% apxs -c mod_foo.c
% apxs -i -a -n foo mod_foo.la
mod_foo bench test:
% ab -v 1 -n 2000 -c 200 http://192.168.11.87/foo-info
% sar 1 1000
03:06:44 80 20 0 0
03:06:45 77 23 0 0
03:06:46 78 22 0 0
03:06:47 78 18 0 4
03:06:48 78 7 0 16 <<< Something happens here!
03:06:49 77 3 0 20
03:06:50 75 1 0 24
03:06:51 75 2 0 23
03:06:52 77 6 0 17
...
(the Timeout expires after 30s)
Result:
Completed 1800 requests
apr_poll: The timeout specified has expired (70007)
Total of 1921 requests completed
Only one thread is still running out..
% ps -eLf | grep httpd
...
daemon 22326 22255 7 27 0 04:03:01 ? 0:00 /usr/local/apache22/bin/httpd -k start
daemon 22326 22255 8 27 20 04:03:01 ? 0:33 /usr/local/apache22/bin/httpd -k start <<< !
daemon 22326 22255 9 27 0 04:03:01 ? 0:00 /usr/local/apache22/bin/httpd -k start
...
% prstat
PID USERNAME SIZE RSS STATE PRI NICE TIME CPU PROCESS/NLWP
...
22326 daemon 26M 6096K cpu0 30 0 1:23:49 25% httpd/27
...
% pstack 22326
(normal thread)
----------------- lwp# 7 / thread# 7 --------------------
ff0d58f4 lwp_park (0, 0, 0)
ff0d166c mutex_lock_queue (ff0e8b44, 0, 17a738, ff0e8000, 81010100, ff00) + 104
ff0d206c slow_lock (17a738, feed2800, 4fbda0, fffffff8, 0, 4fbef5) + 58
ff29669c apr_thread_mutex_lock (17a730, 51b119, 0, 4, 0, 51b130) + 34
ff299758 allocator_alloc (179288, 1fe8, ff04283c, 1, 0, 51b0a0) + c0
ff29a8a4 apr_pool_create_ex (fc4fbb90, 1d26e0, 0, 0, 1f9610, fee74cf4) + bc
fee822d8 trace_add (1871d0, 0, 1f8df8, fee86cb0, 519e48, 51adf8) + c0
fee836fc x_quick_handler (519e80, 0, 519e80, 4fbe90, 51a018, 51a020) + 64
0007d488 ap_run_quick_handler (519e80, 0, 4, 519e80, 0, 51a031) + 78
000aa778 ap_process_request (519e80, 4, 519e80, 4fbe90, 81010100, ff00) + 40
000a60c8 ap_process_http_connection (4fbe90, 4fbda0, 4fbda0, fffffff8, 0, 4fbef5) + 80
000899ec ap_run_process_connection (4fbe90, 4fbda0, 4fbda0, 11a6, 4fbe88, 511e28) + 6c
0008a088 ap_process_connection (4fbe90, 4fbda0, 4fbda0, 11a6, 4fbe88, 511e28) + 98
000ce62c process_socket (4fbd60, 4fbda0, 9, 12, 511e28, 0) + c4
000cf270 worker_thread (184ba0, 1693e0, 0, 0, 0, 0) + 300
ff2acde8 dummy_worker (184ba0, 0, 0, 0, 0, 0) + 48
ff0d57b4 _lwp_start (0, 0, 0, 0, 0, 0)
(blocked thread)
----------------- lwp# 8 / thread# 8 --------------------
ff299bb4 allocator_free (179288, 2118a8, 0, 7efefeff, 0, 2118f8) + 8c
ff29a798 apr_pool_destroy (2118c0, 2118f8, 0, 0, 0, fee97f5c) + 170
fee61d60 trace_add (1871d0, 0, 1f95f8, fee64294, 746f746f, 297fc5) + 140
fee63078 x_insert_filter (29c848, 2a2e00, 188fc8, 0, 666f0070, 666f0049) + 60
00075908 ap_run_insert_filter (29c848, 0, 29c848, 276638, 0, 0) + 70
0007dd88 ap_invoke_handler (29c848, 0, 4, 29c848, 0, 29c9f9) + 18
000aa7b8 ap_process_request (29c848, 4, 29c848, 276638, 81010100, ff00) + 80
000a60c8 ap_process_http_connection (276638, 276548, 276548, fffffff8, 0, 27669d) + 80
000899ec ap_run_process_connection (276638, 276548, 276548, 11a7, 276630, 2845b0) + 6c
0008a088 ap_process_connection (276638, 276548, 276548, 11a7, 276630, 2845b0) + 98
000ce62c process_socket (276508, 276548, 9, 13, 2845b0, 0) + c4
000cf270 worker_thread (184bc0, 1693f8, 0, 0, 0, 0) + 300
ff2acde8 dummy_worker (184bc0, 0, 0, 0, 0, 0) + 48
ff0d57b4 _lwp_start (0, 0, 0, 0, 0, 0)
Regards,
--------------------------------------------------------------------------------
Neil J MARTIN [neilm@xxxxxxx] Tel +44 (0)208 757 5817 Fax +44 (0)208 757 5827
Product Support Engineer - Four J's Development Tools (UK) [www.4js.com]
--
Regards,
--------------------------------------------------------------------------------
Neil J MARTIN [neilm@xxxxxxx] Tel +44 (0)208 757 5817 Fax +44 (0)208 757 5827
Product Support Engineer - Four J's Development Tools (UK) [www.4js.com]
// Need to add extra -I to build flags to find these?
// I cheated and created a symbolic link in /usr/include to these files from my unixODBC folder.
// ln -s /opt3/unixODBC-2.2.11/include/sql.h ./sql.h
// ln -s /opt3/unixODBC-2.2.11/include/sqlext.h ./sqlext.h
// ln -s /opt3/unixODBC-2.2.11/include/sqltypes.h ./sqltypes.h
// ln -s /opt3/unixODBC-2.2.11/include/sqlucode.h ./sqlucode.h
#include <sql.h>
#include <sqlext.h>
#include <sqltypes.h>
// NJM forward declare of function(s)
void foo_test(request_rec *r);
void foo_getErrorInfo(SQLSMALLINT sqlhdltype, SQLHANDLE sqlhandle, request_rec *r);
#define ANTSDATESIZE 50
#define CHECK_RETCODE(t,h,m) \
if ( l_retcode != SQL_NO_DATA \
&& l_retcode != SQL_SUCCESS \
&& l_retcode != SQL_SUCCESS_WITH_INFO \
&& l_retcode != SQL_NEED_DATA ) { \
ap_rprintf(r, "%s, Status=%d<BR>\n",m, l_retcode) ; \
foo_getErrorInfo(t,h,r); \
}
#include "httpd.h"
#include "http_config.h"
#include "http_core.h"
#include "http_log.h"
#include "http_main.h"
#include "http_protocol.h"
#include "http_request.h"
#include "util_script.h"
#include "http_connection.h"
#include "apr_strings.h"
#include <stdio.h>
#include "mod_foo.h" // NJM
/*--------------------------------------------------------------------------*/
/* */
/* Data declarations. */
/* */
/* Here are the static cells and structure declarations private to our */
/* module. */
/* */
/*--------------------------------------------------------------------------*/
/*
* Sample configuration record. Used for both per-directory and per-server
* configuration data.
*
* It's perfectly reasonable to have two different structures for the two
* different environments. The same command handlers will be called for
* both, though, so the handlers need to be able to tell them apart. One
* possibility is for both structures to start with an int which is 0 for
* one and 1 for the other.
*
* Note that while the per-directory and per-server configuration records are
* available to most of the module handlers, they should be treated as
* READ-ONLY by all except the command and merge handlers. Sometimes handlers
* are handed a record that applies to the current location by implication or
* inheritance, and modifying it will change the rules for other locations.
*/
typedef struct x_cfg {
int cmode; /* Environment to which record applies
* (directory, server, or combination).
*/
#define CONFIG_MODE_SERVER 1
#define CONFIG_MODE_DIRECTORY 2
#define CONFIG_MODE_COMBO 3 /* Shouldn't ever happen. */
int local; /* Boolean: "foo" directive declared
* here?
*/
int congenital; /* Boolean: did we inherit an "foo"? */
char *trace; /* Pointer to trace string. */
char *loc; /* Location to which this record applies. */
} x_cfg;
/*
* Let's set up a module-local static cell to point to the accreting callback
* trace. As each API callback is made to us, we'll tack on the particulars
* to whatever we've already recorded. To avoid massive memory bloat as
* directories are walked again and again, we record the routine/environment
* the first time (non-request context only), and ignore subsequent calls for
* the same routine/environment.
*/
static const char *trace = NULL;
static apr_table_t *static_calls_made = NULL;
/*
* To avoid leaking memory from pools other than the per-request one, we
* allocate a module-private pool, and then use a sub-pool of that which gets
* freed each time we modify the trace. That way previous layers of trace
* data don't get lost.
*/
static apr_pool_t *x_pool = NULL;
static apr_pool_t *x_subpool = NULL;
/*
* Declare ourselves so the configuration routines can find and know us.
* We'll fill it in at the end of the module.
*/
module AP_MODULE_DECLARE_DATA foo_module;
/*--------------------------------------------------------------------------*/
/* */
/* The following pseudo-prototype declarations illustrate the parameters */
/* passed to command handlers for the different types of directive */
/* syntax. If an argument was specified in the directive definition */
/* (look for "command_rec" below), it's available to the command handler */
/* via the (void *) info field in the cmd_parms argument passed to the */
/* handler (cmd->info for the foos below). */
/* */
/*--------------------------------------------------------------------------*/
/*
* Command handler for a NO_ARGS directive. Declared in the command_rec
* list with
* AP_INIT_NO_ARGS("directive", function, mconfig, where, help)
*
* static const char *handle_NO_ARGS(cmd_parms *cmd, void *mconfig);
*/
/*
* Command handler for a RAW_ARGS directive. The "args" argument is the text
* of the commandline following the directive itself. Declared in the
* command_rec list with
* AP_INIT_RAW_ARGS("directive", function, mconfig, where, help)
*
* static const char *handle_RAW_ARGS(cmd_parms *cmd, void *mconfig,
* const char *args);
*/
/*
* Command handler for a FLAG directive. The single parameter is passed in
* "bool", which is either zero or not for Off or On respectively.
* Declared in the command_rec list with
* AP_INIT_FLAG("directive", function, mconfig, where, help)
*
* static const char *handle_FLAG(cmd_parms *cmd, void *mconfig, int bool);
*/
/*
* Command handler for a TAKE1 directive. The single parameter is passed in
* "word1". Declared in the command_rec list with
* AP_INIT_TAKE1("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE1(cmd_parms *cmd, void *mconfig,
* char *word1);
*/
/*
* Command handler for a TAKE2 directive. TAKE2 commands must always have
* exactly two arguments. Declared in the command_rec list with
* AP_INIT_TAKE2("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE2(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2);
*/
/*
* Command handler for a TAKE3 directive. Like TAKE2, these must have exactly
* three arguments, or the parser complains and doesn't bother calling us.
* Declared in the command_rec list with
* AP_INIT_TAKE3("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE3(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2, char *word3);
*/
/*
* Command handler for a TAKE12 directive. These can take either one or two
* arguments.
* - word2 is a NULL pointer if no second argument was specified.
* Declared in the command_rec list with
* AP_INIT_TAKE12("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE12(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2);
*/
/*
* Command handler for a TAKE123 directive. A TAKE123 directive can be given,
* as might be expected, one, two, or three arguments.
* - word2 is a NULL pointer if no second argument was specified.
* - word3 is a NULL pointer if no third argument was specified.
* Declared in the command_rec list with
* AP_INIT_TAKE123("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE123(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2, char *word3);
*/
/*
* Command handler for a TAKE13 directive. Either one or three arguments are
* permitted - no two-parameters-only syntax is allowed.
* - word2 and word3 are NULL pointers if only one argument was specified.
* Declared in the command_rec list with
* AP_INIT_TAKE13("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE13(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2, char *word3);
*/
/*
* Command handler for a TAKE23 directive. At least two and as many as three
* arguments must be specified.
* - word3 is a NULL pointer if no third argument was specified.
* Declared in the command_rec list with
* AP_INIT_TAKE23("directive", function, mconfig, where, help)
*
* static const char *handle_TAKE23(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2, char *word3);
*/
/*
* Command handler for a ITERATE directive.
* - Handler is called once for each of n arguments given to the directive.
* - word1 points to each argument in turn.
* Declared in the command_rec list with
* AP_INIT_ITERATE("directive", function, mconfig, where, help)
*
* static const char *handle_ITERATE(cmd_parms *cmd, void *mconfig,
* char *word1);
*/
/*
* Command handler for a ITERATE2 directive.
* - Handler is called once for each of the second and subsequent arguments
* given to the directive.
* - word1 is the same for each call for a particular directive instance (the
* first argument).
* - word2 points to each of the second and subsequent arguments in turn.
* Declared in the command_rec list with
* AP_INIT_ITERATE2("directive", function, mconfig, where, help)
*
* static const char *handle_ITERATE2(cmd_parms *cmd, void *mconfig,
* char *word1, char *word2);
*/
/*--------------------------------------------------------------------------*/
/* */
/* These routines are strictly internal to this module, and support its */
/* operation. They are not referenced by any external portion of the */
/* server. */
/* */
/*--------------------------------------------------------------------------*/
/*
* Locate our directory configuration record for the current request.
*/
static x_cfg *our_dconfig(const request_rec *r)
{
return (x_cfg *) ap_get_module_config(r->per_dir_config, &foo_module);
}
#if 0
/*
* Locate our server configuration record for the specified server.
*/
static x_cfg *our_sconfig(const server_rec *s)
{
return (x_cfg *) ap_get_module_config(s->module_config, &foo_module);
}
/*
* Likewise for our configuration record for the specified request.
*/
static x_cfg *our_rconfig(const request_rec *r)
{
return (x_cfg *) ap_get_module_config(r->request_config, &foo_module);
}
#endif
/*
* Likewise for our configuration record for a connection.
*/
static x_cfg *our_cconfig(const conn_rec *c)
{
return (x_cfg *) ap_get_module_config(c->conn_config, &foo_module);
}
/*
* This routine sets up some module-wide cells if they haven't been already.
*/
static void setup_module_cells(void)
{
/*
* If we haven't already allocated our module-private pool, do so now.
*/
if (x_pool == NULL) {
apr_pool_create(&x_pool, NULL);
};
/*
* Likewise for the table of routine/environment pairs we visit outside of
* request context.
*/
if (static_calls_made == NULL) {
static_calls_made = apr_table_make(x_pool, 16);
};
}
/*
* This routine is used to add a trace of a callback to the list. We're
* passed the server record (if available), the request record (if available),
* a pointer to our private configuration record (if available) for the
* environment to which the callback is supposed to apply, and some text. We
* turn this into a textual representation and add it to the tail of the list.
* The list can be displayed by the x_handler() routine.
*
* If the call occurs within a request context (i.e., we're passed a request
* record), we put the trace into the request apr_pool_t and attach it to the
* request via the notes mechanism. Otherwise, the trace gets added
* to the static (non-request-specific) list.
*
* Note that the r->notes table is only for storing strings; if you need to
* maintain per-request data of any other type, you need to use another
* mechanism.
*/
#define TRACE_NOTE "foo-trace"
static void trace_add(server_rec *s, request_rec *r, x_cfg *mconfig,
const char *note)
{
const char *sofar;
char *addon;
char *where;
apr_pool_t *p;
const char *trace_copy;
/*
* Make sure our pools and tables are set up - we need 'em.
*/
setup_module_cells();
/*
* Now, if we're in request-context, we use the request pool.
*/
if (r != NULL) {
p = r->pool;
if ((trace_copy = apr_table_get(r->notes, TRACE_NOTE)) == NULL) {
trace_copy = "";
}
}
else {
/*
* We're not in request context, so the trace gets attached to our
* module-wide pool. We do the create/destroy every time we're called
* in non-request context; this avoids leaking memory in some of
* the subsequent calls that allocate memory only once (such as the
* key formation below).
*
* Make a new sub-pool and copy any existing trace to it. Point the
* trace cell at the copied value.
*/
apr_pool_create(&p, x_pool);
if (trace != NULL) {
trace = apr_pstrdup(p, trace);
}
/*
* Now, if we have a sub-pool from before, nuke it and replace with
* the one we just allocated.
*/
if (x_subpool != NULL) {
apr_pool_destroy(x_subpool);
}
x_subpool = p;
trace_copy = trace;
}
/*
* If we weren't passed a configuration record, we can't figure out to
* what location this call applies. This only happens for co-routines
* that don't operate in a particular directory or server context. If we
* got a valid record, extract the location (directory or server) to which
* it applies.
*/
where = (mconfig != NULL) ? mconfig->loc : "nowhere";
where = (where != NULL) ? where : "";
/*
* Now, if we're not in request context, see if we've been called with
* this particular combination before. The apr_table_t is allocated in the
* module's private pool, which doesn't get destroyed.
*/
if (r == NULL) {
char *key;
key = apr_pstrcat(p, note, ":", where, NULL);
if (apr_table_get(static_calls_made, key) != NULL) {
/*
* Been here, done this.
*/
return;
}
else {
/*
* First time for this combination of routine and environment -
* log it so we don't do it again.
*/
apr_table_set(static_calls_made, key, "been here");
}
}
addon = apr_pstrcat(p,
" <li>\n"
" <dl>\n"
" <dt><samp>", note, "</samp></dt>\n"
" <dd><samp>[", where, "]</samp></dd>\n"
" </dl>\n"
" </li>\n",
NULL);
sofar = (trace_copy == NULL) ? "" : trace_copy;
trace_copy = apr_pstrcat(p, sofar, addon, NULL);
if (r != NULL) {
apr_table_set(r->notes, TRACE_NOTE, trace_copy);
}
else {
trace = trace_copy;
}
/*
* You *could* change the following if you wanted to see the calling
* sequence reported in the server's error_log, but beware - almost all of
* these co-routines are called for every single request, and the impact
* on the size (and readability) of the error_log is considerable.
*/
#define ANTS_LOG_EACH 0
if (ANTS_LOG_EACH && (s != NULL)) {
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "mod_foo: %s", note);
}
}
/*--------------------------------------------------------------------------*/
/* We prototyped the various syntax for command handlers (routines that */
/* are called when the configuration parser detects a directive declared */
/* by our module) earlier. Now we actually declare a "real" routine that */
/* will be invoked by the parser when our "real" directive is */
/* encountered. */
/* */
/* If a command handler encounters a problem processing the directive, it */
/* signals this fact by returning a non-NULL pointer to a string */
/* describing the problem. */
/* */
/* The magic return value DECLINE_CMD is used to deal with directives */
/* that might be declared by multiple modules. If the command handler */
/* returns NULL, the directive was processed; if it returns DECLINE_CMD, */
/* the next module (if any) that declares the directive is given a chance */
/* at it. If it returns any other value, it's treated as the text of an */
/* error message. */
/*--------------------------------------------------------------------------*/
/*
* Command handler for the NO_ARGS "foo" directive. All we do is mark the
* call in the trace log, and flag the applicability of the directive to the
* current location in that location's configuration record.
*/
static const char *cmd_foo(cmd_parms *cmd, void *mconfig)
{
x_cfg *cfg = (x_cfg *) mconfig;
/*
* "foo Wuz Here"
*/
cfg->local = 1;
trace_add(cmd->server, NULL, cfg, "cmd_foo()");
return NULL;
}
/*--------------------------------------------------------------------------*/
/* */
/* Now we declare our content handlers, which are invoked when the server */
/* encounters a document which our module is supposed to have a chance to */
/* see. (See mod_mime's SetHandler and AddHandler directives, and the */
/* mod_info and mod_status foos, for more details.) */
/* */
/* Since content handlers are dumping data directly into the connection */
/* (using the r*() routines, such as rputs() and rprintf()) without */
/* intervention by other parts of the server, they need to make */
/* sure any accumulated HTTP headers are sent first. This is done by */
/* calling send_http_header(). Otherwise, no header will be sent at all, */
/* and the output sent to the client will actually be HTTP-uncompliant. */
/*--------------------------------------------------------------------------*/
/*
* Sample content handler. All this does is display the call list that has
* been built up so far.
*
* The return value instructs the caller concerning what happened and what to
* do next:
* OK ("we did our thing")
* DECLINED ("this isn't something with which we want to get involved")
* HTTP_mumble ("an error status should be reported")
*/
static int x_handler(request_rec *r)
{
x_cfg *dcfg;
char *msgs;
short do_test;
//NJM
if (strcmp(r->handler, "foo-handler")) {
return DECLINED;
}
dcfg = our_dconfig(r);
do_test = 0;
trace_add(r->server, r, dcfg, "x_handler()");
// msgs = (char *)apr_palloc(r->pool, 200 ); // This crashes!!
msgs = (char *)malloc( 200 );
if (r->args != 0) {
sprintf(msgs, "x_handler() Args=%s\n",r->args );
trace_add(r->server, r, dcfg, msgs);
}
if (r->filename != 0) {
sprintf(msgs, "x_handler() FileName=%s\n",r->filename);
trace_add(r->server, r, dcfg, msgs);
// Need to strip this down so it only tests the final part, ie 'foo-info'
if ( strcmp(r->filename, "/usr/local/apache2/htdocs/foo-info" ) != 0 ) do_test = 1;
}
free(msgs);
/*
* We're about to start sending content, so we need to force the HTTP
* headers to be sent at this point. Otherwise, no headers will be sent
* at all. We can set any we like first, of course. **NOTE** Here's
* where you set the "Content-type" header, and you do so by putting it in
* r->content_type, *not* r->headers_out("Content-type"). If you don't
* set it, it will be filled in with the server's default type (typically
* "text/plain"). You *must* also ensure that r->content_type is lower
* case.
*
* We also need to start a timer so the server can know if the connexion
* is broken.
*/
ap_set_content_type(r, "text/html");
/*
* If we're only supposed to send header information (HEAD request), we're
* already there.
*/
if (r->header_only) {
return OK;
}
/*
* Now send our actual output. Since we tagged this as being
* "text/html", we need to embed any HTML.
*/
ap_rputs(DOCTYPE_HTML_3_2, r);
ap_rputs("<HTML>\n", r);
ap_rputs(" <HEAD>\n", r);
ap_rputs(" <TITLE>mod_foo Module Content-Handler Output\n", r);
ap_rputs(" </TITLE>\n", r);
ap_rputs(" </HEAD>\n", r);
ap_rputs(" <BODY>\n", r);
if ( do_test ) {
foo_test(r);
} else {
ap_rputs(" <H1><SAMP>mod_foo</SAMP> Module Content-Handler Output\n", r);
ap_rputs(" </H1>\n", r);
ap_rputs(" <P>\n", r);
/*
ap_rprintf(r, " Apache HTTP Server version: \"%s\"\n", ap_get_server_banner());
*/
ap_rputs(" <BR>\n", r);
ap_rprintf(r, " Server built: \"%s\"\n", ap_get_server_built());
ap_rputs(" </P>\n", r);;
ap_rprintf(r, " <H2>Static callbacks so far:</H2>\n <OL>\n%s </OL>\n", trace);
ap_rputs(" <H2>Request-specific callbacks so far:</H2>\n", r);
ap_rprintf(r, " <OL>\n%s </OL>\n", apr_table_get(r->notes, TRACE_NOTE));
ap_rputs(" <H2>Environment for <EM>this</EM> call:</H2>\n", r);
ap_rputs(" <UL>\n", r);
ap_rprintf(r, " <LI>Applies-to: <SAMP>%s</SAMP>\n </LI>\n", dcfg->loc);
ap_rprintf(r, " <LI>\"foo\" directive declared here: %s\n </LI>\n", (dcfg->local ? "YES" : "NO"));
ap_rprintf(r, " <LI>\"foo\" inherited: %s\n </LI>\n", (dcfg->congenital ? "YES" : "NO"));
ap_rputs(" </UL>\n", r);
}
ap_rputs(" </BODY>\n", r);
ap_rputs("</HTML>\n", r);
/*
* We're all done, so cancel the timeout we set. Since this is probably
* the end of the request we *could* assume this would be done during
* post-processing - but it's possible that another handler might be
* called and inherit our outstanding timer. Not good; to each its own.
*/
/*
* We did what we wanted to do, so tell the rest of the server we
* succeeded.
*/
return OK;
}
/*--------------------------------------------------------------------------*/
/* */
/* Now let's declare routines for each of the callback phase in order. */
/* (That's the order in which they're listed in the callback list, *not */
/* the order in which the server calls them! See the command_rec */
/* declaration near the bottom of this file.) Note that these may be */
/* called for situations that don't relate primarily to our function - in */
/* other words, the fixup handler shouldn't assume that the request has */
/* to do with "foo" stuff. */
/* */
/* With the exception of the content handler, all of our routines will be */
/* called for each request, unless an earlier handler from another module */
/* aborted the sequence. */
/* */
/* Handlers that are declared as "int" can return the following: */
/* */
/* OK Handler accepted the request and did its thing with it. */
/* DECLINED Handler took no action. */
/* HTTP_mumble Handler looked at request and found it wanting. */
/* */
/* What the server does after calling a module handler depends upon the */
/* handler's return value. In all cases, if the handler returns */
/* DECLINED, the server will continue to the next module with an handler */
/* for the current phase. However, if the handler return a non-OK, */
/* non-DECLINED status, the server aborts the request right there. If */
/* the handler returns OK, the server's next action is phase-specific; */
/* see the individual handler comments below for details. */
/* */
/*--------------------------------------------------------------------------*/
/*
* This function is called during server initialisation. Any information
* that needs to be recorded must be in static cells, since there's no
* configuration record.
*
* There is no return value.
*/
/*
* This function is called when an heavy-weight process (such as a child) is
* being run down or destroyed. As with the child initialisation function,
* any information that needs to be recorded must be in static cells, since
* there's no configuration record.
*
* There is no return value.
*/
/*
* This function is called during server initialisation when an heavy-weight
* process (such as a child) is being initialised. As with the
* module initialisation function, any information that needs to be recorded
* must be in static cells, since there's no configuration record.
*
* There is no return value.
*/
/*
* This function gets called to create a per-directory configuration
* record. This will be called for the "default" server environment, and for
* each directory for which the parser finds any of our directives applicable.
* If a directory doesn't have any of our directives involved (i.e., they
* aren't in the .htaccess file, or a <Location>, <Directory>, or related
* block), this routine will *not* be called - the configuration for the
* closest ancestor is used.
*
* The return value is a pointer to the created module-specific
* structure.
*/
static void *x_create_dir_config(apr_pool_t *p, char *dirspec)
{
x_cfg *cfg;
char *dname = dirspec;
/*
* Allocate the space for our record from the pool supplied.
*/
cfg = (x_cfg *) apr_pcalloc(p, sizeof(x_cfg));
/*
* Now fill in the defaults. If there are any `parent' configuration
* records, they'll get merged as part of a separate callback.
*/
cfg->local = 0;
cfg->congenital = 0;
cfg->cmode = CONFIG_MODE_DIRECTORY;
/*
* Finally, add our trace to the callback list.
*/
dname = (dname != NULL) ? dname : "";
cfg->loc = apr_pstrcat(p, "DIR(", dname, ")", NULL);
trace_add(NULL, NULL, cfg, "x_create_dir_config()");
return (void *) cfg;
}
/*
* This function gets called to merge two per-directory configuration
* records. This is typically done to cope with things like .htaccess files
* or <Location> directives for directories that are beneath one for which a
* configuration record was already created. The routine has the
* responsibility of creating a new record and merging the contents of the
* other two into it appropriately. If the module doesn't declare a merge
* routine, the record for the closest ancestor location (that has one) is
* used exclusively.
*
* The routine MUST NOT modify any of its arguments!
*
* The return value is a pointer to the created module-specific structure
* containing the merged values.
*/
static void *x_merge_dir_config(apr_pool_t *p, void *parent_conf,
void *newloc_conf)
{
x_cfg *merged_config = (x_cfg *) apr_pcalloc(p, sizeof(x_cfg));
x_cfg *pconf = (x_cfg *) parent_conf;
x_cfg *nconf = (x_cfg *) newloc_conf;
char *note;
/*
* Some things get copied directly from the more-specific record, rather
* than getting merged.
*/
merged_config->local = nconf->local;
merged_config->loc = apr_pstrdup(p, nconf->loc);
/*
* Others, like the setting of the `congenital' flag, get ORed in. The
* setting of that particular flag, for instance, is TRUE if it was ever
* true anywhere in the upstream configuration.
*/
merged_config->congenital = (pconf->congenital | pconf->local);
/*
* If we're merging records for two different types of environment (server
* and directory), mark the new record appropriately. Otherwise, inherit
* the current value.
*/
merged_config->cmode =
(pconf->cmode == nconf->cmode) ? pconf->cmode : CONFIG_MODE_COMBO;
/*
* Now just record our being called in the trace list. Include the
* locations we were asked to merge.
*/
note = apr_pstrcat(p, "x_merge_dir_config(\"", pconf->loc, "\",\"",
nconf->loc, "\")", NULL);
trace_add(NULL, NULL, merged_config, note);
return (void *) merged_config;
}
/*
* This function gets called to create a per-server configuration
* record. It will always be called for the "default" server.
*
* The return value is a pointer to the created module-specific
* structure.
*/
static void *x_create_server_config(apr_pool_t *p, server_rec *s)
{
x_cfg *cfg;
char *sname = s->server_hostname;
/*
* As with the x_create_dir_config() reoutine, we allocate and fill
* in an empty record.
*/
cfg = (x_cfg *) apr_pcalloc(p, sizeof(x_cfg));
cfg->local = 0;
cfg->congenital = 0;
cfg->cmode = CONFIG_MODE_SERVER;
/*
* Note that we were called in the trace list.
*/
sname = (sname != NULL) ? sname : "";
cfg->loc = apr_pstrcat(p, "SVR(", sname, ")", NULL);
trace_add(s, NULL, cfg, "x_create_server_config()");
return (void *) cfg;
}
/*
* This function gets called to merge two per-server configuration
* records. This is typically done to cope with things like virtual hosts and
* the default server configuration The routine has the responsibility of
* creating a new record and merging the contents of the other two into it
* appropriately. If the module doesn't declare a merge routine, the more
* specific existing record is used exclusively.
*
* The routine MUST NOT modify any of its arguments!
*
* The return value is a pointer to the created module-specific structure
* containing the merged values.
*/
static void *x_merge_server_config(apr_pool_t *p, void *server1_conf,
void *server2_conf)
{
x_cfg *merged_config = (x_cfg *) apr_pcalloc(p, sizeof(x_cfg));
x_cfg *s1conf = (x_cfg *) server1_conf;
x_cfg *s2conf = (x_cfg *) server2_conf;
char *note;
/*
* Our inheritance rules are our own, and part of our module's semantics.
* Basically, just note whence we came.
*/
merged_config->cmode =
(s1conf->cmode == s2conf->cmode) ? s1conf->cmode : CONFIG_MODE_COMBO;
merged_config->local = s2conf->local;
merged_config->congenital = (s1conf->congenital | s1conf->local);
merged_config->loc = apr_pstrdup(p, s2conf->loc);
/*
* Trace our call, including what we were asked to merge.
*/
note = apr_pstrcat(p, "x_merge_server_config(\"", s1conf->loc, "\",\"",
s2conf->loc, "\")", NULL);
trace_add(NULL, NULL, merged_config, note);
return (void *) merged_config;
}
/*
* This routine is called before the server processes the configuration
* files. There is no return value.
*/
static int x_pre_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp)
{
/*
* Log the call and exit.
*/
trace_add(NULL, NULL, NULL, "x_pre_config()");
return OK;
}
/*
* This routine is called to perform any module-specific fixing of header
* fields, et cetera. It is invoked just before any content-handler.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static int x_post_config(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
/*
* Log the call and exit.
*/
trace_add(NULL, NULL, NULL, "x_post_config()");
return OK;
}
/*
* This routine is called to perform any module-specific log file
* openings. It is invoked just before the post_config phase
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static int x_open_logs(apr_pool_t *pconf, apr_pool_t *plog,
apr_pool_t *ptemp, server_rec *s)
{
/*
* Log the call and exit.
*/
trace_add(s, NULL, NULL, "x_open_logs()");
return OK;
}
/*
* All our process-death routine does is add its trace to the log.
*/
static apr_status_t x_child_exit(void *data)
{
char *note;
server_rec *s = data;
char *sname = s->server_hostname;
/*
* The arbitrary text we add to our trace entry indicates for which server
* we're being called.
*/
sname = (sname != NULL) ? sname : "";
note = apr_pstrcat(s->process->pool, "x_child_exit(", sname, ")", NULL);
trace_add(s, NULL, NULL, note);
return APR_SUCCESS;
}
/*
* All our process initialiser does is add its trace to the log.
*/
static void x_child_init(apr_pool_t *p, server_rec *s)
{
char *note;
char *sname = s->server_hostname;
/*
* Set up any module cells that ought to be initialised.
*/
setup_module_cells();
/*
* The arbitrary text we add to our trace entry indicates for which server
* we're being called.
*/
sname = (sname != NULL) ? sname : "";
note = apr_pstrcat(p, "x_child_init(", sname, ")", NULL);
trace_add(s, NULL, NULL, note);
apr_pool_cleanup_register(p, s, x_child_exit, x_child_exit);
}
/*
* XXX: This routine is called XXX
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
#if 0
static const char *x_http_scheme(const request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and exit.
*/
trace_add(r->server, NULL, cfg, "x_http_scheme()");
return "foo";
}
/*
* XXX: This routine is called XXX
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static apr_port_t x_default_port(const request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and exit.
*/
trace_add(r->server, NULL, cfg, "x_default_port()");
return 80;
}
#endif /*0*/
/*
* XXX: This routine is called XXX
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static void x_insert_filter(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and exit.
*/
trace_add(r->server, NULL, cfg, "x_insert_filter()");
}
/*
* XXX: This routine is called XXX
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static int x_quick_handler(request_rec *r, int lookup_uri)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and exit.
*/
trace_add(r->server, NULL, cfg, "x_quick_handler()");
return DECLINED;
}
/*
* This routine is called just after the server accepts the connection,
* but before it is handed off to a protocol module to be served. The point
* of this hook is to allow modules an opportunity to modify the connection
* as soon as possible. The core server uses this phase to setup the
* connection record based on the type of connection that is being used.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static int x_pre_connection(conn_rec *c, void *csd)
{
x_cfg *cfg;
cfg = our_cconfig(c);
#if 0
/*
* Log the call and exit.
*/
trace_add(r->server, NULL, cfg, "x_pre_connection()");
#endif
return OK;
}
/* This routine is used to actually process the connection that was received.
* Only protocol modules should implement this hook, as it gives them an
* opportunity to replace the standard HTTP processing with processing for
* some other protocol. Both echo and POP3 modules are available as
* foos.
*
* The return VALUE is OK, DECLINED, or HTTP_mumble. If we return OK, no
* further modules are called for this phase.
*/
static int x_process_connection(conn_rec *c)
{
return DECLINED;
}
/*
* This routine is called after the request has been read but before any other
* phases have been processed. This allows us to make decisions based upon
* the input header fields.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, no
* further modules are called for this phase.
*/
static int x_post_read_request(request_rec *r)
{
x_cfg *cfg;
char *msgs;
cfg = our_dconfig(r);
/*
* We don't actually *do* anything here, except note the fact that we were
* called.
*/
trace_add(r->server, r, cfg, "x_post_read_request()");
//NJM1
msgs = (char *)malloc( 500 );
if (r->args != 0) {
sprintf(msgs, "x_post_read_request() Args=%s\n",r->args );
trace_add(r->server, r, cfg, msgs);
}
if (r->filename != 0) {
sprintf(msgs, "x_post_read_request() FN=%s\n",r->filename);
trace_add(r->server, r, cfg, msgs);
}
free(msgs);
return DECLINED;
}
/*
* This routine gives our module an opportunity to translate the URI into an
* actual filename. If we don't do anything special, the server's default
* rules (Alias directives and the like) will continue to be followed.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, no
* further modules are called for this phase.
*/
static int x_translate_handler(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* We don't actually *do* anything here, except note the fact that we were
* called.
*/
trace_add(r->server, r, cfg, "x_translate_handler()");
return DECLINED;
}
/*
* This routine maps r->filename to a physical file on disk. Useful for
* overriding default core behavior, including skipping mapping for
* requests that are not file based.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, no
* further modules are called for this phase.
*/
static int x_map_to_storage_handler(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* We don't actually *do* anything here, except note the fact that we were
* called.
*/
trace_add(r->server, r, cfg, "x_map_to_storage_handler()");
return DECLINED;
}
/*
* this routine gives our module another chance to examine the request
* headers and to take special action. This is the first phase whose
* hooks' configuration directives can appear inside the <Directory>
* and similar sections, because at this stage the URI has been mapped
* to the filename. For foo this phase can be used to block evil
* clients, while little resources were wasted on these.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK,
* the server will still call any remaining modules with an handler
* for this phase.
*/
static int x_header_parser_handler(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* We don't actually *do* anything here, except note the fact that we were
* called.
*/
trace_add(r->server, r, cfg, "header_parser_handler()");
return DECLINED;
}
/*
* This routine is called to check the authentication information sent with
* the request (such as looking up the user in a database and verifying that
* the [encrypted] password sent matches the one in the database).
*
* The return value is OK, DECLINED, or some HTTP_mumble error (typically
* HTTP_UNAUTHORIZED). If we return OK, no other modules are given a chance
* at the request during this phase.
*/
static int x_check_user_id(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Don't do anything except log the call.
*/
trace_add(r->server, r, cfg, "x_check_user_id()");
return DECLINED;
}
/*
* This routine is called to check to see if the resource being requested
* requires authorisation.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, no
* other modules are called during this phase.
*
* If *all* modules return DECLINED, the request is aborted with a server
* error.
*/
static int x_auth_checker(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and return OK, or access will be denied (even though we
* didn't actually do anything).
*/
trace_add(r->server, r, cfg, "x_auth_checker()");
return DECLINED;
}
/*
* This routine is called to check for any module-specific restrictions placed
* upon the requested resource. (See the mod_access module for an foo.)
*
* The return value is OK, DECLINED, or HTTP_mumble. All modules with an
* handler for this phase are called regardless of whether their predecessors
* return OK or DECLINED. The first one to return any other status, however,
* will abort the sequence (and the request) as usual.
*/
static int x_access_checker(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
trace_add(r->server, r, cfg, "x_access_checker()");
return DECLINED;
}
/*
* This routine is called to determine and/or set the various document type
* information bits, like Content-type (via r->content_type), language, et
* cetera.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, no
* further modules are given a chance at the request for this phase.
*/
static int x_type_checker(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call, but don't do anything else - and report truthfully that
* we didn't do anything.
*/
trace_add(r->server, r, cfg, "x_type_checker()");
return DECLINED;
}
/*
* This routine is called to perform any module-specific fixing of header
* fields, et cetera. It is invoked just before any content-handler.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, the
* server will still call any remaining modules with an handler for this
* phase.
*/
static int x_fixer_upper(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
/*
* Log the call and exit.
*/
trace_add(r->server, r, cfg, "x_fixer_upper()");
return OK;
}
/*
* This routine is called to perform any module-specific logging activities
* over and above the normal server things.
*
* The return value is OK, DECLINED, or HTTP_mumble. If we return OK, any
* remaining modules with an handler for this phase will still be called.
*/
static int x_logger(request_rec *r)
{
x_cfg *cfg;
cfg = our_dconfig(r);
trace_add(r->server, r, cfg, "x_logger()");
return DECLINED;
}
/*--------------------------------------------------------------------------*/
/* */
/* Which functions are responsible for which hooks in the server. */
/* */
/*--------------------------------------------------------------------------*/
/*
* Each function our module provides to handle a particular hook is
* specified here. The functions are registered using
* ap_hook_foo(name, predecessors, successors, position)
* where foo is the name of the hook.
*
* The args are as follows:
* name -> the name of the function to call.
* predecessors -> a list of modules whose calls to this hook must be
* invoked before this module.
* successors -> a list of modules whose calls to this hook must be
* invoked after this module.
* position -> The relative position of this module. One of
* APR_HOOK_FIRST, APR_HOOK_MIDDLE, or APR_HOOK_LAST.
* Most modules will use APR_HOOK_MIDDLE. If multiple
* modules use the same relative position, Apache will
* determine which to call first.
* If your module relies on another module to run first,
* or another module running after yours, use the
* predecessors and/or successors.
*
* The number in brackets indicates the order in which the routine is called
* during request processing. Note that not all routines are necessarily
* called (such as if a resource doesn't have access restrictions).
* The actual delivery of content to the browser [9] is not handled by
* a hook; see the handler declarations below.
*/
static void x_register_hooks(apr_pool_t *p)
{
ap_hook_pre_config(x_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_post_config(x_post_config, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_open_logs(x_open_logs, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_child_init(x_child_init, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_handler(x_handler, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_quick_handler(x_quick_handler, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_pre_connection(x_pre_connection, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_process_connection(x_process_connection, NULL, NULL, APR_HOOK_MIDDLE);
/* [1] post read_request handling */
ap_hook_post_read_request(x_post_read_request, NULL, NULL,
APR_HOOK_MIDDLE);
ap_hook_log_transaction(x_logger, NULL, NULL, APR_HOOK_MIDDLE);
#if 0
ap_hook_http_scheme(x_http_scheme, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_default_port(x_default_port, NULL, NULL, APR_HOOK_MIDDLE);
#endif
ap_hook_translate_name(x_translate_handler, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_map_to_storage(x_map_to_storage_handler, NULL,NULL, APR_HOOK_MIDDLE);
ap_hook_header_parser(x_header_parser_handler, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_check_user_id(x_check_user_id, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_fixups(x_fixer_upper, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_type_checker(x_type_checker, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_access_checker(x_access_checker, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_auth_checker(x_auth_checker, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_insert_filter(x_insert_filter, NULL, NULL, APR_HOOK_MIDDLE);
}
/*--------------------------------------------------------------------------*/
/* */
/* All of the routines have been declared now. Here's the list of */
/* directives specific to our module, and information about where they */
/* may appear and how the command parser should pass them to us for */
/* processing. Note that care must be taken to ensure that there are NO */
/* collisions of directive names between modules. */
/* */
/*--------------------------------------------------------------------------*/
/*
* List of directives specific to our module.
*/
static const command_rec x_cmds[] =
{
AP_INIT_NO_ARGS(
"Ants", /* directive name */
cmd_foo, /* config action routine */
NULL, /* argument to include in call */
OR_OPTIONS, /* where available */
"Ants directive - no arguments" /* directive description */
),
{NULL}
};
/*--------------------------------------------------------------------------*/
/* */
/* Finally, the list of callback routines and data structures that provide */
/* the static hooks into our module from the other parts of the server. */
/* */
/*--------------------------------------------------------------------------*/
/*
* Module definition for configuration. If a particular callback is not
* needed, replace its routine name below with the word NULL.
*/
module AP_MODULE_DECLARE_DATA foo_module =
{
STANDARD20_MODULE_STUFF,
x_create_dir_config, /* per-directory config creator */
x_merge_dir_config, /* dir config merger */
x_create_server_config, /* server config creator */
x_merge_server_config, /* server config merger */
x_cmds, /* command table */
x_register_hooks, /* set up other request processing hooks */
};
/*--------------------------------------------------------------------------*/
/* NJM: */
/* Do our Ants Test Here */
/*--------------------------------------------------------------------------*/
void foo_test(request_rec *r)
{
// SQLRETURN l_retcode;
// SQLHENV l_henv;
// SQLHDBC l_hdbc;
// SQLHSTMT l_hstmt1, l_hstmt2;
char l_dsn[20];
char l_usr[20];
char l_pwd[20];
char *l_stmt;
int l_retLen;
short l_pno;
// Record
int tra_urn;
int tra_phone_urn;
int tra_manager_pin;
int tra_team_pin;
char tra_source[9];
short tra_playerout;
short tra_playerin;
char tra_receipt_date[ANTSDATESIZE];
char tra_receipt_time[6];
char tra_effect_date[ANTSDATESIZE];
short tra_sequence;
int tra_linkno;
int tra_val_link;
char tra_status[9];
char tra_status_date[ANTSDATESIZE];
short tra_week_no;
short tra_day_no;
int tra_batchno;
char tra_recdate[ANTSDATESIZE];
char tra_upddate[ANTSDATESIZE];
char tra_upduser[6];
char tra_updstat[4];
int tra_procbatch;
ap_rputs(" <H1>Doing Ants Test</H1>\n", r);
strcpy(l_dsn, "foo_dsn");
strcpy(l_usr, "foo");
strcpy(l_pwd, "TOTO");
ap_rprintf(r, "DSN=\"%s\"\n User=\"%s\" Password=\"%s\"<BR>\n", l_dsn, l_usr, l_pwd) ;
// CONNECTION CODE
ap_rputs("<BR><B>Connecting...</B><BR>",r);
ap_rputs("<BR><B>Process Statements...</B><BR>",r);
// Allocate statement Handles
// Prepare statements
ap_rputs("<BR><B>Prepare Statements...</B><BR>",r);
// Execute select statement
ap_rputs("<BR><B>Execute Statements...</B><BR>",r);
// Bind Columns for the Select.
// Free statement Handle
// DISCONNECT CODE
ap_rputs("<BR><B>Disconnect...</B><BR>",r);
ap_rputs("<BR><B>Finished.</B><BR>",r);
}
/*--------------------------------------------------------------------------*/
void foo_getErrorInfo(SQLSMALLINT sqlhdltype, SQLHANDLE sqlhandle, request_rec *r)
{
SQLRETURN rcode = 0;
SQLCHAR sqlstate[SQL_SQLSTATE_SIZE + 1];
SQLINTEGER naterror = 0;
SQLCHAR msgtext[SQL_MAX_MESSAGE_LENGTH + 1];
SQLSMALLINT msgtextl = 0;
rcode = SQLGetDiagRec((SQLSMALLINT) sqlhdltype,
(SQLHANDLE) sqlhandle,
(SQLSMALLINT) 1,
(SQLCHAR *) sqlstate,
(SQLINTEGER *) & naterror,
(SQLCHAR *) msgtext,
(SQLSMALLINT) sizeof(msgtext),
(SQLSMALLINT *) & msgtextl);
ap_rprintf(r, "Diagnostic info:<BR>\n");
ap_rprintf(r, " SQL State: %s<BR>\n", (char *) sqlstate);
ap_rprintf(r, " SQL code : %d<BR>\n", (int) naterror);
ap_rprintf(r, " Message : %s<BR>\n", (char *) msgtext);
}
/*--------------------------------------------------------------------------*/
--------------------------------------------------------------------- The official User-To-User support forum of the Apache HTTP Server Project. See <URL:http://httpd.apache.org/userslist.html> for more info. To unsubscribe, e-mail: users-unsubscribe@xxxxxxxxxxxxxxxx " from the digest: users-digest-unsubscribe@xxxxxxxxxxxxxxxx For additional commands, e-mail: users-help@xxxxxxxxxxxxxxxx
|