Annotation of libwww/Library/src/HTFilter.c, revision 2.31
2.1 frystyk 1: /*
2: ** BEFORE AND AFTER FILTERS
3: **
4: ** (c) COPYRIGHT MIT 1995.
5: ** Please first read the full copyright statement in the file COPYRIGH.
2.31 ! kahan 6: ** @(#) $Id: HTFilter.c,v 2.30 1998/09/10 03:30:44 frystyk Exp $
2.1 frystyk 7: **
8: ** This module implrments a set of default filters that can be registerd
9: ** as BEFORE and AFTER filters to the Net manager
10: ** Authors
11: ** HFN Henrik Frystyk, frystyk@w.org
12: ** History
13: ** Jul 4, 96 Written
14: */
15:
16: /* Library include files */
17: #include "WWWLib.h"
18: #include "WWWCache.h"
19: #include "WWWHTTP.h"
20: #include "HTLog.h"
21: #include "HTAccess.h"
2.10 frystyk 22: #include "HTProxy.h"
23: #include "HTRules.h"
2.1 frystyk 24: #include "HTFilter.h" /* Implemented here */
25:
26: /* ------------------------------------------------------------------------- */
27:
28: /*
29: ** Proxy and Gateway BEFORE filter
30: ** -------------------------------
31: ** Checks for registerd proxy servers or gateways and sees whether this
32: ** request should be redirected to a proxy or a gateway. Proxies have
33: ** higher priority than gateways so we look for them first!
34: ** For HTTP/1.0 and HTTP/1.1 we may only send a full URL (including the
35: ** host portion) to proxy servers. Therefore, we tell the Library whether
36: ** to use the full URL or the traditional HTTP one without the host part.
37: */
2.15 frystyk 38: PUBLIC int HTProxyFilter (HTRequest * request, void * param, int mode)
2.1 frystyk 39: {
40: HTParentAnchor * anchor = HTRequest_anchor(request);
2.2 frystyk 41: char * addr = HTAnchor_physical(anchor);
2.1 frystyk 42: char * physical = NULL;
43: if ((physical = HTProxy_find(addr))) {
2.6 frystyk 44: HTRequest_setFullURI(request, YES); /* For now */
2.5 frystyk 45: HTRequest_setProxy(request, physical);
2.8 frystyk 46: HT_FREE(physical);
2.6 frystyk 47: #if 0
48: /* Don't paste the URLs together anymore */
2.1 frystyk 49: StrAllocCat(physical, addr);
2.5 frystyk 50: HTAnchor_setPhysical(anchor, physical);
2.6 frystyk 51: #endif
2.1 frystyk 52: } else if ((physical = HTGateway_find(addr))) {
53: /*
54: ** A gateway URL is crated by chopping off any leading "/" to make the
55: ** host into part of path
56: */
57: char * path =
58: HTParse(addr, "", PARSE_HOST + PARSE_PATH + PARSE_PUNCTUATION);
2.26 frystyk 59: char * gatewayed = HTParse((*path=='/') ? path+1 : path, physical, PARSE_ALL);
2.1 frystyk 60: HTAnchor_setPhysical(anchor, gatewayed);
61: HT_FREE(path);
62: HT_FREE(gatewayed);
63: HTRequest_setFullURI(request, NO);
2.6 frystyk 64: HTRequest_deleteProxy(request);
2.1 frystyk 65: } else {
2.6 frystyk 66: HTRequest_setFullURI(request, NO); /* For now */
67: HTRequest_deleteProxy(request);
2.1 frystyk 68: }
69: return HT_OK;
70: }
71:
72: /*
73: ** Rule Translation BEFORE Filter
74: ** ------------------------------
75: ** If we have a set of rules loaded (see the Rule manager) then check
76: ** before each request whether how that should be translated. The trick
77: ** is that a parent anchor has a "address" which is the part from the URL
78: ** we used when we created the anchor. However, it also have a "physical
79: ** address" which is the place we are actually going to look for the
2.2 frystyk 80: ** resource. Hence this filter translates the physical address
81: ** (if any translations are found)
2.1 frystyk 82: */
2.15 frystyk 83: PUBLIC int HTRuleFilter (HTRequest * request, void * param, int mode)
2.1 frystyk 84: {
85: HTList * list = HTRule_global();
86: HTParentAnchor * anchor = HTRequest_anchor(request);
2.2 frystyk 87: char * addr = HTAnchor_physical(anchor);
2.1 frystyk 88: char * physical = HTRule_translate(list, addr, NO);
89: if (!physical) {
90: HTRequest_addError(request, ERR_FATAL, NO, HTERR_FORBIDDEN,
91: NULL, 0, "HTRuleFilter");
92: return HT_ERROR;
93: }
94: HTAnchor_setPhysical(anchor, physical);
95: HT_FREE(physical);
96: return HT_OK;
97: }
98:
99: /*
100: ** Cache Validation BEFORE Filter
101: ** ------------------------------
102: ** Check the cache mode to see if we can use an already loaded version
103: ** of this document. If so and our copy is valid then we don't have
104: ** to go out and get it unless we are forced to
2.3 frystyk 105: ** We only check the cache in caseof a GET request. Otherwise, we go
106: ** directly to the source.
2.1 frystyk 107: */
2.15 frystyk 108: PUBLIC int HTCacheFilter (HTRequest * request, void * param, int mode)
2.1 frystyk 109: {
110: HTParentAnchor * anchor = HTRequest_anchor(request);
2.12 frystyk 111: HTCache * cache = NULL;
2.15 frystyk 112: HTReload reload = HTRequest_reloadMode(request);
2.3 frystyk 113: HTMethod method = HTRequest_method(request);
2.12 frystyk 114: HTDisconnectedMode disconnect = HTCacheMode_disconnected();
115: BOOL validate = NO;
2.3 frystyk 116:
117: /*
2.12 frystyk 118: ** If the cache is disabled all together then it won't help looking, huh?
2.3 frystyk 119: */
2.12 frystyk 120: if (!HTCacheMode_enabled()) return HT_OK;
121: if (CACHE_TRACE) HTTrace("Cachefilter. Checking persistent cache\n");
2.3 frystyk 122:
2.1 frystyk 123: /*
2.12 frystyk 124: ** Now check the cache...
2.1 frystyk 125: */
2.12 frystyk 126: if (method != METHOD_GET) {
127: if (CACHE_TRACE) HTTrace("Cachefilter. We only check GET methods\n");
2.15 frystyk 128: } else if (reload == HT_CACHE_FLUSH) {
2.12 frystyk 129: /*
130: ** If the mode if "Force Reload" then don't even bother to check the
131: ** cache - we flush everything we know abut this document anyway.
2.1 frystyk 132: ** Add the appropriate request headers. We use both the "pragma"
133: ** and the "cache-control" headers in order to be
2.12 frystyk 134: ** backwards compatible with HTTP/1.0
2.1 frystyk 135: */
2.12 frystyk 136: validate = YES;
2.1 frystyk 137: HTRequest_addGnHd(request, HT_G_PRAGMA_NO_CACHE);
2.11 frystyk 138: HTRequest_addCacheControl(request, "no-cache", "");
2.1 frystyk 139:
140: /*
2.15 frystyk 141: ** We also flush the information in the anchor as we don't want to
142: ** inherit any "old" values
2.1 frystyk 143: */
144: HTAnchor_clearHeader(anchor);
145:
2.12 frystyk 146: } else {
147: /*
148: ** Check the persistent cache manager. If we have a cache hit then
149: ** continue to see if the reload mode requires us to do a validation
150: ** check. This filter assumes that we can get the cached version
151: ** through one of our protocol modules (for example the file module)
152: */
153: cache = HTCache_find(anchor);
2.1 frystyk 154: if (cache) {
2.20 frystyk 155: HTReload cache_mode = HTCache_isFresh(cache, request);
156: if (cache_mode == HT_CACHE_ERROR) cache = NULL;
157: reload = HTMAX(reload, cache_mode);
2.15 frystyk 158: HTRequest_setReloadMode(request, reload);
2.12 frystyk 159:
160: /*
161: ** Now check the mode and add the right headers for the validation
162: ** If we are to validate a cache entry then we get a lock
163: ** on it so that not other requests can steal it.
164: */
2.15 frystyk 165: if (reload == HT_CACHE_RANGE_VALIDATE) {
166: /*
167: ** If we were asked to range validate the cached object then
168: ** use the etag or the last modified for cache validation
169: */
170: validate = YES;
171: HTCache_getLock(cache, request);
172: HTRequest_addRqHd(request, HT_C_IF_RANGE);
173: } else if (reload == HT_CACHE_END_VALIDATE) {
2.12 frystyk 174: /*
175: ** If we were asked to end-to-end validate the cached object
176: ** then use a max-age=0 cache control directive
177: */
178: validate = YES;
179: HTCache_getLock(cache, request);
180: HTRequest_addCacheControl(request, "max-age", "0");
2.15 frystyk 181: } else if (reload == HT_CACHE_VALIDATE) {
2.11 frystyk 182: /*
2.12 frystyk 183: ** If we were asked to validate the cached object then
2.11 frystyk 184: ** use the etag or the last modified for cache validation
2.15 frystyk 185: ** We use both If-None-Match or If-Modified-Since.
2.11 frystyk 186: */
2.12 frystyk 187: validate = YES;
188: HTCache_getLock(cache, request);
2.11 frystyk 189: HTRequest_addRqHd(request, HT_C_IF_NONE_MATCH | HT_C_IMS);
2.20 frystyk 190: } else if (cache) {
2.12 frystyk 191: /*
192: ** The entity does not require any validation at all. We
2.15 frystyk 193: ** can just go ahead and get it from the cache. In case we
194: ** have a fresh subpart of the entity, then we issue a
195: ** conditional GET request with the range set by the cache
196: ** manager. Issuing the conditional range request is
197: ** equivalent to a validation as we have to go out on the
198: ** net. This may have an effect if running in disconnected
199: ** mode. We disable all BEFORE filters as they don't make
200: ** sense while loading the cache entry.
2.12 frystyk 201: */
2.15 frystyk 202: {
203: char * name = HTCache_name(cache);
204: HTAnchor_setPhysical(anchor, name);
205: HTCache_addHit(cache);
206: HT_FREE(name);
207: }
2.11 frystyk 208: }
209: }
2.12 frystyk 210: }
211:
212: /*
213: ** If we are in disconnected mode and we are to validate an entry
214: ** then check whether what mode of disconnected mode we're in. If
215: ** we are to use our own cache then return a "504 Gateway Timeout"
216: */
217: if ((!cache || validate) && disconnect != HT_DISCONNECT_NONE) {
218: if (disconnect == HT_DISCONNECT_EXTERNAL)
219: HTRequest_addCacheControl(request, "only-if-cached", "");
220: else {
221: HTRequest_addError(request, ERR_FATAL, NO,
222: HTERR_GATE_TIMEOUT, "Disconnected Cache Mode",
223: 0, "HTCacheFilter");
224: return HT_ERROR;
225: }
2.11 frystyk 226: }
227: return HT_OK;
228: }
229:
230: /*
2.16 frystyk 231: ** A small BEFORE filter that just finds a cache entry unconditionally
232: ** and loads the entry. All freshness and any other constraints are
233: ** ignored.
234: */
235: PUBLIC int HTCacheLoadFilter (HTRequest * request, void * param, int mode)
236: {
237: HTParentAnchor * anchor = HTRequest_anchor(request);
238: HTCache * cache = HTCache_find(anchor);
239: if (cache) {
240: char * name = HTCache_name(cache);
241: HTAnchor_setPhysical(anchor, name);
242: HTCache_addHit(cache);
243: HT_FREE(name);
244:
245: /*
246: ** Start request directly from the cache. As with the redirection
247: ** filter we reuse the same request object which means that we must
248: ** keep this around until the cache load request has terminated
249: */
250: {
251: HTLoad(request, NO);
252: return HT_ERROR;
253: }
254: }
255: return HT_OK;
256: }
257:
258: /*
2.15 frystyk 259: ** Check the Memory Cache (History list) BEFORE filter
260: ** ---------------------------------------------------
2.11 frystyk 261: ** Check if document is already loaded. The user can define whether
262: ** the history list should follow normal expiration or work as a
263: ** traditional history list where expired documents are not updated.
264: ** We don't check for anything but existence proof of a document
265: ** associated with the anchor as the definition is left to the application
266: */
2.15 frystyk 267: PUBLIC int HTMemoryCacheFilter (HTRequest * request, void * param, int mode)
2.11 frystyk 268: {
269: HTReload validation = HTRequest_reloadMode(request);
270: HTParentAnchor * anchor = HTRequest_anchor(request);
271: void * document = HTAnchor_document(anchor);
2.1 frystyk 272:
2.11 frystyk 273: /*
2.14 frystyk 274: ** We only check the memory cache if it's a GET method
275: */
276: if (HTRequest_method(request) != METHOD_GET) {
277: if (CACHE_TRACE) HTTrace("Mem Cache... We only check GET methods\n");
278: return HT_OK;
279: }
280:
281: /*
2.11 frystyk 282: ** If we are asked to flush the persistent cache then there is no reason
283: ** to do anything here - we're flushing it anyway. Also if no document
284: ** then just exit from this filter.
285: */
286: if (!document || validation > HT_CACHE_FLUSH_MEM) {
287: if (CACHE_TRACE) HTTrace("Mem Cache... No fresh document...\n");
288: return HT_OK;
289: }
2.1 frystyk 290:
2.11 frystyk 291: /*
292: ** If we have a document object associated with this anchor then we also
293: ** have the object in the history list. Depending on what the user asked,
294: ** we can add a cache validator
295: */
2.14 frystyk 296: if (document && validation != HT_CACHE_FLUSH_MEM) {
297: if (CACHE_TRACE) HTTrace("Mem Cache... Document already in memory\n");
298: return HT_LOADED;
2.1 frystyk 299: }
300: return HT_OK;
301: }
302:
303: /*
2.15 frystyk 304: ** Cache Update AFTER filter
305: ** -------------------------
306: ** On our way out we catch the metainformation and stores it in
307: ** our persistent store. If we have a cache validation (a 304
308: ** response then we use the new metainformation and merges it with
309: ** the existing information already captured in the cache.
310: */
311: PUBLIC int HTCacheUpdateFilter (HTRequest * request, HTResponse * response,
312: void * param, int status)
313: {
314: HTParentAnchor * anchor = HTRequest_anchor(request);
315: HTCache * cache = HTCache_find(anchor);
2.17 frystyk 316: if (cache) {
2.15 frystyk 317:
2.17 frystyk 318: /*
319: ** It may in fact be that the information in the 304 response
320: ** told us that we can't cache the entity anymore. If this is the
321: ** case then flush it now. Otherwise prepare for a cache read
322: */
323: if (CACHE_TRACE) HTTrace("Cache....... Merging metainformation\n");
2.29 frystyk 324: if (HTResponse_isCachable(response) == HT_NO_CACHE) {
2.17 frystyk 325: HTCache_remove(cache);
326: } else {
327: char * name = HTCache_name(cache);
328: HTAnchor_setPhysical(anchor, name);
329: HTCache_addHit(cache);
330: HT_FREE(name);
331: HTCache_updateMeta(cache, request, response);
332: }
2.15 frystyk 333:
2.17 frystyk 334: /*
335: ** Start request directly from the cache. As with the redirection filter
336: ** we reuse the same request object which means that we must
337: ** keep this around until the cache load request has terminated
338: ** In the case of a
339: */
340: HTLoad(request, YES);
2.15 frystyk 341: return HT_ERROR;
2.30 frystyk 342: } else {
343:
344: /* If entry doesn't already exist then create a new entry */
345: HTCache_touch(request, response, anchor);
346:
2.15 frystyk 347: }
2.17 frystyk 348: return HT_OK;
2.15 frystyk 349: }
350:
351: /*
2.1 frystyk 352: ** Error and Information AFTER filter
353: ** ----------------------------------
354: ** It checks the status code from a request and generates an
355: ** error/information message if required.
356: */
2.15 frystyk 357: PUBLIC int HTInfoFilter (HTRequest * request, HTResponse * response,
358: void * param, int status)
2.1 frystyk 359: {
360: HTParentAnchor * anchor = HTRequest_anchor(request);
361: char * uri = HTAnchor_address((HTAnchor*) anchor);
362: switch (status) {
2.28 frystyk 363: case HT_RETRY: {
364: HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
365: if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
366: HTRequest_error(request), NULL);
2.1 frystyk 367: if (PROT_TRACE)
368: HTTrace("Load End.... NOT AVAILABLE, RETRY AT %ld\n",
2.15 frystyk 369: HTResponse_retryTime(response));
2.28 frystyk 370: }
371: break;
2.1 frystyk 372:
2.7 frystyk 373: case HT_NO_DATA:
374: {
375: /*
376: ** The document was empty
377: */
378: HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
379: if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
380: HTRequest_error(request), NULL);
381: if (PROT_TRACE)
382: HTTrace("Load End.... EMPTY: No content `%s\'\n",
383: uri ? uri : "<UNKNOWN>");
384: break;
385: }
2.3 frystyk 386:
387: case HT_LOADED:
2.16 frystyk 388: if (PROT_TRACE) HTTrace("Load End.... OK: `%s\'\n", uri);
389: break;
390:
391: default:
2.3 frystyk 392: {
393: /*
2.16 frystyk 394: ** See if we have a function registered for outputting errors.
395: ** If so then call it and present the message to the user
2.3 frystyk 396: */
397: HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
398: if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
399: HTRequest_error(request), NULL);
2.1 frystyk 400: if (PROT_TRACE)
401: HTTrace("Load End.... Request ended with code %d\n", status);
402: break;
403: }
2.16 frystyk 404: }
2.1 frystyk 405: HT_FREE(uri);
406: return HT_OK;
407: }
408:
409: /*
410: ** Redirection AFTER filter
411: ** ------------------------
412: ** The redirection handler only handles redirections
413: ** on the GET or HEAD method (or any other safe method)
414: */
2.15 frystyk 415: PUBLIC int HTRedirectFilter (HTRequest * request, HTResponse * response,
416: void * param, int status)
2.1 frystyk 417: {
418: HTMethod method = HTRequest_method(request);
2.15 frystyk 419: HTAnchor * new_anchor = HTResponse_redirection(response);
2.7 frystyk 420: if (!new_anchor) {
421: if (PROT_TRACE) HTTrace("Redirection. No destination\n");
422: return HT_OK;
423: }
424:
2.1 frystyk 425: /*
2.21 frystyk 426: ** Only do automatic redirect on GET and HEAD. Ask for all
2.27 frystyk 427: ** other methods.
2.1 frystyk 428: */
2.21 frystyk 429: if (!HTMethod_isSafe(method)) {
430:
431: /*
432: ** If we got a 303 See Other then change the method to GET.
433: ** Otherwise ask the user whether we should continue.
434: */
435: if (status == HT_SEE_OTHER) {
436: if (PROT_TRACE)
437: HTTrace("Redirection. Changing method from %s to GET\n",
438: HTMethod_name(method));
439: HTRequest_setMethod(request, METHOD_GET);
440: } else {
441: HTAlertCallback * prompt = HTAlert_find(HT_A_CONFIRM);
442: if (prompt) {
443: if ((*prompt)(request, HT_A_CONFIRM, HT_MSG_REDIRECTION,
444: NULL, NULL, NULL) != YES)
2.27 frystyk 445: return HT_OK;
2.21 frystyk 446: }
2.4 frystyk 447: }
2.1 frystyk 448: }
449:
450: /*
451: ** Start new request with the redirect anchor found in the headers.
452: ** Note that we reuse the same request object which means that we must
453: ** keep this around until the redirected request has terminated. It also
454: ** allows us in an easy way to keep track of the number of redirections
455: ** so that we can detect endless loops.
456: */
2.4 frystyk 457: if (HTRequest_doRetry(request)) {
2.1 frystyk 458: HTLoadAnchor(new_anchor, request);
2.9 frystyk 459: } else {
460: HTRequest_addError(request, ERR_FATAL, NO, HTERR_MAX_REDIRECT,
461: NULL, 0, "HTRedirectFilter");
462: }
463:
464: /*
465: ** By returning HT_ERROR we make sure that this is the last handler to be
466: ** called. We do this as we don't want any other filter to delete the
467: ** request object now when we have just started a new one ourselves
468: */
469: return HT_ERROR;
470: }
471:
472: /*
2.15 frystyk 473: ** Retry through Proxy AFTER Filter
474: ** --------------------------------
2.9 frystyk 475: ** This filter handles a 305 Use Proxy response and retries the request
476: ** through the proxy
477: */
2.15 frystyk 478: PUBLIC int HTUseProxyFilter (HTRequest * request, HTResponse * response,
479: void * param, int status)
2.9 frystyk 480: {
2.20 frystyk 481: HTAlertCallback * cbf = HTAlert_find(HT_A_CONFIRM);
2.15 frystyk 482: HTAnchor * proxy_anchor = HTResponse_redirection(response);
2.9 frystyk 483: if (!proxy_anchor) {
484: if (PROT_TRACE) HTTrace("Use Proxy... No proxy location\n");
485: return HT_OK;
486: }
487:
488: /*
489: ** Add the proxy to the list. Assume HTTP access method only!
2.20 frystyk 490: ** Because evil servers may rediret the client to an untrusted
491: ** proxy, we can only accept redirects for this particular
492: ** server. Also, we do not know whether this is for HTTP or all
493: ** other requests as well
2.9 frystyk 494: */
2.20 frystyk 495: if ((cbf && (*cbf)(request, HT_A_CONFIRM, HT_MSG_PROXY, NULL,NULL,NULL))) {
2.9 frystyk 496: char * addr = HTAnchor_address(proxy_anchor);
497: HTProxy_add("http", addr);
498: HT_FREE(addr);
499:
2.20 frystyk 500: /*
501: ** Start new request through the proxy if we haven't reached the max
502: ** number of redirections for this request
503: */
504: if (HTRequest_doRetry(request)) {
505: HTLoadAnchor(proxy_anchor, request);
506: } else {
507: HTRequest_addError(request, ERR_FATAL, NO, HTERR_MAX_REDIRECT,
508: NULL, 0, "HTRedirectFilter");
509: }
510:
511: /*
512: ** By returning HT_ERROR we make sure that this is the last handler to be
513: ** called. We do this as we don't want any other filter to delete the
514: ** request object now when we have just started a new one ourselves
515: */
516: return HT_ERROR;
517:
2.1 frystyk 518: } else {
2.20 frystyk 519: HTRequest_addError(request, ERR_FATAL, NO, HTERR_NO_AUTO_PROXY,
520: NULL, 0, "HTUseProxyFilter");
521: return HT_OK;
2.1 frystyk 522: }
523: }
524:
525: /*
526: ** Client side authentication BEFORE filter
527: ** ----------------------------------------
528: ** The filter generates the credentials required to access a document
529: ** Getting the credentials may involve asking the user
530: */
2.15 frystyk 531: PUBLIC int HTCredentialsFilter (HTRequest * request, void * param, int mode)
2.1 frystyk 532: {
533: /*
534: ** Ask the authentication module to call the right credentials generator
535: ** that understands this scheme
536: */
2.15 frystyk 537: if (HTAA_beforeFilter(request, param, mode) == HT_OK) {
2.1 frystyk 538: if (PROT_TRACE) HTTrace("Credentials. verified\n");
539: return HT_OK;
540: } else {
541: HTRequest_addError(request, ERR_FATAL, NO, HTERR_UNAUTHORIZED,
542: NULL, 0, "HTCredentialsFilter");
543: return HT_ERROR;
544: }
545: }
546:
547: /*
548: ** Client side authentication AFTER filter
549: ** ---------------------------------------
550: ** The client side authentication filter uses the
551: ** user dialog messages registered in the HTAlert module.
552: ** By default these are the ones used by the line mode browser but you can
553: ** just register something else.
554: */
2.15 frystyk 555: PUBLIC int HTAuthFilter (HTRequest * request, HTResponse * response,
556: void * param, int status)
2.1 frystyk 557: {
558: /*
559: ** Ask the authentication module to call the right challenge parser
560: ** that understands this scheme
561: */
2.15 frystyk 562: if (HTAA_afterFilter(request, response, param, status) == HT_OK) {
2.1 frystyk 563:
564: /*
565: ** Start request with new credentials. As with the redirection filter
566: ** we reuse the same request object which means that we must
567: ** keep this around until the redirected request has terminated
568: */
569: HTLoad(request, NO);
570:
571: /*
572: ** We return HT_ERROR to make sure that this is the last handler to be
573: ** called. We do this as we don't want any other filter to delete the
574: ** request object now when we have just started a new one ourselves
575: */
576: return HT_ERROR;
577: }
578: return HT_OK;
579: }
580:
581: /*
2.24 frystyk 582: ** Request Logging AFTER filter
583: ** ----------------------------
2.1 frystyk 584: ** Default Logging filter using the log manager provided by HTLog.c
585: */
2.15 frystyk 586: PUBLIC int HTLogFilter (HTRequest * request, HTResponse * response,
587: void * param, int status)
2.1 frystyk 588: {
589: if (request) {
2.23 frystyk 590: HTLog * log = (HTLog *) param;
591: if (log) HTLog_addCLF(log, request, status);
2.24 frystyk 592: return HT_OK;
593: }
594: return HT_ERROR;
595: }
596:
597: /*
598: ** Request Referer AFTER filter
599: ** ----------------------------
600: ** Default Referer Log filter using the log manager provided by HTLog.c
601: */
602: PUBLIC int HTRefererFilter (HTRequest * request, HTResponse * response,
603: void * param, int status)
604: {
605: if (request) {
606: HTLog * log = (HTLog *) param;
607: if (log) HTLog_addReferer(log, request, status);
2.1 frystyk 608: return HT_OK;
609: }
610: return HT_ERROR;
611: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTFilter.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src