Annotation of libwww/Library/src/HTMIME.c, revision 2.47
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.35 frystyk 90: BOOL nntp;
2.1 timbl 91: };
92:
2.18 frystyk 93: /* ------------------------------------------------------------------------- */
2.1 timbl 94:
2.18 frystyk 95: /*
2.1 timbl 96: ** This is a FSM parser which is tolerant as it can be of all
97: ** syntax errors. It ignores field names it does not understand,
98: ** and resynchronises on line beginnings.
99: */
2.36 frystyk 100: PRIVATE int parseheader (HTStream * me, HTRequest * request,
101: HTParentAnchor * anchor)
2.18 frystyk 102: {
103: MIME_state state = BEGINNING_OF_LINE;
104: MIME_state ok_state; /* got this state if match */
105: char *ptr = me->buffer->data-1; /* We dont change the data in length */
106: char *stop = ptr+me->buffer->size; /* When to stop */
107: char *header = ptr; /* For diagnostics */
108: CONST char * check_pointer; /* checking input */
109: char *value;
2.27 frystyk 110:
111: /* In case we get an empty header consisting of a CRLF, we fall thru */
2.18 frystyk 112: while (ptr < stop) {
113: switch (state) {
114: case BEGINNING_OF_LINE:
115: header = ++ptr;
116: switch (TOLOWER(*ptr)) {
117: case 'a':
2.45 frystyk 118: state = FIRSTLETTER_A;
2.18 frystyk 119: break;
120:
121: case 'c':
2.32 frystyk 122: check_pointer = "on";
123: ok_state = CON;
2.18 frystyk 124: state = CHECK;
125: break;
126:
127: case 'd':
128: state = FIRSTLETTER_D;
129: break;
130:
131: case 'e':
132: check_pointer = "xpires";
133: ok_state = EXPIRES;
134: state = CHECK;
135: break;
136:
2.32 frystyk 137: case 'k':
2.33 frystyk 138: check_pointer = "eep-alive";
139: ok_state = JUNK_LINE; /* We don't use this but recognize it */
140: state = CHECK;
2.32 frystyk 141: break;
142:
2.18 frystyk 143: case 'l':
144: state = FIRSTLETTER_L;
145: break;
146:
147: case 'm':
148: check_pointer = "ime-version";
149: ok_state = JUNK_LINE; /* We don't use this but recognize it */
150: state = CHECK;
151: break;
152:
2.35 frystyk 153: case 'n':
154: check_pointer = "ewsgroups";
155: me->nntp = YES; /* Due to news brain damage */
156: ok_state = JUNK_LINE; /* We don't use this but recognize it */
157: state = CHECK;
158: break;
159:
2.18 frystyk 160: case 'r':
161: check_pointer = "etry-after";
162: ok_state = RETRY_AFTER;
163: state = CHECK;
164: break;
165:
166: case 's':
167: check_pointer = "erver";
168: ok_state = JUNK_LINE; /* We don't use this but recognize it */
169: state = CHECK;
170: break;
2.1 timbl 171:
2.18 frystyk 172: case 't':
173: check_pointer = "itle";
174: ok_state = TITLE;
175: state = CHECK;
176: break;
177:
178: case 'u':
179: check_pointer = "ri";
180: ok_state = URI_HEADER;
181: state = CHECK;
182: break;
183:
184: case 'v':
185: check_pointer = "ersion";
186: ok_state = VERSION;
187: state = CHECK;
188: break;
189:
190: case 'w':
191: check_pointer = "ww-authenticate";
192: ok_state = AUTHENTICATE;
193: state = CHECK;
194: break;
2.1 timbl 195:
2.18 frystyk 196: default:
197: state = UNKNOWN;
198: break;
199: }
200: ptr++;
2.1 timbl 201: break;
202:
2.45 frystyk 203: case FIRSTLETTER_A:
204: if (!strncasecomp(ptr, "llow", 4)) {
205: state = ALLOW;
206: ptr += 4;
207: } else if (!strncasecomp(ptr, "ccept-language", 14)) {
208: state = ACCEPT_LANGUAGE;
209: ptr += 14;
210: } else if (!strncasecomp(ptr, "ccept-charset", 13)) {
211: state = ACCEPT_CHARSET;
212: ptr += 13;
213: } else if (!strncasecomp(ptr, "ccept", 5)) {
214: state = ACCEPT_TYPE;
215: ptr += 5;
216: } else
217: state = UNKNOWN;
218: ptr++;
219: break;
220:
2.18 frystyk 221: case FIRSTLETTER_D:
222: switch (TOLOWER(*ptr)) {
223: case 'a':
224: check_pointer = "te";
2.23 frystyk 225: ok_state = MIME_DATE;
2.18 frystyk 226: state = CHECK;
227: break;
228:
229: case 'e':
230: check_pointer = "rived-from";
231: ok_state = DERIVED_FROM;
232: state = CHECK;
233: break;
234:
235: default:
236: state = UNKNOWN;
237: break;
238: }
239: ptr++;
240: break;
241:
242: case FIRSTLETTER_L:
243: switch (TOLOWER(*ptr)) {
244: case 'a':
245: check_pointer = "st-modified";
246: ok_state = LAST_MODIFIED;
247: state = CHECK;
248: break;
249:
250: case 'i':
251: check_pointer = "nk";
252: ok_state = LINK;
253: state = CHECK;
254: break;
255:
256: case 'o':
257: check_pointer = "cation";
258: ok_state = LOCATION;
259: state = CHECK;
260: break;
261:
262: default:
263: state = UNKNOWN;
264: break;
265: }
266: ptr++;
267: break;
268:
2.32 frystyk 269: case CON:
270: switch (TOLOWER(*ptr)) {
271: case 'n':
272: check_pointer = "ection";
273: ok_state = CONNECTION;
274: state = CHECK;
275: break;
276:
277: case 't':
278: check_pointer = "ent-";
279: ok_state = CONTENT;
280: state = CHECK;
281: break;
282:
283: default:
284: state = UNKNOWN;
285: break;
286: }
287: ptr++;
288: break;
289:
2.18 frystyk 290: case CONTENT:
291: switch (TOLOWER(*ptr)) {
292: case 'e':
293: check_pointer = "ncoding";
294: ok_state = CONTENT_ENCODING;
295: state = CHECK;
296: break;
297:
298: case 'l':
299: state = CONTENTLETTER_L;
300: break;
301:
302: case 't':
303: state = CONTENTLETTER_T;
304: break;
305:
306: default:
307: state = UNKNOWN;
308: break;
309: }
310: ptr++;
2.1 timbl 311: break;
2.14 frystyk 312:
2.18 frystyk 313: case CONTENTLETTER_L:
314: switch (TOLOWER(*ptr)) {
315: case 'a':
316: check_pointer = "nguage";
317: ok_state = CONTENT_LANGUAGE;
318: state = CHECK;
319: break;
320:
321: case 'e':
322: check_pointer = "ngth";
323: ok_state = CONTENT_LENGTH;
324: state = CHECK;
325: break;
326:
327: default:
328: state = UNKNOWN;
329: break;
330: }
331: ptr++;
2.14 frystyk 332: break;
333:
2.18 frystyk 334: case CONTENTLETTER_T:
335: switch (TOLOWER(*ptr)) {
336: case 'r':
337: check_pointer = "ansfer-encoding";
338: ok_state = CONTENT_TRANSFER_ENCODING;
339: state = CHECK;
340: break;
341:
342: case 'y':
343: check_pointer = "pe";
344: ok_state = CONTENT_TYPE;
345: state = CHECK;
346: break;
347:
348: default:
349: state = UNKNOWN;
350: break;
351: }
352: ptr++;
2.14 frystyk 353: break;
354:
2.18 frystyk 355: case CHECK: /* Check against string */
2.45 frystyk 356: while (TOLOWER(*ptr) == *check_pointer) ptr++, check_pointer++;
357: if (!*check_pointer) {
2.18 frystyk 358: state = ok_state;
359: while (*ptr && (WHITE(*ptr) || *ptr==':')) /* Spool to value */
360: ptr++;
361: } else
362: state = UNKNOWN;
2.14 frystyk 363: break;
364:
2.45 frystyk 365: case ACCEPT_TYPE: /* @@@ */
366: state = JUNK_LINE;
367: break;
368:
369: case ACCEPT_CHARSET: /* @@@ */
370: state = JUNK_LINE;
371: break;
372:
373: case ACCEPT_ENCODING: /* @@@ */
374: state = JUNK_LINE;
375: break;
376:
377: case ACCEPT_LANGUAGE: /* @@@ */
378: state = JUNK_LINE;
379: break;
380:
381: case ALLOW:
2.20 frystyk 382: while ((value = HTNextField(&ptr)) != NULL) {
383: HTMethod new_method;
2.26 frystyk 384: /* We treat them as case-insensitive! */
2.20 frystyk 385: if ((new_method = HTMethod_enum(value)) != METHOD_INVALID)
386: anchor->methods += new_method;
2.1 timbl 387: }
2.18 frystyk 388: if (STREAM_TRACE)
2.37 frystyk 389: TTYPrint(TDEST, "MIMEParser.. Methods allowed: %d\n",
2.18 frystyk 390: anchor->methods);
391: state = JUNK_LINE;
2.1 timbl 392: break;
2.18 frystyk 393:
394: case AUTHENTICATE:
395: if ((value = HTNextField(&ptr)) != NULL) {
396: StrAllocCopy(request->WWWAAScheme, value);
2.20 frystyk 397:
398: /* The parsing is done in HTSSUtils.c for the moment */
399: if (*ptr) StrAllocCopy(request->WWWAARealm, ptr);
2.1 timbl 400: }
2.18 frystyk 401: state = JUNK_LINE;
402: break;
403:
2.32 frystyk 404: case CONNECTION:
405: if ((value = HTNextField(&ptr)) != NULL) {
406: if (!strcasecomp(value, "keep-alive")) {
407: if (STREAM_TRACE)
2.43 frystyk 408: TTYPrint(TDEST,"MIMEParser.. Persistent Connection\n");
2.32 frystyk 409: HTDNS_setSocket(me->net->dns, me->net->sockfd);
410: }
411: }
412: state = JUNK_LINE;
413: break;
414:
2.18 frystyk 415: case CONTENT_ENCODING:
416: if ((value = HTNextField(&ptr)) != NULL) {
417: char *lc = value;
2.20 frystyk 418: while ((*lc = TOLOWER(*lc))) lc++;
2.18 frystyk 419: anchor->content_encoding = HTAtom_for(value);
420: }
421: state = JUNK_LINE;
422: break;
423:
2.21 frystyk 424: case CONTENT_LANGUAGE: /* @@@ SHOULD BE A LIST @@@ */
425: if ((value = HTNextField(&ptr)) != NULL) {
426: char *lc = value;
427: while ((*lc = TOLOWER(*lc))) lc++;
428: anchor->content_language = HTAtom_for(value);
429: }
430: state = JUNK_LINE;
2.18 frystyk 431: break;
432:
433: case CONTENT_LENGTH:
434: if ((value = HTNextField(&ptr)) != NULL)
435: anchor->content_length = atol(value);
436: state = JUNK_LINE;
437: break;
438:
439: case CONTENT_TRANSFER_ENCODING:
440: if ((value = HTNextField(&ptr)) != NULL) {
441: char *lc = value;
2.20 frystyk 442: while ((*lc = TOLOWER(*lc))) lc++;
2.18 frystyk 443: anchor->cte = HTAtom_for(value);
444: }
445: state = JUNK_LINE;
446: break;
447:
448: case CONTENT_TYPE:
449: if ((value = HTNextField(&ptr)) != NULL) {
450: char *lc = value;
451: while ((*lc = TOLOWER(*lc))) lc++;
452: anchor->content_type = HTAtom_for(value);
2.38 frystyk 453: while ((value = HTNextField(&ptr)) != NULL) {
2.20 frystyk 454: if (!strcasecomp(value, "charset")) {
455: if ((value = HTNextField(&ptr)) != NULL) {
456: lc = value;
457: while ((*lc = TOLOWER(*lc))) lc++;
458: anchor->charset = HTAtom_for(value);
459: }
2.38 frystyk 460: } else if (!strcasecomp(value, "level")) {
2.20 frystyk 461: if ((value = HTNextField(&ptr)) != NULL) {
462: lc = value;
463: while ((*lc = TOLOWER(*lc))) lc++;
464: anchor->level = HTAtom_for(value);
465: }
2.38 frystyk 466: } else if (!strcasecomp(value, "boundary")) {
467: if ((value = HTNextField(&ptr)) != NULL) {
468: StrAllocCopy(request->boundary, value);
469: }
2.20 frystyk 470: }
471: }
2.1 timbl 472: }
2.20 frystyk 473: state = JUNK_LINE;
2.18 frystyk 474: break;
475:
2.23 frystyk 476: case MIME_DATE:
2.18 frystyk 477: anchor->date = HTParseTime(ptr);
478: state = JUNK_LINE;
479: break;
480:
481: case DERIVED_FROM:
482: if ((value = HTNextField(&ptr)) != NULL)
483: StrAllocCopy(anchor->derived_from, value);
484: state = JUNK_LINE;
485: break;
486:
487: case EXPIRES:
488: anchor->expires = HTParseTime(ptr);
489: state = JUNK_LINE;
490: break;
491:
492: case LAST_MODIFIED:
493: anchor->last_modified = HTParseTime(ptr);
494: state = JUNK_LINE;
495: break;
496:
497: case LINK:
2.20 frystyk 498: state = UNKNOWN; /* @@@@@@@@@@@ */
2.18 frystyk 499: break;
500:
501: case LOCATION:
2.46 frystyk 502: request->redirectionAnchor = HTAnchor_findAddress(HTStrip(ptr));
2.18 frystyk 503: state = JUNK_LINE;
504: break;
505:
506: case PUBLIC_METHODS:
2.20 frystyk 507: state = UNKNOWN; /* @@@@@@@@@@@ */
2.18 frystyk 508: break;
509:
510: case RETRY_AFTER:
2.19 frystyk 511: request->retry_after = HTParseTime(ptr);
512: state = JUNK_LINE;
2.18 frystyk 513: break;
514:
515: case TITLE: /* Can't reuse buffer as HTML version might differ */
516: if ((value = HTNextField(&ptr)) != NULL)
517: StrAllocCopy(anchor->title, value);
518: state = JUNK_LINE;
519: break;
520:
521: case URI_HEADER:
522: state = LOCATION; /* @@@ Need extended parsing */
523: break;
524:
525: case VERSION:
526: if ((value = HTNextField(&ptr)) != NULL)
527: StrAllocCopy(anchor->version, value);
528: state = JUNK_LINE;
529: break;
530:
531: case UNKNOWN:
2.40 frystyk 532: {
2.36 frystyk 533: HTList * list;
534: HTParserCallback *cbf;
535: int status;
536: BOOL override;
537: if (STREAM_TRACE)
2.38 frystyk 538: TTYPrint(TDEST,"MIMEParser.. Unknown `%s\'\n", header);
2.36 frystyk 539: if ((list = HTRequest_parser(request, &override)) &&
2.40 frystyk 540: (cbf = HTParser_find(list, header)) &&
541: (status = (*cbf)(request, header) != HT_OK)) {
2.36 frystyk 542: return status;
543: } else if (!override &&
544: (list = HTHeader_parser()) &&
2.40 frystyk 545: (cbf = HTParser_find(list, header)) &&
546: (status = (*cbf)(request, header) != HT_OK)) {
2.36 frystyk 547: return status;
548: }
549: }
2.18 frystyk 550:
551: case JUNK_LINE:
552: while (*ptr) ptr++;
553: state = BEGINNING_OF_LINE;
554: break;
2.1 timbl 555: }
2.18 frystyk 556: }
2.27 frystyk 557:
2.43 frystyk 558: anchor->header_parsed = YES;
2.47 ! frystyk 559: me->transparent = YES; /* Pump rest of data right through */
! 560:
! 561: #if 0
! 562: /* If we're a server then stop here */
! 563: if (request->server_net) {
! 564: return HTMethod_hasEntity(request->method) ? HT_PAUSE : HT_LOADED;
! 565: }
! 566: #endif
! 567: if (request->method == METHOD_HEAD) return HT_LOADED;
2.43 frystyk 568:
2.35 frystyk 569: /* News server almost never send content type or content length */
570: if (anchor->content_type != WWW_UNKNOWN || me->nntp) {
2.18 frystyk 571: if (STREAM_TRACE)
2.37 frystyk 572: TTYPrint(TDEST, "MIMEParser.. Convert %s to %s\n",
2.30 frystyk 573: HTAtom_name(anchor->content_type),
574: HTAtom_name(me->target_format));
575: if ((me->target=HTStreamStack(anchor->content_type, me->target_format,
576: me->target, request, YES)) == NULL) {
577: if (STREAM_TRACE)
2.37 frystyk 578: TTYPrint(TDEST, "MIMEParser.. Can't convert media type\n");
2.47 ! frystyk 579: me->target = HTErrorStream();
2.30 frystyk 580: }
2.18 frystyk 581: }
2.27 frystyk 582: return HT_OK;
2.1 timbl 583: }
584:
585:
2.18 frystyk 586: /*
587: ** Header is terminated by CRCR, LFLF, CRLFLF, CRLFCRLF
588: ** Folding is either of CF LWS, LF LWS, CRLF LWS
589: */
2.36 frystyk 590: PRIVATE int HTMIME_put_block (HTStream * me, CONST char * b, int l)
2.18 frystyk 591: {
592: while (!me->transparent && l-- > 0) {
593: if (me->EOLstate == EOL_FCR) {
2.27 frystyk 594: if (*b == CR) { /* End of header */
2.32 frystyk 595: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 596: HTNet_setBytesRead(me->net, l);
2.27 frystyk 597: if (status != HT_OK)
598: return status;
599: } else if (*b == LF) /* CRLF */
2.18 frystyk 600: me->EOLstate = EOL_FLF;
601: else if (WHITE(*b)) { /* Folding: CR SP */
602: me->EOLstate = EOL_BEGIN;
2.44 frystyk 603: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 604: } else { /* New line */
605: me->EOLstate = EOL_BEGIN;
2.44 frystyk 606: HTChunk_putc(me->buffer, '\0');
607: HTChunk_putc(me->buffer, *b);
2.18 frystyk 608: }
609: } else if (me->EOLstate == EOL_FLF) {
610: if (*b == CR) /* LF CR or CR LF CR */
611: me->EOLstate = EOL_SCR;
2.27 frystyk 612: else if (*b == LF) { /* End of header */
2.32 frystyk 613: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 614: HTNet_setBytesRead(me->net, l);
2.27 frystyk 615: if (status != HT_OK)
616: return status;
617: } else if (WHITE(*b)) { /* Folding: LF SP or CR LF SP */
2.18 frystyk 618: me->EOLstate = EOL_BEGIN;
2.44 frystyk 619: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 620: } else { /* New line */
621: me->EOLstate = EOL_BEGIN;
2.44 frystyk 622: HTChunk_putc(me->buffer, '\0');
623: HTChunk_putc(me->buffer, *b);
2.18 frystyk 624: }
625: } else if (me->EOLstate == EOL_SCR) {
2.27 frystyk 626: if (*b==CR || *b==LF) { /* End of header */
2.32 frystyk 627: int status = parseheader(me, me->request, me->anchor);
2.46 frystyk 628: HTNet_setBytesRead(me->net, l);
2.27 frystyk 629: if (status != HT_OK)
630: return status;
631: } else if (WHITE(*b)) { /* Folding: LF CR SP or CR LF CR SP */
2.18 frystyk 632: me->EOLstate = EOL_BEGIN;
2.44 frystyk 633: HTChunk_putc(me->buffer, ' ');
2.18 frystyk 634: } else { /* New line */
635: me->EOLstate = EOL_BEGIN;
2.44 frystyk 636: HTChunk_putc(me->buffer, '\0');
637: HTChunk_putc(me->buffer, *b);
2.18 frystyk 638: }
639: } else if (*b == CR) {
640: me->EOLstate = EOL_FCR;
641: } else if (*b == LF) {
642: me->EOLstate = EOL_FLF; /* Line found */
643: } else
2.44 frystyk 644: HTChunk_putc(me->buffer, *b);
2.18 frystyk 645: b++;
646: }
2.32 frystyk 647:
648: /*
649: ** Put the rest down the stream without touching the data but make sure
650: ** that we get the correct content length of data
651: */
2.47 ! frystyk 652: if (l < 0) return HT_OK;
! 653: if (me->target) {
! 654: long cl = me->anchor->content_length;
! 655: int status = (*me->target->isa->put_block)(me->target, b, l);
! 656: if (status == HT_OK)
! 657: /* Check if CL at all - thanks to jwei@hal.com (John Wei) */
! 658: return (me->request->method == METHOD_HEAD ||
! 659: (cl >= 0 && HTNet_bytesRead(me->net) >= cl)) ?
! 660: HT_LOADED : HT_OK;
2.46 frystyk 661: else
2.47 ! frystyk 662: return status;
! 663: } else if (me->anchor->header_parsed)
! 664: return HT_LOADED;
! 665: return HT_WOULD_BLOCK;
2.18 frystyk 666: }
667:
668:
669: /* Character handling
670: ** ------------------
671: */
2.36 frystyk 672: PRIVATE int HTMIME_put_character (HTStream * me, char c)
2.18 frystyk 673: {
674: return HTMIME_put_block(me, &c, 1);
675: }
676:
2.1 timbl 677:
678: /* String handling
679: ** ---------------
680: */
2.36 frystyk 681: PRIVATE int HTMIME_put_string (HTStream * me, CONST char * s)
2.1 timbl 682: {
2.18 frystyk 683: return HTMIME_put_block(me, s, (int) strlen(s));
2.1 timbl 684: }
685:
686:
2.18 frystyk 687: /* Flush an stream object
688: ** ---------------------
2.1 timbl 689: */
2.36 frystyk 690: PRIVATE int HTMIME_flush (HTStream * me)
2.1 timbl 691: {
2.47 ! frystyk 692: return me->target ? (*me->target->isa->flush)(me->target) : HT_OK;
2.1 timbl 693: }
694:
2.18 frystyk 695: /* Free a stream object
696: ** --------------------
2.1 timbl 697: */
2.36 frystyk 698: PRIVATE int HTMIME_free (HTStream * me)
2.1 timbl 699: {
2.18 frystyk 700: int status = HT_OK;
2.25 frystyk 701: if (me->target) {
702: if ((status = (*me->target->isa->_free)(me->target))==HT_WOULD_BLOCK)
703: return HT_WOULD_BLOCK;
704: }
2.26 frystyk 705: if (PROT_TRACE)
2.37 frystyk 706: TTYPrint(TDEST, "MIME........ FREEING....\n");
2.44 frystyk 707: HTChunk_delete(me->buffer);
2.1 timbl 708: free(me);
2.18 frystyk 709: return status;
2.1 timbl 710: }
711:
712: /* End writing
713: */
2.38 frystyk 714: PRIVATE int HTMIME_abort (HTStream * me, HTList * e)
2.1 timbl 715: {
2.18 frystyk 716: int status = HT_ERROR;
2.41 frystyk 717: if (me->target) status = (*me->target->isa->abort)(me->target, e);
2.26 frystyk 718: if (PROT_TRACE)
2.37 frystyk 719: TTYPrint(TDEST, "MIME........ ABORTING...\n");
2.44 frystyk 720: HTChunk_delete(me->buffer);
2.6 timbl 721: free(me);
2.18 frystyk 722: return status;
2.1 timbl 723: }
724:
725:
726:
727: /* Structured Object Class
728: ** -----------------------
729: */
2.6 timbl 730: PRIVATE CONST HTStreamClass HTMIME =
2.1 timbl 731: {
732: "MIMEParser",
2.18 frystyk 733: HTMIME_flush,
2.1 timbl 734: HTMIME_free,
2.6 timbl 735: HTMIME_abort,
736: HTMIME_put_character,
737: HTMIME_put_string,
2.18 frystyk 738: HTMIME_put_block
2.1 timbl 739: };
740:
741:
742: /* Subclass-specific Methods
743: ** -------------------------
744: */
2.36 frystyk 745: PUBLIC HTStream* HTMIMEConvert (HTRequest * request,
746: void * param,
747: HTFormat input_format,
748: HTFormat output_format,
749: HTStream * output_stream)
2.1 timbl 750: {
751: HTStream* me;
2.18 frystyk 752: if ((me=(HTStream *) calloc(1, sizeof(* me))) == NULL)
753: outofmem(__FILE__, "HTMIMEConvert");
2.1 timbl 754: me->isa = &HTMIME;
2.18 frystyk 755: me->request = request;
2.32 frystyk 756: me->anchor = request->anchor;
757: me->net = request->net;
2.18 frystyk 758: me->target = output_stream;
759: me->target_format = output_format;
2.44 frystyk 760: me->buffer = HTChunk_new(512);
2.18 frystyk 761: me->EOLstate = EOL_BEGIN;
2.1 timbl 762: return me;
763: }
2.32 frystyk 764:
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