Annotation of libwww/Library/src/HTRules.c, revision 2.1
2.1 ! timbl 1: /* Configuration manager for Hypertext Daemon HTRules.c
! 2: ** ==========================================
! 3: **
! 4: **
! 5: ** History:
! 6: ** 3 Jun 91 Written TBL
! 7: ** 10 Aug 91 Authorisation added after Daniel Martin (pass, fail)
! 8: ** Rule order in file changed
! 9: ** Comments allowed with # on 1st char of rule line
! 10: ** 17 Jun 92 Bug fix: pass and fail failed if didn't contain '*' TBL
! 11: */
! 12:
! 13: /* (c) CERN WorldWideWeb project 1990,91. See Copyright.html for details */
! 14: #include "HTRules.h"
! 15:
! 16: #include <stdio.h>
! 17: #include "HTUtils.h"
! 18: #include "tcp.h"
! 19: #include "HTFile.h"
! 20:
! 21: #define LINE_LENGTH 256
! 22:
! 23:
! 24: typedef struct _rule {
! 25: struct _rule * next;
! 26: HTRuleOp op;
! 27: char * pattern;
! 28: char * equiv;
! 29: } rule;
! 30:
! 31: /* Module-wide variables
! 32: ** ---------------------
! 33: */
! 34:
! 35: PRIVATE rule * rules = 0; /* Pointer to first on list */
! 36: #ifndef PUT_ON_HEAD
! 37: PRIVATE rule * rule_tail = 0; /* Pointer to last on list */
! 38: #endif
! 39:
! 40: /* Add rule to the list HTAddRule()
! 41: ** --------------------
! 42: **
! 43: ** On entry,
! 44: ** pattern points to 0-terminated string containing a single "*"
! 45: ** equiv points to the equivalent string with * for the
! 46: ** place where the text matched by * goes.
! 47: ** On exit,
! 48: ** returns 0 if success, -1 if error.
! 49: */
! 50: /* Note that if BYTE_ADDRESSING is set, the three blocks required
! 51: ** are allocated and deallocated as one. This will save time and
! 52: ** storage, when malloc's allocation units are large.
! 53: */
! 54: #ifdef __STDC__
! 55: PUBLIC int HTAddRule (HTRuleOp op, const char * pattern, const char * equiv)
! 56: #else
! 57: int HTAddRule(op, pattern, equiv)
! 58: HTRuleOp op;
! 59: char * pattern;
! 60: char * equiv;
! 61: #endif
! 62: {
! 63: #ifdef BYTE_ADDRESSING /* economise on malloc() blocks */
! 64: int length_of_pattern = strlen(pattern)+1;
! 65: rule * temp = malloc(sizeof(*temp) +
! 66: size_of_pattern + strlen(equiv) + 1);
! 67: char * pPattern = (char *) &temp[1];
! 68: #else
! 69: rule * temp = (rule *)malloc(sizeof(*temp));
! 70: char * pPattern = (char *)malloc(strlen(pattern)+1);
! 71: #endif
! 72:
! 73: if (equiv) { /* Two operands */
! 74: #ifdef BYTE_ADDRESSING /* economise on malloc() blocks */
! 75: char * pEquiv = pPattern + length_of_pattern;
! 76: #else
! 77: char * pEquiv = (char *)malloc(strlen(equiv)+1);
! 78: #endif
! 79: temp->equiv = pEquiv;
! 80: strcpy(pEquiv, equiv);
! 81: } else {
! 82: temp->equiv = 0;
! 83: }
! 84: temp->pattern = pPattern;
! 85: temp->op = op;
! 86:
! 87: strcpy(pPattern, pattern);
! 88: if (TRACE) printf("Rule: For `%s' op %i `%s'\n", pattern, op, equiv);
! 89:
! 90: #ifdef PUT_ON_HEAD
! 91: temp->next = rules;
! 92: rules = temp;
! 93: #else
! 94: temp->next = 0;
! 95: if (rule_tail) rule_tail->next = temp;
! 96: else rules = temp;
! 97: rule_tail = temp;
! 98: #endif
! 99:
! 100:
! 101: return 0;
! 102: }
! 103:
! 104:
! 105: /* Clear all rules HTClearRules()
! 106: ** ---------------
! 107: **
! 108: ** On exit,
! 109: ** There are no rules
! 110: ** returns 0 if success, -1 if error.
! 111: **
! 112: ** See also
! 113: ** HTAddRule()
! 114: */
! 115: #ifdef __STDC__
! 116: int HTClearRules(void)
! 117: #else
! 118: int HTClearRules()
! 119: #endif
! 120: {
! 121: while (rules) {
! 122: rule * temp = rules;
! 123: rules = temp->next;
! 124: #ifdef BYTE_ADDRESSING
! 125: free(temp);
! 126: #else
! 127: free(temp->pattern);
! 128: free(temp->equiv);
! 129: free(temp);
! 130: #endif
! 131: }
! 132: #ifndef PUT_ON_HEAD
! 133: rule_tail = 0;
! 134: #endif
! 135:
! 136: return 0;
! 137: }
! 138:
! 139:
! 140: /* Translate by rules HTTranslate()
! 141: ** ------------------
! 142: **
! 143: ** The most recently defined rules are applied first.
! 144: **
! 145: ** On entry,
! 146: ** required points to a string whose equivalent value is neeed
! 147: ** On exit,
! 148: ** returns the address of the equivalent string allocated from
! 149: ** the heap which the CALLER MUST FREE. If no translation
! 150: ** occured, then it is a copy of te original.
! 151: */
! 152: #ifdef __STDC__
! 153: char * HTTranslate(const char * required)
! 154: #else
! 155: char * HTTranslate(required)
! 156: char * required;
! 157: #endif
! 158: {
! 159: rule * r;
! 160: char * current = (char *)malloc(strlen(required)+1);
! 161: strcpy(current, required);
! 162:
! 163: for(r = rules; r; r = r->next) {
! 164: char * p = r->pattern;
! 165: int m; /* Number of characters matched against wildcard */
! 166: CONST char * q = current;
! 167: for(;*p && *q; p++, q++) { /* Find first mismatch */
! 168: if (*p!=*q) break;
! 169: }
! 170:
! 171: if (*p == '*') { /* Match up to wildcard */
! 172: m = strlen(q) - strlen(p+1); /* Amount to match to wildcard */
! 173: if(m<0) continue; /* tail is too short to match */
! 174: if (0!=strcmp(q+m, p+1)) continue; /* Tail mismatch */
! 175: } else /* Not wildcard */
! 176: if (*p != *q) continue; /* plain mismatch: go to next rule */
! 177:
! 178: switch (r->op) { /* Perform operation */
! 179: case HT_Pass: /* Authorised */
! 180: if (!r->equiv) {
! 181: if (TRACE) printf("HTRule: Pass `%s'\n", current);
! 182: return current;
! 183: }
! 184: /* Fall through ...to map and pass */
! 185:
! 186: case HT_Map:
! 187: if (*p == *q) { /* End of both strings, no wildcard */
! 188: if (TRACE) printf(
! 189: "For `%s' using `%s'\n", current, r->equiv);
! 190: StrAllocCopy(current, r->equiv); /* use entire translation */
! 191: } else {
! 192: char * ins = strchr(r->equiv, '*'); /* Insertion point */
! 193: if (ins) { /* Consistent rule!!! */
! 194: char * temp = (char *)malloc(
! 195: strlen(r->equiv)-1 + m + 1);
! 196: strncpy(temp, r->equiv, ins-r->equiv);
! 197: /* Note: temp may be unterminated now! */
! 198: strncpy(temp+(ins-r->equiv), q, m); /* Matched bit */
! 199: strcpy (temp+(ins-r->equiv)+m, ins+1); /* Last bit */
! 200: if (TRACE) printf("For `%s' using `%s'\n",
! 201: current, temp);
! 202: free(current);
! 203: current = temp; /* Use this */
! 204:
! 205: } else { /* No insertion point */
! 206: char * temp = (char *)malloc(strlen(r->equiv)+1);
! 207: strcpy(temp, r->equiv);
! 208: if (TRACE) printf("For `%s' using `%s'\n",
! 209: current, temp);
! 210: free(current);
! 211: current = temp; /* Use this */
! 212: } /* If no insertion point exists */
! 213: }
! 214: if (r->op == HT_Pass) {
! 215: if (TRACE) printf("HTRule: ...and pass `%s'\n", current);
! 216: return current;
! 217: }
! 218: break;
! 219:
! 220: case HT_Invalid:
! 221: case HT_Fail: /* Unauthorised */
! 222: if (TRACE) printf("HTRule: *** FAIL `%s'\n", current);
! 223: return (char *)0;
! 224:
! 225: } /* if tail matches ... switch operation */
! 226:
! 227: } /* loop over rules */
! 228:
! 229:
! 230: return current;
! 231: }
! 232:
! 233:
! 234:
! 235: /* Load the rules from a file HtLoadRules()
! 236: ** --------------------------
! 237: **
! 238: ** On entry,
! 239: ** Rules can be in any state
! 240: ** On exit,
! 241: ** Any existing rules will have been kept.
! 242: ** Any new rules will have been loaded on top, so as to be tried first.
! 243: ** Returns 0 if no error.
! 244: **
! 245: ** Bugs:
! 246: ** The strings may not contain spaces.
! 247: */
! 248:
! 249: int HTLoadRules ARGS1(CONST char *, filename)
! 250: {
! 251: FILE * fp = fopen(filename, "r");
! 252: char line[LINE_LENGTH+1];
! 253: char pattern[LINE_LENGTH+1];
! 254: char operation [LINE_LENGTH+1];
! 255: char equiv[LINE_LENGTH+1];
! 256: float quality;
! 257: int status;
! 258:
! 259: if (!fp) {
! 260: if (TRACE) printf("HTRules: Can't open rules file %s\n", filename);
! 261: return -1; /* File open error */
! 262: }
! 263: for(;;) {
! 264: HTRuleOp op;
! 265: if (!fgets(line, LINE_LENGTH+1, fp)) break; /* EOF or error */
! 266:
! 267: {
! 268: char * p = strchr(line, '#'); /* Chop off comments */
! 269: if (p) *p = 0;
! 270: }
! 271: status = sscanf(line, "%256s%256s%256s%f",
! 272: operation, pattern, equiv, &quality);
! 273: if (status<=0) continue; /* Comment only or blank */
! 274: if (status<2) {
! 275: fprintf(stderr, "HTRule: Insufficient operands: %s\n", line);
! 276: return -2; /*syntax error */
! 277: }
! 278:
! 279: if (0==strcasecomp(operation, "suffix")) {
! 280: HTSetSuffix(pattern, equiv, quality);
! 281: } else {
! 282: op = 0==strcasecomp(operation, "map") ? HT_Map
! 283: : 0==strcasecomp(operation, "pass") ? HT_Pass
! 284: : 0==strcasecomp(operation, "fail") ? HT_Fail
! 285: : HT_Invalid;
! 286: if (op==HT_Invalid) {
! 287: fprintf(stderr, "HTRule: Bad rule `%s'\n", line);
! 288: /* return -2; */
! 289: } else {
! 290: HTAddRule(op, pattern, status > 2 ? equiv : NULL);
! 291: }
! 292: }
! 293: }
! 294: fclose(fp);
! 295: return 0; /* No error */
! 296: }
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