Annotation of libwww/Library/src/HTRules.c, revision 2.50
2.26 frystyk 1: /* HTRules.c
2: ** CONFIGURATION MANAGER FOR CLIENTS
3: **
2.32 frystyk 4: ** (c) COPYRIGHT MIT 1995.
2.26 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
2.50 ! frystyk 6: ** @(#) $Id: Date Author State $
2.1 timbl 7: **
2.40 frystyk 8: ** This module manages rule files in the Library
2.1 timbl 9: **
10: ** History:
11: ** 3 Jun 91 Written TBL
12: ** 10 Aug 91 Authorisation added after Daniel Martin (pass, fail)
13: ** Rule order in file changed
14: ** Comments allowed with # on 1st char of rule line
15: ** 17 Jun 92 Bug fix: pass and fail failed if didn't contain '*' TBL
2.9 secret 16: ** 1 Sep 93 Bug fix: no memory check - Nathan Torkington
17: ** BYTE_ADDRESSING removed - Arthur Secret
2.12 luotonen 18: ** 11 Sep 93 MD Changed %i into %d in debug printf.
2.10 duns 19: ** VMS does not recognize %i.
20: ** Bug Fix: in case of PASS, only one parameter to printf.
2.12 luotonen 21: ** 19 Sep 93 AL Added Access Authorization stuff.
22: ** 1 Nov 93 AL Added htbin.
2.15 luotonen 23: ** 30 Nov 93 AL Added HTTranslateReq().
2.19 luotonen 24: ** 4 Feb 94 AL Took away all the daemon-specific stuff.
2.36 frystyk 25: ** 28 Sep 94 HWL Added field to HTPresentation_add call
2.40 frystyk 26: ** 15 Nov 95 HFN Made a stream, fixed interface and made new translater
2.11 luotonen 27: **
2.40 frystyk 28: ** BUGS: We only have one wildcard match pr rule!
2.1 timbl 29: */
30:
2.28 frystyk 31: /* Library include files */
2.34 frystyk 32: #include "WWWLib.h"
2.40 frystyk 33: #include "HTProxy.h"
2.26 frystyk 34: #include "HTRules.h" /* Implemented here */
2.1 timbl 35:
2.40 frystyk 36: struct _HTStream {
2.48 frystyk 37: const HTStreamClass * isa;
2.40 frystyk 38: HTRequest * request;
39: HTStream * target;
40: HTChunk * buffer;
2.49 frystyk 41: HTEOLState EOLstate;
2.40 frystyk 42: };
43:
44: struct _HTRule {
45: HTRuleOp op;
46: char * pattern;
47: char * replace;
48: int insert; /* Index into any wildcard in replace */
49: };
50:
51: PRIVATE HTList * rules = NULL;
52:
53: /* ------------------------------------------------------------------------- */
54:
55: /*
56: ** Rules are handled as list as everything else that has to do with
57: ** preferences. We provide two functions for getting and setting the
58: ** global rules
2.1 timbl 59: */
2.40 frystyk 60: PUBLIC HTList * HTRule_global (void)
61: {
62: if (!rules) rules = HTList_new();
63: return rules;
64: }
2.1 timbl 65:
2.40 frystyk 66: PUBLIC BOOL HTRule_setGlobal(HTList * list)
67: {
68: if (rules) HTRule_deleteAll(rules);
69: rules = list;
70: return YES;
71: }
2.1 timbl 72:
2.40 frystyk 73: /* Add rule to the list
2.1 timbl 74: ** --------------------
2.40 frystyk 75: ** This function adds a rule to the list of rules. The
76: ** pattern is a 0-terminated string containing a single
77: ** "*". <CODE>equiv</CODE> points to the equivalent string with * for the
78: ** place where the text matched by * goes.
2.1 timbl 79: ** On entry,
80: ** pattern points to 0-terminated string containing a single "*"
2.40 frystyk 81: ** replace points to the equivalent string with * for the
2.1 timbl 82: ** place where the text matched by * goes.
83: ** On exit,
2.40 frystyk 84: ** returns YES if OK, else NO
2.1 timbl 85: */
2.40 frystyk 86: PUBLIC BOOL HTRule_add (HTList * list, HTRuleOp op,
2.48 frystyk 87: const char * pattern, const char * replace)
2.39 frystyk 88: {
2.40 frystyk 89: if (list && pattern) {
2.45 frystyk 90: HTRule * me;
91: if ((me = (HTRule *) HT_CALLOC(1, sizeof(HTRule))) == NULL)
92: HT_OUTOFMEM("HTRule_add");
2.40 frystyk 93: me->op = op;
94: StrAllocCopy(me->pattern, pattern);
95: if (replace) {
96: char *ptr = strchr(replace, '*');
97: StrAllocCopy(me->replace, replace);
98: me->insert = ptr ? ptr-replace : -1;
99: if (APP_TRACE)
2.47 eric 100: HTTrace("Rule Add.... For `%s\' op %d `%s\'\n",
2.40 frystyk 101: pattern, op, replace);
102: } else
2.47 eric 103: HTTrace("Rule Add.... For `%s\' op %d\n", pattern, op);
2.40 frystyk 104: return HTList_appendObject(rules, (void *) me);
2.10 duns 105: }
2.40 frystyk 106: return NO;
2.1 timbl 107: }
108:
2.40 frystyk 109: /* Delete all rules
110: ** ----------------
111: ** Deletes all the rules registered by this module
2.1 timbl 112: */
2.40 frystyk 113: PUBLIC BOOL HTRule_deleteAll (HTList * list)
2.1 timbl 114: {
2.40 frystyk 115: if (list) {
116: HTList *cur = list;
117: HTRule *pres;
118: while ((pres = (HTRule *) HTList_nextObject(cur))) {
2.45 frystyk 119: HT_FREE(pres->pattern);
120: HT_FREE(pres->replace);
121: HT_FREE(pres);
2.40 frystyk 122: }
123: return HTList_delete(list);
2.1 timbl 124: }
2.40 frystyk 125: return NO;
2.1 timbl 126: }
127:
2.40 frystyk 128: /* Translate by rules
2.1 timbl 129: ** ------------------
2.15 luotonen 130: ** The most recently defined rules are applied last.
2.40 frystyk 131: ** This function walks through the list of rules and translates the
132: ** reference when matches are found. The list is traversed in order
133: ** starting from the head of the list. It returns the address of the
134: ** equivalent string allocated from the heap which the CALLER MUST
135: ** FREE.
2.1 timbl 136: */
2.48 frystyk 137: PUBLIC char * HTRule_translate (HTList * list, const char * token,
2.40 frystyk 138: BOOL ignore_case)
2.1 timbl 139: {
2.40 frystyk 140: HTRule * pres;
141: char * replace = NULL;
142: if (!token || !list) return NULL;
2.47 eric 143: if (APP_TRACE) HTTrace("Check rules. for `%s\'\n", token);
2.40 frystyk 144: while ((pres = (HTRule *) HTList_nextObject(list))) {
145: char * rest = ignore_case ? HTStrCaseMatch(pres->pattern, token) :
146: HTStrMatch(pres->pattern, token);
147: if (!rest) continue; /* No match at all */
148:
149: /* We found a match for this entry, now do operation */
150: switch (pres->op) {
151:
152: case HT_Pass:
153: case HT_Map:
154: if (!pres->replace) { /* No replace */
155: StrAllocCopy(replace, token);
156:
157: } else if (*rest && pres->insert >= 0) {
2.45 frystyk 158: if ((replace = (char *) HT_MALLOC(strlen(pres->replace)+strlen(rest))) == NULL)
159: HT_OUTOFMEM("HTRule_translate");
2.40 frystyk 160: strcpy(replace, pres->replace);
161: strcpy(replace+pres->insert, rest);
162:
163: } else { /* Perfect match or no insetion point */
164: StrAllocCopy(replace, pres->replace);
165: }
166:
167: if (pres->op == HT_Pass) {
168: if (APP_TRACE)
2.47 eric 169: HTTrace("............ map into `%s'\n", replace);
2.40 frystyk 170: return replace;
171: }
172: break;
173:
174: case HT_Fail:
175:
176: default:
2.47 eric 177: if (APP_TRACE) HTTrace("............ FAIL `%s'\n", token);
2.40 frystyk 178: return NULL;
2.1 timbl 179: }
2.40 frystyk 180: }
181: if (!replace) StrAllocCopy(replace, token);
182: return replace;
2.15 luotonen 183: }
184:
2.7 timbl 185: /* Load one line of configuration
186: ** ------------------------------
187: ** Call this, for example, to load a X resource with config info.
2.40 frystyk 188: ** Returns YES if line OK, else NO
2.7 timbl 189: */
2.48 frystyk 190: PUBLIC BOOL HTRule_parseLine (HTList * list, const char * config)
2.7 timbl 191: {
192: HTRuleOp op;
193: char * line = NULL;
2.40 frystyk 194: char * ptr;
195: char * word1, * word2, * word3;
2.7 timbl 196: int status;
2.40 frystyk 197: if ((ptr = strchr(config, '#'))) *ptr = '\0';
198: StrAllocCopy(line, config); /* Get our own copy */
199: ptr = line;
200: if ((word1 = HTNextField(&ptr)) == NULL) { /* Empty line */
2.45 frystyk 201: HT_FREE(line);
2.40 frystyk 202: return YES;
2.7 timbl 203: }
2.40 frystyk 204: if ((word2 = HTNextField(&ptr)) == NULL) {
205: if (APP_TRACE)
2.47 eric 206: HTTrace("Rule Parse.. Insufficient operands: `%s\'\n",line);
2.45 frystyk 207: HT_FREE(line);
2.40 frystyk 208: return NO;
2.7 timbl 209: }
2.40 frystyk 210: word3 = HTNextField(&ptr);
2.7 timbl 211:
2.40 frystyk 212: /* Look for things we recognize */
213: if (!strcasecomp(word1, "addtype")) {
214: double quality;
215: char * encoding = HTNextField(&ptr);
216: status = ptr ? sscanf(ptr, "%lf", &quality) : 0;
2.37 frystyk 217: HTBind_add(word2, /* suffix */
218: word3, /* type */
219: encoding ? encoding : "binary", /* encoding */
2.50 ! frystyk 220: NULL, /* cte */
2.40 frystyk 221: NULL, /* language */
2.37 frystyk 222: status >= 1? quality : 1.0); /* quality */
2.7 timbl 223:
2.40 frystyk 224: } else if (!strcasecomp(word1, "addencoding")) {
225: double quality;
226: status = ptr ? sscanf(ptr, "%lf", &quality) : 0;
227: HTBind_addEncoding(word2, word3, status >= 1 ? quality : 1.0);
228:
229: } else if (!strcasecomp(word1, "addlanguage")) {
230: double quality;
231: status = ptr ? sscanf(ptr, "%lf", &quality) : 0;
232: HTBind_addLanguage(word2, word3, status >= 1 ? quality : 1.0);
233:
234: } else if (!strcasecomp(word1, "presentation")) {
235: HTList * converters = HTFormat_conversion();
236: double quality, secs, secs_per_byte;
237: status = ptr ? sscanf(ptr,"%lf%lf%lf",&quality,&secs,&secs_per_byte):0;
2.36 frystyk 238: HTPresentation_add(converters, word2, word3, NULL,
2.40 frystyk 239: status >= 1 ? quality : 1.0,
240: status >= 2 ? secs : 0.0,
241: status >= 3 ? secs_per_byte : 0.0);
242:
243: } else if (!strcasecomp(word1, "proxy")) {
244: HTProxy_add(word2, word3);
245:
246: } else if (!strcasecomp(word1, "noproxy")) {
247: int port = 0;
248: status = ptr ? sscanf(ptr, "%d", &port) : 0;
249: HTNoProxy_add(word2, word3, port);
250:
251: } else if (!strcasecomp(word1, "gateway")) {
252: HTGateway_add(word2, word3);
2.12 luotonen 253:
2.7 timbl 254: } else {
255: op = 0==strcasecomp(word1, "map") ? HT_Map
256: : 0==strcasecomp(word1, "pass") ? HT_Pass
257: : 0==strcasecomp(word1, "fail") ? HT_Fail
2.19 luotonen 258: : HT_Invalid;
2.40 frystyk 259: if (op == HT_Invalid) {
260: if (APP_TRACE)
2.47 eric 261: HTTrace("Rule Parse.. Bad or unknown: `%s'\n", config);
2.40 frystyk 262: } else
263: HTRule_add(list, op, word2, word3);
2.7 timbl 264: }
2.45 frystyk 265: HT_FREE(line);
2.40 frystyk 266: return YES;
2.7 timbl 267: }
268:
2.40 frystyk 269: /*
270: ** Folding is either of CF LWS, LF LWS, CRLF LWS
271: */
2.48 frystyk 272: PRIVATE int HTRule_put_block (HTStream * me, const char * b, int l)
2.40 frystyk 273: {
274: while (l > 0) {
275: if (me->EOLstate == EOL_FCR) {
276: if (*b == LF) /* CRLF */
277: me->EOLstate = EOL_FLF;
278: else if (WHITE(*b)) /* Folding: CR SP */
279: me->EOLstate = EOL_DOT;
280: else { /* New line */
2.42 frystyk 281: HTRule_parseLine(rules, HTChunk_data(me->buffer));
2.40 frystyk 282: me->EOLstate = EOL_BEGIN;
2.42 frystyk 283: HTChunk_clear(me->buffer);
2.40 frystyk 284: continue;
285: }
286: } else if (me->EOLstate == EOL_FLF) {
287: if (WHITE(*b)) /* Folding: LF SP or CR LF SP */
288: me->EOLstate = EOL_DOT;
289: else { /* New line */
2.42 frystyk 290: HTRule_parseLine(rules, HTChunk_data(me->buffer));
2.40 frystyk 291: me->EOLstate = EOL_BEGIN;
2.42 frystyk 292: HTChunk_clear(me->buffer);
2.40 frystyk 293: continue;
294: }
295: } else if (me->EOLstate == EOL_DOT) {
296: if (WHITE(*b)) {
297: me->EOLstate = EOL_BEGIN;
2.42 frystyk 298: HTChunk_putc(me->buffer, ' ');
2.40 frystyk 299: } else {
2.42 frystyk 300: HTRule_parseLine(rules, HTChunk_data(me->buffer));
2.40 frystyk 301: me->EOLstate = EOL_BEGIN;
2.42 frystyk 302: HTChunk_clear(me->buffer);
2.40 frystyk 303: continue;
304: }
305: } else if (*b == CR) {
306: me->EOLstate = EOL_FCR;
307: } else if (*b == LF) {
308: me->EOLstate = EOL_FLF; /* Line found */
309: } else
2.42 frystyk 310: HTChunk_putc(me->buffer, *b);
2.40 frystyk 311: l--; b++;
312: }
313: return HT_OK;
314: }
2.1 timbl 315:
2.40 frystyk 316: PRIVATE int HTRule_put_character (HTStream * me, char c)
317: {
318: return HTRule_put_block(me, &c, 1);
319: }
320:
2.48 frystyk 321: PRIVATE int HTRule_put_string (HTStream * me, const char * s)
2.40 frystyk 322: {
323: return HTRule_put_block(me, s, (int) strlen(s));
324: }
325:
326: PRIVATE int HTRule_flush (HTStream * me)
327: {
328: return (*me->target->isa->flush)(me->target);
329: }
330:
331: PRIVATE int HTRule_free (HTStream * me)
332: {
333: int status = HT_OK;
334: if (me->target) {
335: if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
336: return HT_WOULD_BLOCK;
337: }
338: if (APP_TRACE)
2.47 eric 339: HTTrace("Rules....... FREEING....\n");
2.42 frystyk 340: HTChunk_delete(me->buffer);
2.45 frystyk 341: HT_FREE(me);
2.40 frystyk 342: return status;
343: }
344:
345: PRIVATE int HTRule_abort (HTStream * me, HTList * e)
346: {
347: int status = HT_ERROR;
348: if (me->target) status = (*me->target->isa->abort)(me->target, e);
2.47 eric 349: if (APP_TRACE) HTTrace("Rules....... ABORTING...\n");
2.42 frystyk 350: HTChunk_delete(me->buffer);
2.45 frystyk 351: HT_FREE(me);
2.40 frystyk 352: return status;
353: }
354:
355: /* Structured Object Class
356: ** -----------------------
2.1 timbl 357: */
2.48 frystyk 358: PRIVATE const HTStreamClass HTRuleClass =
2.40 frystyk 359: {
360: "RuleParser",
361: HTRule_flush,
362: HTRule_free,
363: HTRule_abort,
364: HTRule_put_character,
365: HTRule_put_string,
366: HTRule_put_block
367: };
368:
369: PUBLIC HTStream * HTRules (HTRequest * request,
370: void * param,
371: HTFormat input_format,
372: HTFormat output_format,
373: HTStream * output_stream)
2.1 timbl 374: {
2.41 frystyk 375: HTAlertCallback *cbf = HTAlert_find(HT_A_CONFIRM);
2.40 frystyk 376: HTStream * me;
2.46 frystyk 377: if (!cbf ||
378: (cbf && (*cbf)(request,HT_A_CONFIRM,HT_MSG_RULES,NULL,NULL,NULL))) {
2.47 eric 379: if (WWWTRACE) HTTrace("Rule file... Parser object created\n");
2.45 frystyk 380: if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
381: HT_OUTOFMEM("HTRules");
2.40 frystyk 382: me->isa = &HTRuleClass;
383: me->request = request;
384: me->target = output_stream;
2.42 frystyk 385: me->buffer = HTChunk_new(512);
2.40 frystyk 386: me->EOLstate = EOL_BEGIN;
387: if (!rules) rules = HTList_new();
388: } else
2.43 frystyk 389: me = HTErrorStream();
2.40 frystyk 390: return me;
2.1 timbl 391: }
2.11 luotonen 392:
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTRules.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src