Annotation of libwww/Library/src/HTMIME.c, revision 2.52
2.15 frystyk 1: /* HTMIME.c
2: ** MIME MESSAGE PARSE
3: **
2.22 frystyk 4: ** (c) COPYRIGHT MIT 1995.
2.15 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
2.1 timbl 6: **
7: ** This is RFC 1341-specific code.
8: ** The input stream pushed into this parser is assumed to be
9: ** stripped on CRs, ie lines end with LF, not CR LF.
10: ** (It is easy to change this except for the body part where
11: ** conversion can be slow.)
12: **
13: ** History:
14: ** Feb 92 Written Tim Berners-Lee, CERN
2.13 duns 15: ** 8 Jul 94 FM Insulate free() from _free structure element.
2.18 frystyk 16: ** 14 Mar 95 HFN Now using anchor for storing data. No more `\n',
17: ** static buffers etc.
2.1 timbl 18: */
2.17 frystyk 19:
20: /* Library include files */
21: #include "tcp.h"
22: #include "HTUtils.h"
23: #include "HTString.h"
2.9 luotonen 24: #include "HTFormat.h"
2.27 frystyk 25: #include "HTCache.h"
26: #include "HTAlert.h"
2.42 frystyk 27: #include "HTAncMan.h"
2.18 frystyk 28: #include "HTChunk.h"
2.26 frystyk 29: #include "HTMethod.h"
2.36 frystyk 30: #include "HTHeader.h"
2.24 frystyk 31: #include "HTSocket.h"
2.39 frystyk 32: #include "HTWWWStr.h"
2.17 frystyk 33: #include "HTFWrite.h"
2.32 frystyk 34: #include "HTNetMan.h"
2.31 frystyk 35: #include "HTReqMan.h"
2.14 frystyk 36: #include "HTMIME.h" /* Implemented here */
2.1 timbl 37:
38: /* MIME Object
39: ** -----------
40: */
41: typedef enum _MIME_state {
2.23 frystyk 42: BEGINNING_OF_LINE=0,
2.18 frystyk 43: CHECK, /* check against check_pointer */
44: UNKNOWN, /* Unknown header */
45: JUNK_LINE, /* Ignore rest of header */
46:
2.32 frystyk 47: CON, /* Intermediate states */
48: CONTENT,
2.45 frystyk 49: FIRSTLETTER_A,
2.18 frystyk 50: FIRSTLETTER_D,
51: FIRSTLETTER_L,
52: CONTENTLETTER_L,
53: CONTENTLETTER_T,
54:
2.45 frystyk 55: ACCEPT_TYPE, /* Headers supported */
56: ACCEPT_CHARSET,
57: ACCEPT_ENCODING,
58: ACCEPT_LANGUAGE,
59: ALLOW,
2.18 frystyk 60: AUTHENTICATE,
2.32 frystyk 61: CONNECTION,
2.18 frystyk 62: CONTENT_ENCODING,
63: CONTENT_LANGUAGE,
64: CONTENT_LENGTH,
2.14 frystyk 65: CONTENT_TRANSFER_ENCODING,
66: CONTENT_TYPE,
2.23 frystyk 67: MIME_DATE,
2.18 frystyk 68: DERIVED_FROM,
69: EXPIRES,
70: LAST_MODIFIED,
71: LINK,
2.14 frystyk 72: LOCATION,
2.18 frystyk 73: PUBLIC_METHODS,
74: RETRY_AFTER,
75: TITLE,
76: URI_HEADER,
77: VERSION
2.1 timbl 78: } MIME_state;
79:
80: struct _HTStream {
2.18 frystyk 81: CONST HTStreamClass * isa;
82: HTRequest * request;
2.32 frystyk 83: HTNet * net;
84: HTParentAnchor * anchor;
2.18 frystyk 85: HTStream * target;
86: HTFormat target_format;
87: HTChunk * buffer;
88: HTSocketEOL EOLstate;
89: BOOL transparent;
2.48 frystyk 90: BOOL head_only;
2.35 frystyk 91: BOOL nntp;
2.1 timbl 92: };
93:
2.18 frystyk 94: /* ------------------------------------------------------------------------- */
2.1 timbl 95:
2.18 frystyk 96: /*
2.1 timbl 97: ** This is a FSM parser which is tolerant as it can be of all
98: ** syntax errors. It ignores field names it does not understand,
99: ** and resynchronises on line beginnings.
100: */
2.36 frystyk 101: PRIVATE int parseheader (HTStream * me, HTRequest * request,
102: HTParentAnchor * anchor)
2.18 frystyk 103: {
104: MIME_state state = BEGINNING_OF_LINE;
105: MIME_state ok_state; /* got this state if match */
106: char *ptr = me->buffer->data-1; /* We dont change the data in length */
107: char *stop = ptr+me->buffer->size; /* When to stop */
108: char *header = ptr; /* For diagnostics */
109: CONST char * check_pointer; /* checking input */
110: char *value;
2.27 frystyk 111:
112: /* In case we get an empty header consisting of a CRLF, we fall thru */
2.18 frystyk 113: while (ptr < stop) {
114: switch (state) {
115: case BEGINNING_OF_LINE:
116: header = ++ptr;
117: switch (TOLOWER(*ptr)) {
2.50 frystyk 118: case '\0':
119: state = BEGINNING_OF_LINE; /* Empty line */
120: continue;
121:
2.18 frystyk 122: case 'a':
2.45 frystyk 123: state = FIRSTLETTER_A;
2.18 frystyk 124: break;
125:
126: case 'c':
2.32 frystyk 127: check_pointer = "on";
128: ok_state = CON;
2.18 frystyk 129: state = CHECK;
130: break;
131:
132: case 'd':
133: state = FIRSTLETTER_D;
134: break;
135:
136: case 'e':
137: check_pointer = "xpires";
138: ok_state = EXPIRES;
139: state = CHECK;
140: break;
141:
2.32 frystyk 142: case 'k':
2.33 frystyk 143: check_pointer = "eep-alive";
144: ok_state = JUNK_LINE; /* We don't use this but recognize it */
145: state = CHECK;
2.32 frystyk 146: break;
147:
2.18 frystyk 148: case 'l':
149: state = FIRSTLETTER_L;
150: break;
151:
152: case 'm':
153: check_pointer = "ime-version";
154: ok_state = JUNK_LINE; /* We don't use this but recognize it */
155: state = CHECK;
156: break;
157:
2.35 frystyk 158: case 'n':
159: check_pointer = "ewsgroups";
160: me->nntp = YES; /* Due to news brain damage */
161: ok_state = JUNK_LINE; /* We don't use this but recognize it */
162: state = CHECK;
163: break;
164:
2.18 frystyk 165: case 'r':
166: check_pointer = "etry-after";
167: ok_state = RETRY_AFTER;
168: state = CHECK;
169: break;
170:
171: case 's':
172: check_pointer = "erver";
173: ok_state = JUNK_LINE; /* We don't use this but recognize it */
174: state = CHECK;
175: break;
2.1 timbl 176:
2.18 frystyk 177: case 't':
178: check_pointer = "itle";
179: ok_state = TITLE;
180: state = CHECK;
181: break;
182:
183: case 'u':
184: check_pointer = "ri";
185: ok_state = URI_HEADER;
186: state = CHECK;
187: break;
188:
189: case 'v':
190: check_pointer = "ersion";
191: ok_state = VERSION;
192: state = CHECK;
193: break;
194:
195: case 'w':
196: check_pointer = "ww-authenticate";
197: ok_state = AUTHENTICATE;
198: state = CHECK;
199: break;
2.1 timbl 200:
2.18 frystyk 201: default:
202: state = UNKNOWN;
203: break;
204: }
205: ptr++;
2.1 timbl 206: break;
207:
2.45 frystyk 208: case FIRSTLETTER_A:
209: if (!strncasecomp(ptr, "llow", 4)) {
210: state = ALLOW;
211: ptr += 4;
212: } else if (!strncasecomp(ptr, "ccept-language", 14)) {
213: state = ACCEPT_LANGUAGE;
214: ptr += 14;
215: } else if (!strncasecomp(ptr, "ccept-charset", 13)) {
216: state = ACCEPT_CHARSET;
217: ptr += 13;
218: } else if (!strncasecomp(ptr, "ccept", 5)) {
219: state = ACCEPT_TYPE;
220: ptr += 5;
221: } else
222: state = UNKNOWN;
223: ptr++;
224: break;
225:
2.18 frystyk 226: case FIRSTLETTER_D:
227: switch (TOLOWER(*ptr)) {
228: case 'a':
229: check_pointer = "te";
2.23 frystyk 230: ok_state = MIME_DATE;
2.18 frystyk 231: state = CHECK;
232: break;
233:
234: case 'e':
235: check_pointer = "rived-from";
236: ok_state = DERIVED_FROM;
237: state = CHECK;
238: break;
239:
240: default:
241: state = UNKNOWN;
242: break;
243: }
244: ptr++;
245: break;
246:
247: case FIRSTLETTER_L:
248: switch (TOLOWER(*ptr)) {
249: case 'a':
250: check_pointer = "st-modified";
251: ok_state = LAST_MODIFIED;
252: state = CHECK;
253: break;
254:
255: case 'i':
256: check_pointer = "nk";
257: ok_state = LINK;
258: state = CHECK;
259: break;
260:
261: case 'o':
262: check_pointer = "cation";
263: ok_state = LOCATION;
264: state = CHECK;
265: break;
266:
267: default:
268: state = UNKNOWN;
269: break;
270: }
271: ptr++;
272: break;
273:
2.32 frystyk 274: case CON:
275: switch (TOLOWER(*ptr)) {
276: case 'n':
277: check_pointer = "ection";
278: ok_state = CONNECTION;
279: state = CHECK;
280: break;
281:
282: case 't':
283: check_pointer = "ent-";
284: ok_state = CONTENT;
285: state = CHECK;
286: break;
287:
288: default:
289: state = UNKNOWN;
290: break;
291: }
292: ptr++;
293: break;
294:
2.18 frystyk 295: case CONTENT:
296: switch (TOLOWER(*ptr)) {
297: case 'e':
298: check_pointer = "ncoding";
299: ok_state = CONTENT_ENCODING;
300: state = CHECK;
301: break;
302:
303: case 'l':
304: state = CONTENTLETTER_L;
305: break;
306:
307: case 't':
308: state = CONTENTLETTER_T;
309: break;
310:
311: default:
312: state = UNKNOWN;
313: break;
314: }
315: ptr++;
2.1 timbl 316: break;
2.14 frystyk 317:
2.18 frystyk 318: case CONTENTLETTER_L:
319: switch (TOLOWER(*ptr)) {
320: case 'a':
321: check_pointer = "nguage";
322: ok_state = CONTENT_LANGUAGE;
323: state = CHECK;
324: break;
325:
326: case 'e':
327: check_pointer = "ngth";
328: ok_state = CONTENT_LENGTH;
329: state = CHECK;
330: break;
331:
332: default:
333: state = UNKNOWN;
334: break;
335: }
336: ptr++;
2.14 frystyk 337: break;
338:
2.18 frystyk 339: case CONTENTLETTER_T:
340: switch (TOLOWER(*ptr)) {
341: case 'r':
342: check_pointer = "ansfer-encoding";
343: ok_state = CONTENT_TRANSFER_ENCODING;
344: state = CHECK;
345: break;
346:
347: case 'y':
348: check_pointer = "pe";
349: ok_state = CONTENT_TYPE;
350: state = CHECK;
351: break;
352:
353: default:
354: state = UNKNOWN;
355: break;
356: }
357: ptr++;
2.14 frystyk 358: break;
359:
2.18 frystyk 360: case CHECK: /* Check against string */
2.45 frystyk 361: while (TOLOWER(*ptr) == *check_pointer) ptr++, check_pointer++;
362: if (!*check_pointer) {
2.18 frystyk 363: state = ok_state;
364: while (*ptr && (WHITE(*ptr) || *ptr==':')) /* Spool to value */
365: ptr++;
366: } else
367: state = UNKNOWN;
2.14 frystyk 368: break;
369:
2.45 frystyk 370: case ACCEPT_TYPE: /* @@@ */
371: state = JUNK_LINE;
372: break;
373:
374: case ACCEPT_CHARSET: /* @@@ */
375: state = JUNK_LINE;
376: break;
377:
378: case ACCEPT_ENCODING: /* @@@ */
379: state = JUNK_LINE;
380: break;
381:
382: case ACCEPT_LANGUAGE: /* @@@ */
383: state = JUNK_LINE;
384: break;
385:
386: case ALLOW:
2.20 frystyk 387: while ((value = HTNextField(&ptr)) != NULL) {
388: HTMethod new_method;
2.26 frystyk 389: /* We treat them as case-insensitive! */
2.20 frystyk 390: if ((new_method = HTMethod_enum(value)) != METHOD_INVALID)
391: anchor->methods += new_method;
2.1 timbl 392: }
2.18 frystyk 393: if (STREAM_TRACE)
2.37 frystyk 394: TTYPrint(TDEST, "MIMEParser.. Methods allowed: %d\n",
2.18 frystyk 395: anchor->methods);
396: state = JUNK_LINE;
2.1 timbl 397: break;
2.18 frystyk 398:
399: case AUTHENTICATE:
400: if ((value = HTNextField(&ptr)) != NULL) {
401: StrAllocCopy(request->WWWAAScheme, value);
2.20 frystyk 402:
403: /* The parsing is done in HTSSUtils.c for the moment */
404: if (*ptr) StrAllocCopy(request->WWWAARealm, ptr);
2.1 timbl 405: }
2.18 frystyk 406: state = JUNK_LINE;
407: break;
408:
2.32 frystyk 409: case CONNECTION:
410: if ((value = HTNextField(&ptr)) != NULL) {
411: if (!strcasecomp(value, "keep-alive")) {
412: if (STREAM_TRACE)
2.43 frystyk 413: TTYPrint(TDEST,"MIMEParser.. Persistent Connection\n");
2.50 frystyk 414: me->net->persistent = YES;
2.32 frystyk 415: HTDNS_setSocket(me->net->dns, me->net->sockfd);
416: }
417: }
418: state = JUNK_LINE;
419: break;
420:
2.18 frystyk 421: case CONTENT_ENCODING:
422: if ((value = HTNextField(&ptr)) != NULL) {
423: char *lc = value;
2.20 frystyk 424: while ((*lc = TOLOWER(*lc))) lc++;
2.18 frystyk 425: anchor->content_encoding = HTAtom_for(value);
426: }
427: state = JUNK_LINE;
428: break;
429:
2.21 frystyk 430: case CONTENT_LANGUAGE: /* @@@ SHOULD BE A LIST @@@ */
431: if ((value = HTNextField(&ptr)) != NULL) {
432: char *lc = value;
433: while ((*lc = TOLOWER(*lc))) lc++;
434: anchor->content_language = HTAtom_for(value);
435: }
436: state = JUNK_LINE;
2.18 frystyk 437: break;
438:
439: case CONTENT_LENGTH:
440: if ((value = HTNextField(&ptr)) != NULL)
441: anchor->content_length = atol(value);
442: state = JUNK_LINE;
443: break;
444:
445: case CONTENT_TRANSFER_ENCODING:
446: if ((value = HTNextField(&ptr)) != NULL) {
447: char *lc = value;
2.20 frystyk 448: while ((*lc = TOLOWER(*lc))) lc++;
2.18 frystyk 449: anchor->cte = HTAtom_for(value);
450: }
451: state = JUNK_LINE;
452: break;
453:
454: case CONTENT_TYPE:
455: if ((value = HTNextField(&ptr)) != NULL) {
456: char *lc = value;
457: while ((*lc = TOLOWER(*lc))) lc++;
458: anchor->content_type = HTAtom_for(value);
2.38 frystyk 459: while ((value = HTNextField(&ptr)) != NULL) {
2.20 frystyk 460: if (!strcasecomp(value, "charset")) {
461: if ((value = HTNextField(&ptr)) != NULL) {
462: lc = value;
463: while ((*lc = TOLOWER(*lc))) lc++;
464: anchor->charset = HTAtom_for(value);
465: }
2.38 frystyk 466: } else if (!strcasecomp(value, "level")) {
2.20 frystyk 467: if ((value = HTNextField(&ptr)) != NULL) {
468: lc = value;
469: while ((*lc = TOLOWER(*lc))) lc++;
470: anchor->level = HTAtom_for(value);
471: }
2.38 frystyk 472: } else if (!strcasecomp(value, "boundary")) {
473: if ((value = HTNextField(&ptr)) != NULL) {
474: StrAllocCopy(request->boundary, value);
475: }
2.20 frystyk 476: }
477: }
2.1 timbl 478: }
2.20 frystyk 479: state = JUNK_LINE;
2.18 frystyk 480: break;
481:
2.23 frystyk 482: case MIME_DATE:
2.18 frystyk 483: anchor->date = HTParseTime(ptr);
484: state = JUNK_LINE;
485: break;
486:
487: case DERIVED_FROM:
488: if ((value = HTNextField(&ptr)) != NULL)
489: StrAllocCopy(anchor->derived_from, value);
490: state = JUNK_LINE;
491: break;
492:
493: case EXPIRES:
494: anchor->expires = HTParseTime(ptr);
495: state = JUNK_LINE;
496: break;
497:
498: case LAST_MODIFIED:
499: anchor->last_modified = HTParseTime(ptr);
500: state = JUNK_LINE;
501: break;
502:
503: case LINK:
2.20 frystyk 504: state = UNKNOWN; /* @@@@@@@@@@@ */
2.18 frystyk 505: break;
506:
507: case LOCATION:
2.46 frystyk 508: request->redirectionAnchor = HTAnchor_findAddress(HTStrip(ptr));
2.18 frystyk 509: state = JUNK_LINE;
510: break;
511:
512: case PUBLIC_METHODS:
2.20 frystyk 513: state = UNKNOWN; /* @@@@@@@@@@@ */
2.18 frystyk 514: break;
515:
516: case RETRY_AFTER:
2.19 frystyk 517: request->retry_after = HTParseTime(ptr);
518: state = JUNK_LINE;
2.18 frystyk 519: break;
520:
521: case TITLE: /* Can't reuse buffer as HTML version might differ */
522: if ((value = HTNextField(&ptr)) != NULL)
523: StrAllocCopy(anchor->title, value);
524: state = JUNK_LINE;
525: break;
526:
527: case URI_HEADER:
528: state = LOCATION; /* @@@ Need extended parsing */
529: break;
530:
531: case VERSION:
532: if ((value = HTNextField(&ptr)) != NULL)
533: StrAllocCopy(anchor->version, value);
534: state = JUNK_LINE;
535: break;
536:
537: case UNKNOWN:
2.40 frystyk 538: {
2.36 frystyk 539: HTList * list;
540: HTParserCallback *cbf;
541: int status;
542: BOOL override;
543: if (STREAM_TRACE)
2.38 frystyk 544: TTYPrint(TDEST,"MIMEParser.. Unknown `%s\'\n", header);
2.36 frystyk 545: if ((list = HTRequest_parser(request, &override)) &&
2.40 frystyk 546: (cbf = HTParser_find(list, header)) &&
547: (status = (*cbf)(request, header) != HT_OK)) {
2.36 frystyk 548: return status;
549: } else if (!override &&
550: (list = HTHeader_parser()) &&
2.40 frystyk 551: (cbf = HTParser_find(list, header)) &&
552: (status = (*cbf)(request, header) != HT_OK)) {
2.36 frystyk 553: return status;
554: }
555: }
2.18 frystyk 556:
557: case JUNK_LINE:
558: while (*ptr) ptr++;
559: state = BEGINNING_OF_LINE;
560: break;
2.1 timbl 561: }
2.18 frystyk 562: }
2.48 frystyk 563: me->transparent = YES; /* Pump rest of data right through */
2.50 frystyk 564: #if 0
565: HTChunk_clear(me->buffer); /* Get ready for next header */
566: #endif
2.27 frystyk 567:
2.48 frystyk 568: /* If this request us a source in PostWeb then pause here */
569: if (me->head_only || HTRequest_isSource(request)) return HT_PAUSE;
2.47 frystyk 570:
2.48 frystyk 571: /* If HEAD method then we just stop here */
2.47 frystyk 572: if (request->method == METHOD_HEAD) return HT_LOADED;
2.43 frystyk 573:
2.35 frystyk 574: /* News server almost never send content type or content length */
575: if (anchor->content_type != WWW_UNKNOWN || me->nntp) {
2.48 frystyk 576: if (STREAM_TRACE) TTYPrint(TDEST, "MIMEParser.. Convert %s to %s\n",
577: HTAtom_name(anchor->content_type),
578: HTAtom_name(me->target_format));
579: me->target = HTStreamStack(anchor->content_type, me->target_format,
580: me->target, request, YES);
2.18 frystyk 581: }
2.49 frystyk 582: if (!me->target) me->target = HTErrorStream();
2.27 frystyk 583: return HT_OK;
2.1 timbl 584: }
585:
586:
2.18 frystyk 587: /*
588: ** Header is terminated by CRCR, LFLF, CRLFLF, CRLFCRLF
589: ** Folding is either of CF LWS, LF LWS, CRLF LWS
590: */
2.36 frystyk 591: PRIVATE int HTMIME_put_block (HTStream * me, CONST char * b, int l)
2.18 frystyk 592: {
593: while (!me->transparent && l-- > 0) {
594: if (me->EOLstate == EOL_FCR) {
2.27 frystyk 595: if (*b == CR) { /* End of header */
2.32 frystyk 596: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 597: HTNet_setBytesRead(me->net, l);
2.27 frystyk 598: if (status != HT_OK)
599: return status;
600: } else if (*b == LF) /* CRLF */
2.18 frystyk 601: me->EOLstate = EOL_FLF;
602: else if (WHITE(*b)) { /* Folding: CR SP */
603: me->EOLstate = EOL_BEGIN;
2.44 frystyk 604: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 605: } else { /* New line */
606: me->EOLstate = EOL_BEGIN;
2.44 frystyk 607: HTChunk_putc(me->buffer, '\0');
2.50 frystyk 608: HTChunk_putc(me->buffer, *b);
2.18 frystyk 609: }
610: } else if (me->EOLstate == EOL_FLF) {
611: if (*b == CR) /* LF CR or CR LF CR */
612: me->EOLstate = EOL_SCR;
2.27 frystyk 613: else if (*b == LF) { /* End of header */
2.32 frystyk 614: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 615: HTNet_setBytesRead(me->net, l);
2.27 frystyk 616: if (status != HT_OK)
617: return status;
618: } else if (WHITE(*b)) { /* Folding: LF SP or CR LF SP */
2.18 frystyk 619: me->EOLstate = EOL_BEGIN;
2.44 frystyk 620: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 621: } else { /* New line */
622: me->EOLstate = EOL_BEGIN;
2.44 frystyk 623: HTChunk_putc(me->buffer, '\0');
2.50 frystyk 624: HTChunk_putc(me->buffer, *b);
2.18 frystyk 625: }
626: } else if (me->EOLstate == EOL_SCR) {
2.27 frystyk 627: if (*b==CR || *b==LF) { /* End of header */
2.32 frystyk 628: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 629: HTNet_setBytesRead(me->net, l);
2.27 frystyk 630: if (status != HT_OK)
631: return status;
632: } else if (WHITE(*b)) { /* Folding: LF CR SP or CR LF CR SP */
2.18 frystyk 633: me->EOLstate = EOL_BEGIN;
2.44 frystyk 634: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 635: } else { /* New line */
636: me->EOLstate = EOL_BEGIN;
2.44 frystyk 637: HTChunk_putc(me->buffer, '\0');
2.50 frystyk 638: HTChunk_putc(me->buffer, *b);
2.18 frystyk 639: }
640: } else if (*b == CR) {
641: me->EOLstate = EOL_FCR;
642: } else if (*b == LF) {
643: me->EOLstate = EOL_FLF; /* Line found */
644: } else
2.50 frystyk 645: HTChunk_putc(me->buffer, *b);
2.18 frystyk 646: b++;
647: }
2.32 frystyk 648:
649: /*
650: ** Put the rest down the stream without touching the data but make sure
651: ** that we get the correct content length of data
652: */
2.48 frystyk 653: if (me->transparent) {
2.47 frystyk 654: int status = (*me->target->isa->put_block)(me->target, b, l);
2.48 frystyk 655: if (status == HT_OK) {
2.47 frystyk 656: /* Check if CL at all - thanks to jwei@hal.com (John Wei) */
2.48 frystyk 657: long cl = HTAnchor_length(me->anchor);
658: return (cl>=0 && HTNet_bytesRead(me->net)>=cl) ? HT_LOADED : HT_OK;
659: } else
2.47 frystyk 660: return status;
2.48 frystyk 661: }
662: return HT_OK;
2.18 frystyk 663: }
664:
665:
666: /* Character handling
667: ** ------------------
668: */
2.36 frystyk 669: PRIVATE int HTMIME_put_character (HTStream * me, char c)
2.18 frystyk 670: {
671: return HTMIME_put_block(me, &c, 1);
672: }
673:
2.1 timbl 674:
675: /* String handling
676: ** ---------------
677: */
2.36 frystyk 678: PRIVATE int HTMIME_put_string (HTStream * me, CONST char * s)
2.1 timbl 679: {
2.18 frystyk 680: return HTMIME_put_block(me, s, (int) strlen(s));
2.1 timbl 681: }
682:
683:
2.18 frystyk 684: /* Flush an stream object
685: ** ---------------------
2.1 timbl 686: */
2.36 frystyk 687: PRIVATE int HTMIME_flush (HTStream * me)
2.1 timbl 688: {
2.47 frystyk 689: return me->target ? (*me->target->isa->flush)(me->target) : HT_OK;
2.1 timbl 690: }
691:
2.18 frystyk 692: /* Free a stream object
693: ** --------------------
2.1 timbl 694: */
2.36 frystyk 695: PRIVATE int HTMIME_free (HTStream * me)
2.1 timbl 696: {
2.18 frystyk 697: int status = HT_OK;
2.51 frystyk 698: if (!me->transparent) parseheader(me, me->request, me->anchor);
2.25 frystyk 699: if (me->target) {
700: if ((status = (*me->target->isa->_free)(me->target))==HT_WOULD_BLOCK)
701: return HT_WOULD_BLOCK;
702: }
2.26 frystyk 703: if (PROT_TRACE)
2.37 frystyk 704: TTYPrint(TDEST, "MIME........ FREEING....\n");
2.44 frystyk 705: HTChunk_delete(me->buffer);
2.52 ! frystyk 706: HT_FREE(me);
2.18 frystyk 707: return status;
2.1 timbl 708: }
709:
710: /* End writing
711: */
2.38 frystyk 712: PRIVATE int HTMIME_abort (HTStream * me, HTList * e)
2.1 timbl 713: {
2.18 frystyk 714: int status = HT_ERROR;
2.41 frystyk 715: if (me->target) status = (*me->target->isa->abort)(me->target, e);
2.26 frystyk 716: if (PROT_TRACE)
2.37 frystyk 717: TTYPrint(TDEST, "MIME........ ABORTING...\n");
2.44 frystyk 718: HTChunk_delete(me->buffer);
2.52 ! frystyk 719: HT_FREE(me);
2.18 frystyk 720: return status;
2.1 timbl 721: }
722:
723:
724:
725: /* Structured Object Class
726: ** -----------------------
727: */
2.6 timbl 728: PRIVATE CONST HTStreamClass HTMIME =
2.1 timbl 729: {
730: "MIMEParser",
2.18 frystyk 731: HTMIME_flush,
2.1 timbl 732: HTMIME_free,
2.6 timbl 733: HTMIME_abort,
734: HTMIME_put_character,
735: HTMIME_put_string,
2.18 frystyk 736: HTMIME_put_block
2.1 timbl 737: };
738:
739:
2.48 frystyk 740: /* MIME header parser stream.
2.1 timbl 741: ** -------------------------
2.48 frystyk 742: ** This stream parses a complete MIME header and if a content type header
743: ** is found then the stream stack is called. Any left over data is pumped
744: ** right through the stream
2.1 timbl 745: */
2.36 frystyk 746: PUBLIC HTStream* HTMIMEConvert (HTRequest * request,
747: void * param,
748: HTFormat input_format,
749: HTFormat output_format,
750: HTStream * output_stream)
2.1 timbl 751: {
752: HTStream* me;
2.52 ! frystyk 753: if ((me = (HTStream *) HT_CALLOC(1, sizeof(* me))) == NULL)
! 754: HT_OUTOFMEM("HTMIMEConvert");
2.1 timbl 755: me->isa = &HTMIME;
2.18 frystyk 756: me->request = request;
2.32 frystyk 757: me->anchor = request->anchor;
758: me->net = request->net;
2.49 frystyk 759: me->target = output_stream;
2.18 frystyk 760: me->target_format = output_format;
2.44 frystyk 761: me->buffer = HTChunk_new(512);
2.18 frystyk 762: me->EOLstate = EOL_BEGIN;
2.1 timbl 763: return me;
764: }
2.32 frystyk 765:
2.48 frystyk 766: /* MIME header ONLY parser stream
767: ** ------------------------------
768: ** This stream parses a complete MIME header and then returnes HT_PAUSE.
769: ** It does not set up any streams and resting data stays in the buffer.
770: ** This can be used if you only want to parse the headers before you
771: ** decide what to do next. This is for example the case in a server app.
772: */
773: PUBLIC HTStream * HTMIMEHeader (HTRequest * request,
774: void * param,
775: HTFormat input_format,
776: HTFormat output_format,
777: HTStream * output_stream)
778: {
779: HTStream * me;
2.52 ! frystyk 780: if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
! 781: HT_OUTOFMEM("HTMIMEConvert");
2.48 frystyk 782: me->isa = &HTMIME;
783: me->request = request;
784: me->anchor = request->anchor;
785: me->net = request->net;
2.49 frystyk 786: me->target = output_stream;
2.48 frystyk 787: me->target_format = output_format;
788: me->buffer = HTChunk_new(512);
789: me->EOLstate = EOL_BEGIN;
790: me->head_only = YES; /* We want to pause after header */
791: return me;
792: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTMIME.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src