diff options
| -rw-r--r-- | web/Makefile | 4 | ||||
| -rw-r--r-- | web/libptt.a | bin | 107932 -> 0 bytes | |||
| -rw-r--r-- | web/mod_ptt.c | 895 | ||||
| -rwxr-xr-x | web/util_cache.c | 6 | ||||
| -rwxr-xr-x | web/util_passwd.c | 4 | ||||
| -rwxr-xr-x | web/util_record.c | 3 |
6 files changed, 38 insertions, 874 deletions
diff --git a/web/Makefile b/web/Makefile index bff43078..42a1a84a 100644 --- a/web/Makefile +++ b/web/Makefile @@ -1,4 +1,6 @@ all: mod_ptt.c mod_ptt.h - apxs -I ../include -c mod_ptt.c + apxs -I ../include -c mod_ptt.c util_cache.c util_passwd.c util_record.c cp mod_ptt.so /usr/local/libexec/apache/mod_ptt.so chmod 775 /usr/local/libexec/apache/mod_ptt.so +clean: + rm -f *.o *.a *.so diff --git a/web/libptt.a b/web/libptt.a Binary files differdeleted file mode 100644 index 26c2f527..00000000 --- a/web/libptt.a +++ /dev/null diff --git a/web/mod_ptt.c b/web/mod_ptt.c index a6427a32..be4a8071 100644 --- a/web/mod_ptt.c +++ b/web/mod_ptt.c @@ -1,36 +1,6 @@ -/* - * Apache example module. Provide demonstrations of how modules do things. - * - */ - #include "mod_ptt.h" extern int numboards; extern boardheader_t *bcache; -/*--------------------------------------------------------------------------*/ -/* */ -/* 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 zero 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 excfg { int cmode; /* Environment to which record applies (directory, * server, or combination). @@ -44,186 +14,19 @@ typedef struct excfg { char *loc; /* Location to which this record applies. */ } excfg; -/* - * 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 table *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 pool *ptt_pool = NULL; static pool *ptt_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 MODULE_VAR_EXPORT ptt_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 examples below). */ -/* */ -/*--------------------------------------------------------------------------*/ - -/* - * Command handler for a NO_ARGS directive. - * - * 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. - * - * 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. - * - * 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". - * - * 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. - * - * 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. - * - * 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. - * - * 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. - * - * 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. - * - * 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. - * - * 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. - * - * 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. - * - * 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 excfg *our_dconfig(request_rec *r) +excfg * our_dconfig(request_rec *r) { return (excfg *) ap_get_module_config(r->per_dir_config, &ptt_module); } -#if 0 -/* - * Locate our server configuration record for the specified server. - */ -static excfg *our_sconfig(server_rec *s) -{ - - return (excfg *) ap_get_module_config(s->module_config, &ptt_module); -} - -/* - * Likewise for our configuration record for the specified request. - */ -static excfg *our_rconfig(request_rec *r) -{ - - return (excfg *) ap_get_module_config(r->request_config, &ptt_module); -} -#endif - -/* - * This routine sets up some module-wide cells if they haven't been already. - */ static void setup_module_cells() { /* @@ -241,212 +44,19 @@ static void setup_module_cells() }; } -/* - * 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 example_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 pool 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 "ptt-trace" - -static void trace_add(server_rec *s, request_rec *r, excfg *mconfig, - const char *note) -{ - - const char *sofar; - char *addon; - char *where; - pool *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 = ap_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. - */ - p = ap_make_sub_pool(ptt_pool); - if (trace != NULL) { - trace = ap_pstrdup(p, trace); - } - /* - * Now, if we have a sub-pool from before, nuke it and replace with - * the one we just allocated. - */ - if (ptt_subpool != NULL) { - ap_destroy_pool(ptt_subpool); - } - ptt_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 table is allocated in the - * module's private pool, which doesn't get destroyed. - */ - if (r == NULL) { - char *key; - - key = ap_pstrcat(p, note, ":", where, NULL); - if (ap_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. - */ - ap_table_set(static_calls_made, key, "been here"); - } - } - addon = ap_pstrcat(p, " <LI>\n", " <DL>\n", " <DT><SAMP>", - note, "</SAMP>\n", " </DT>\n", " <DD><SAMP>[", - where, "]</SAMP>\n", " </DD>\n", " </DL>\n", - " </LI>\n", NULL); - sofar = (trace_copy == NULL) ? "" : trace_copy; - trace_copy = ap_pstrcat(p, sofar, addon, NULL); - if (r != NULL) { - ap_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 EXAMPLE_LOG_EACH 0 -#if EXAMPLE_LOG_EACH - if (s != NULL) { - ap_log_error(APLOG_MARK, APLOG_DEBUG, s, "mod_ptt: %s", note); - } -#endif -} - -/*--------------------------------------------------------------------------*/ -/* 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 "Example" 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_ptt(cmd_parms *cmd, void *mconfig) -{ - excfg *cfg = (excfg *) mconfig; - /* - * "Example Wuz Here" - */ - cfg->local = 1; - trace_add(cmd->server, NULL, cfg, "cmd_ptt()"); - 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 examples, for more details.) */ -/* */ -/* Since content handlers are dumping data directly into the connexion */ -/* (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 ptt_handler(request_rec *r) { int i; excfg *dcfg; dcfg = our_dconfig(r); - trace_add(r->server, r, dcfg, "ptt_handler()"); - /* - * 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. - */ + //resolve_utmp(); + //resolve_boards(); + // resolve_garbage(); + // resolve_fcache(); + r->content_type = "text/html"; ap_soft_timeout("send ptt call trace", r); @@ -537,50 +147,16 @@ static int ptt_handler(request_rec *r) * There is no return value. */ -/* - * All our module-initialiser does is add its trace to the log. - */ -static void ptt_init(server_rec *s, pool *p) -{ - - 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 = ap_pstrcat(p, "ptt_init(", sname, ")", NULL); - trace_add(s, NULL, NULL, note); -} - -/* - * 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. - */ - -/* - * All our process-initialiser does is add its trace to the log. - */ static void ptt_child_init(server_rec *s, pool *p) { char *note; char *sname = s->server_hostname; - resolve_utmp(); - resolve_boards(); - resolve_garbage(); - resolve_fcache(); + //resolve_utmp(); + //resolve_boards(); + //resolve_garbage(); + //resolve_fcache(); /* * Set up any module cells that ought to be initialised. */ @@ -591,21 +167,8 @@ static void ptt_child_init(server_rec *s, pool *p) */ sname = (sname != NULL) ? sname : ""; note = ap_pstrcat(p, "ptt_child_init(", sname, ")", NULL); - trace_add(s, NULL, NULL, note); } -/* - * 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. - */ - -/* - * All our process-death routine does is add its trace to the log. - */ static void ptt_child_exit(server_rec *s, pool *p) { @@ -618,439 +181,33 @@ static void ptt_child_exit(server_rec *s, pool *p) */ sname = (sname != NULL) ? sname : ""; note = ap_pstrcat(p, "ptt_child_exit(", sname, ")", NULL); - trace_add(s, NULL, NULL, note); -} - -/* - * 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 *ptt_create_dir_config(pool *p, char *dirspec) -{ - - excfg *cfg; - char *dname = dirspec; - - /* - * Allocate the space for our record from the pool supplied. - */ - cfg = (excfg *) ap_pcalloc(p, sizeof(excfg)); - /* - * 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 = ap_pstrcat(p, "DIR(", dname, ")", NULL); - trace_add(NULL, NULL, cfg, "ptt_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 *ptt_merge_dir_config(pool *p, void *parent_conf, - void *newloc_conf) -{ - - excfg *merged_config = (excfg *) ap_pcalloc(p, sizeof(excfg)); - excfg *pconf = (excfg *) parent_conf; - excfg *nconf = (excfg *) 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 = ap_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 = ap_pstrcat(p, "ptt_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 *ptt_create_server_config(pool *p, server_rec *s) -{ - - excfg *cfg; - char *sname = s->server_hostname; - - /* - * As with the ptt_create_dir_config() reoutine, we allocate and fill - * in an empty record. - */ - cfg = (excfg *) ap_pcalloc(p, sizeof(excfg)); - 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 = ap_pstrcat(p, "SVR(", sname, ")", NULL); - trace_add(s, NULL, cfg, "ptt_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 *ptt_merge_server_config(pool *p, void *server1_conf, - void *server2_conf) -{ - - excfg *merged_config = (excfg *) ap_pcalloc(p, sizeof(excfg)); - excfg *s1conf = (excfg *) server1_conf; - excfg *s2conf = (excfg *) 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 = ap_pstrdup(p, s2conf->loc); - /* - * Trace our call, including what we were asked to merge. - */ - note = ap_pstrcat(p, "ptt_merge_server_config(\"", s1conf->loc, "\",\"", - s2conf->loc, "\")", NULL); - trace_add(NULL, NULL, merged_config, note); - return (void *) merged_config; -} - -/* - * 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 ptt_post_read_request(request_rec *r) -{ - - excfg *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, "ptt_post_read_request()"); - 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 ptt_translate_handler(request_rec *r) -{ - - excfg *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, "ptt_translate_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 ptt_check_user_id(request_rec *r) -{ - - excfg *cfg; - - cfg = our_dconfig(r); - /* - * Don't do anything except log the call. - */ - trace_add(r->server, r, cfg, "ptt_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 ptt_auth_checker(request_rec *r) -{ - - excfg *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, "ptt_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 example.) - * - * 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 ptt_access_checker(request_rec *r) -{ - - excfg *cfg; - - cfg = our_dconfig(r); - trace_add(r->server, r, cfg, "ptt_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 ptt_type_checker(request_rec *r) -{ - - excfg *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, "ptt_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 ptt_fixer_upper(request_rec *r) -{ - - excfg *cfg; - - cfg = our_dconfig(r); - /* - * Log the call and exit. - */ - trace_add(r->server, r, cfg, "ptt_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 ptt_logger(request_rec *r) -{ - - excfg *cfg; - - cfg = our_dconfig(r); - trace_add(r->server, r, cfg, "ptt_logger()"); - return DECLINED; -} - -/* - * This routine is called to give the module a chance to look at the request - * headers and take any appropriate specific actions early in the processing - * sequence. - * - * The return value is OK, DECLINED, or HTTP_mumble. If we return OK, any - * remaining modules with handlers for this phase will still be called. - */ -static int ptt_header_parser(request_rec *r) -{ - - excfg *cfg; - - cfg = our_dconfig(r); - trace_add(r->server, r, cfg, "ptt_header_parser()"); - return DECLINED; } -/*--------------------------------------------------------------------------*/ -/* */ -/* 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 ptt_cmds[] = -{ - { - "ptt", /* directive name */ - cmd_ptt, /* config action routine */ - NULL, /* argument to include in call */ - OR_OPTIONS, /* where available */ - NO_ARGS, /* arguments */ - "Example directive - no arguments" - /* directive description */ - }, - {NULL} -}; - -/*--------------------------------------------------------------------------*/ -/* */ -/* Now the list of content handlers available from this module. */ -/* */ -/*--------------------------------------------------------------------------*/ -/* - * List of content handlers our module supplies. Each handler is defined by - * two parts: a name by which it can be referenced (such as by - * {Add,Set}Handler), and the actual routine name. The list is terminated by - * a NULL block, since it can be of variable length. - * - * Note that content-handlers are invoked on a most-specific to least-specific - * basis; that is, a handler that is declared for "text/plain" will be - * invoked before one that was declared for "text / *". Note also that - * if a content-handler returns anything except DECLINED, no other - * content-handlers will be called. - */ static const handler_rec ptt_handlers[] = { - {"ptt-handler", ptt_handler}, + {"ptt_h", ptt_handler}, {NULL} }; -/*--------------------------------------------------------------------------*/ -/* */ -/* Finally, the list of callback routines and data structures that */ -/* provide the 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. - * - * 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). - */ module MODULE_VAR_EXPORT ptt_module = { STANDARD_MODULE_STUFF, - ptt_init, /* module initializer */ - ptt_create_dir_config, /* per-directory config creator */ - ptt_merge_dir_config, /* dir config merger */ - ptt_create_server_config, /* server config creator */ - ptt_merge_server_config, /* server config merger */ - ptt_cmds, /* command table */ + NULL, /* module initializer */ + NULL, /* per-directory config creator */ + NULL, /* dir config merger */ + NULL, /* server config creator */ + NULL, /* server config merger */ + NULL, /* command table */ ptt_handlers, /* [9] list of handlers */ - ptt_translate_handler, /* [2] filename-to-URI translation */ - ptt_check_user_id, /* [5] check/validate user_id */ - ptt_auth_checker, /* [6] check user_id is valid *here* */ - ptt_access_checker, /* [4] check access by host address */ - ptt_type_checker, /* [7] MIME type checker/setter */ - ptt_fixer_upper, /* [8] fixups */ - ptt_logger, /* [10] logger */ + NULL, /* [2] filename-to-URI translation */ + NULL, /* [5] check/validate user_id */ + NULL, /* [6] check user_id is valid *here* */ + NULL, /* [4] check access by host address */ + NULL, /* [7] MIME type checker/setter */ + NULL, /* [8] fixups */ + NULL, /* [10] logger */ #if MODULE_MAGIC_NUMBER >= 19970103 - ptt_header_parser, /* [3] header parser */ + NULL, /* [3] header parser */ #endif #if MODULE_MAGIC_NUMBER >= 19970719 ptt_child_init, /* process initializer */ @@ -1059,6 +216,6 @@ module MODULE_VAR_EXPORT ptt_module = ptt_child_exit, /* process exit/cleanup */ #endif #if MODULE_MAGIC_NUMBER >= 19970902 - ptt_post_read_request /* [1] post read_request handling */ + NULL #endif }; diff --git a/web/util_cache.c b/web/util_cache.c index 5178dad5..7bfb67cc 100755 --- a/web/util_cache.c +++ b/web/util_cache.c @@ -1,4 +1,4 @@ -/* $Id: util_cache.c,v 1.1 2002/10/18 14:43:58 ptt Exp $ */ +/* $Id: util_cache.c,v 1.2 2003/03/24 20:44:09 ptt Exp $ */ #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -316,6 +316,10 @@ static void reload_bcache() { if(SHM->Bbusystate) { safe_sleep(1); } + else{ + puts("bcache is not loaded? resolve_boards() fail"); + exit(1); + } } void resolve_boards() { diff --git a/web/util_passwd.c b/web/util_passwd.c index 03e90f6c..6fa94302 100755 --- a/web/util_passwd.c +++ b/web/util_passwd.c @@ -1,4 +1,4 @@ -/* $Id: util_passwd.c,v 1.1 2002/10/18 14:43:58 ptt Exp $ */ +/* $Id: util_passwd.c,v 1.2 2003/03/24 20:44:09 ptt Exp $ */ #include <stdio.h> #include <string.h> #include <fcntl.h> @@ -36,7 +36,7 @@ static userec_t *passwd_image = NULL; static int passwd_image_size; static int semid = -1; -int passwd_mmap() { +int passwd_mmap(void) { int fd; if(passwd_image!=NULL) return 0; diff --git a/web/util_record.c b/web/util_record.c index bc74d575..93d060e0 100755 --- a/web/util_record.c +++ b/web/util_record.c @@ -1,5 +1,6 @@ -/* $Id: util_record.c,v 1.1 2002/10/18 14:43:58 ptt Exp $ */ +/* $Id: util_record.c,v 1.2 2003/03/24 20:44:09 ptt Exp $ */ #include <stdio.h> +#include <stdlib.h> #include <errno.h> #include <string.h> #include <unistd.h> |