Debian Codegraph @

WWW/Library/Implementation/HTMIME.c

raw
1 /*
2 * $LynxId: HTMIME.c,v 1.105 2025/01/08 00:23:14 tom Exp $
3 *
4 * MIME Message Parse HTMIME.c
5 * ==================
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
15 *
16 */
17
18 #define HTSTREAM_INTERNAL 1
19
20 #include <HTUtils.h>
21 #include <HTMIME.h> /* Implemented here */
22 #include <HTTP.h> /* for redirecting_url */
23 #include <HTAlert.h>
24 #include <HTFile.h>
25 #include <HTCJK.h>
26 #include <UCMap.h>
27 #include <UCDefs.h>
28 #include <UCAux.h>
29
30 #include <LYCookie.h>
31 #include <LYCharSets.h>
32 #include <LYCharUtils.h>
33 #include <LYStrings.h>
34 #include <LYUtils.h>
35 #include <LYGlobalDefs.h>
36 #include <LYLeaks.h>
37
38 /* MIME Object
39 * -----------
40 */
41
42 typedef enum {
43 MIME_TRANSPARENT, /* put straight through to target ASAP! */
44 /* states for "Transfer-Encoding: chunked" */
45 MIME_CHUNKED,
46 mcCHUNKED_COUNT_DIGIT,
47 mcCHUNKED_COUNT_CR,
48 mcCHUNKED_COUNT_LF,
49 mcCHUNKED_EXTENSION,
50 mcCHUNKED_DATA,
51 mcCHUNKED_DATA_CR,
52 mcCHUNKED_DATA_LF,
53 /* character state-machine */
54 miBEGINNING_OF_LINE, /* first character and not a continuation */
55 miA,
56 miACCEPT_RANGES,
57 miAGE,
58 miAL,
59 miALLOW,
60 miALTERNATES,
61 miC,
62 miCACHE_CONTROL,
63 miCO,
64 miCOOKIE,
65 miCON,
66 miCONNECTION,
67 miCONTENT_,
68 miCONTENT_BASE,
69 miCONTENT_DISPOSITION,
70 miCONTENT_ENCODING,
71 miCONTENT_FEATURES,
72 miCONTENT_L,
73 miCONTENT_LANGUAGE,
74 miCONTENT_LENGTH,
75 miCONTENT_LOCATION,
76 miCONTENT_MD5,
77 miCONTENT_RANGE,
78 miCONTENT_T,
79 miCONTENT_TRANSFER_ENCODING,
80 miCONTENT_TYPE,
81 miDATE,
82 miE,
83 miETAG,
84 miEXPIRES,
85 miKEEP_ALIVE,
86 miL,
87 miLAST_MODIFIED,
88 miLINK,
89 miLOCATION,
90 miP,
91 miPR,
92 miPRAGMA,
93 miPROXY_AUTHENTICATE,
94 miPUBLIC,
95 miR,
96 miRE,
97 miREFRESH,
98 miRETRY_AFTER,
99 miS,
100 miSAFE,
101 miSE,
102 miSERVER,
103 miSET_COOKIE,
104 miSET_COOKIE1,
105 miSET_COOKIE2,
106 miT,
107 miTITLE,
108 miTRANSFER_ENCODING,
109 miU,
110 miUPGRADE,
111 miURI,
112 miV,
113 miVARY,
114 miVIA,
115 miW,
116 miWARNING,
117 miWWW_AUTHENTICATE,
118 miSKIP_GET_VALUE, /* Skip space then get value */
119 miGET_VALUE, /* Get value till white space */
120 miJUNK_LINE, /* Ignore the rest of this folded line */
121 miNEWLINE, /* Just found a LF .. maybe continuation */
122 miCHECK, /* check against check_pointer */
123 MIME_NET_ASCII, /* Translate from net ascii */
124 MIME_IGNORE /* Ignore entire file */
125 /* TRANSPARENT and IGNORE are defined as stg else in _WINDOWS */
126 } MIME_state;
127
128 #define VALUE_SIZE 5120 /* @@@@@@@ Arbitrary? */
129 struct _HTStream {
130 const HTStreamClass *isa;
131
132 BOOL net_ascii; /* Is input net ascii? */
133 MIME_state state; /* current state */
134 MIME_state if_ok; /* got this state if match */
135 MIME_state field; /* remember which field */
136 MIME_state fold_state; /* state on a fold */
137 BOOL head_only; /* only parsing header */
138 BOOL pickup_redirection; /* parsing for location */
139 BOOL no_streamstack; /* use sink directly */
140 const char *check_pointer; /* checking input */
141
142 char *value_pointer; /* storing values */
143 char value[VALUE_SIZE];
144
145 HTParentAnchor *anchor; /* Given on creation */
146 HTStream *sink; /* Given on creation */
147
148 char *boundary; /* For multipart */
149 char *set_cookie; /* Set-Cookie */
150 char *set_cookie2; /* Set-Cookie2 */
151 char *location; /* Location */
152
153 char *refresh_url; /* "Refresh:" URL */
154
155 HTFormat c_t_encoding; /* Content-Transfer-Encoding */
156 char *compression_encoding;
157
158 BOOL chunked_encoding; /* Transfer-Encoding: chunked */
159 long chunked_size; /* ...counter for "chunked" */
160
161 HTFormat format; /* Content-Type */
162 HTStream *target; /* While writing out */
163 HTStreamClass targetClass;
164
165 HTAtom *targetRep; /* Converting into? */
166 };
167
168 /*
169 * This function is for trimming off any paired
170 * open- and close-double quotes from header values.
171 * It does not parse the string for embedded quotes,
172 * and will not modify the string unless both the
173 * first and last characters are double-quotes. - FM
174 */
175 void HTMIME_TrimDoubleQuotes(char *value)
176 {
177 size_t i;
178 char *cp = value;
179
180 if (isEmpty(cp) || *cp != '"')
181 return;
182
183 i = strlen(cp);
184 if (cp[(i - 1)] != '"')
185 return;
186 else
187 cp[(i - 1)] = '\0';
188
189 for (i = 0; value[i]; i++)
190 value[i] = cp[(i + 1)];
191 }
192
193 /*
194 * Check if the token from "Content-Encoding" corresponds to a compression
195 * type.
196 */
197 static BOOL content_is_compressed(HTStream *me)
198 {
199 char *encoding = me->anchor->content_encoding;
200 BOOL result = (BOOL) (HTEncodingToCompressType(encoding) != cftNone);
201
202 CTRACE((tfp, "content is%s compressed\n", result ? "" : " NOT"));
203 return result;
204 }
205
206 /*
207 * Strip quotes from a refresh-URL.
208 */
209 static void dequote(char *url)
210 {
211 size_t len;
212
213 len = strlen(url);
214 if (*url == '\'' && len > 1 && url[len - 1] == url[0]) {
215 url[len - 1] = '\0';
216 while ((url[0] = url[1]) != '\0') {
217 ++url;
218 }
219 }
220 }
221
222 /*
223 * Strip off any compression-suffix from the address and check if the result
224 * looks like one of the presentable suffixes. If so, return the corresponding
225 * MIME type.
226 */
227 static const char *UncompressedContentType(HTStream *me, CompressFileType method)
228 {
229 const char *result = NULL;
230 char *address = me->anchor->address;
231 const char *expected = HTCompressTypeToSuffix(method);
232 const char *actual = strrchr(address, '.');
233
234 /*
235 * We have to ensure the suffix is consistent, to use HTFileFormat().
236 */
237 if (actual != NULL && !strcasecomp(actual, expected)) {
238 HTFormat format;
239 HTAtom *pencoding = NULL;
240 const char *description = NULL;
241
242 format = HTFileFormat(address, &pencoding, &description);
243 result = HTAtom_name(format);
244 }
245
246 return result;
247 }
248
249 static int pumpData(HTStream *me)
250 {
251 CompressFileType method;
252 const char *new_encoding;
253 const char *new_content;
254
255 CTRACE((tfp, "Begin pumpData\n"));
256 /*
257 * If the content-type says it is compressed, and there is no
258 * content-encoding, check further and see if the address (omitting the
259 * suffix for a compressed type) looks like a type we can present. If so,
260 * rearrange things so we'll present the StreamStack code with the
261 * presentable type, already marked as compressed.
262 */
263 CTRACE((tfp, "...address{%s}\n", me->anchor->address));
264 method = HTContentTypeToCompressType(me->anchor->content_type_params);
265 if (isEmpty(me->anchor->content_encoding))
266 me->anchor->no_content_encoding = TRUE;
267 if ((method != cftNone)
268 && isEmpty(me->anchor->content_encoding)
269 && (new_content = UncompressedContentType(me, method)) != NULL) {
270
271 new_encoding = HTCompressTypeToEncoding(method);
272 CTRACE((tfp, "reinterpreting as content-type:%s, encoding:%s\n",
273 new_content, new_encoding));
274
275 StrAllocCopy(me->anchor->content_encoding, new_encoding);
276 FREE(me->compression_encoding);
277 StrAllocCopy(me->compression_encoding, new_encoding);
278
279 LYStrNCpy(me->value, new_content, VALUE_SIZE - 1);
280 StrAllocCopy(me->anchor->content_type_params, me->value);
281 me->format = HTAtom_for(me->value);
282 }
283
284 if (StrChr(HTAtom_name(me->format), ';') != NULL) {
285 char *cp = NULL, *cp1, *cp2, *cp3 = NULL, *cp4;
286
287 CTRACE((tfp, "HTMIME: Extended MIME Content-Type is %s\n",
288 HTAtom_name(me->format)));
289 StrAllocCopy(cp, HTAtom_name(me->format));
290 /*
291 * Note that the Content-Type value was converted
292 * to lower case when we loaded into me->format,
293 * but there may have been a mixed or upper-case
294 * atom, so we'll force lower-casing again. We
295 * also stripped spaces and double-quotes, but
296 * we'll make sure they're still gone from any
297 * charset parameter we check. - FM
298 */
299 LYLowerCase(cp);
300 if ((cp1 = StrChr(cp, ';')) != NULL) {
301 BOOL chartrans_ok = NO;
302
303 if ((cp2 = strstr(cp1, "charset")) != NULL) {
304 int chndl;
305
306 cp2 += 7;
307 while (*cp2 == ' ' || *cp2 == '=' || *cp2 == '"')
308 cp2++;
309 StrAllocCopy(cp3, cp2); /* copy to mutilate more */
310 for (cp4 = cp3; (*cp4 != '\0' && *cp4 != '"' &&
311 *cp4 != ';' && *cp4 != ':' &&
312 !WHITE(*cp4)); cp4++) ; /* do nothing */
313 *cp4 = '\0';
314 cp4 = cp3;
315 chndl = UCGetLYhndl_byMIME(cp3);
316 if (UCCanTranslateFromTo(chndl,
317 current_char_set)) {
318 chartrans_ok = YES;
319 *cp1 = '\0';
320 me->format = HTAtom_for(cp);
321 StrAllocCopy(me->anchor->charset, cp4);
322 HTAnchor_setUCInfoStage(me->anchor, chndl,
323 UCT_STAGE_MIME,
324 UCT_SETBY_MIME);
325 } else if (chndl < 0) { /* got something but we don't
326 recognize it */
327 chndl = UCLYhndl_for_unrec;
328 if (chndl < 0)
329 /*
330 * UCLYhndl_for_unrec not defined :-( fallback to
331 * UCLYhndl_for_unspec which always valid.
332 */
333 chndl = UCLYhndl_for_unspec; /* always >= 0 */
334 if (UCCanTranslateFromTo(chndl,
335 current_char_set)) {
336 chartrans_ok = YES;
337 *cp1 = '\0';
338 me->format = HTAtom_for(cp);
339 HTAnchor_setUCInfoStage(me->anchor, chndl,
340 UCT_STAGE_MIME,
341 UCT_SETBY_DEFAULT);
342 }
343 } else {
344 /*
345 * Something like 'big5' - we cannot translate it, but
346 * the user may still be able to navigate the links.
347 */
348 *cp1 = '\0';
349 me->format = HTAtom_for(cp);
350 StrAllocCopy(me->anchor->charset, cp4);
351 HTAnchor_setUCInfoStage(me->anchor, chndl,
352 UCT_STAGE_MIME,
353 UCT_SETBY_MIME);
354 }
355 if (chartrans_ok) {
356 LYUCcharset *p_in =
357 HTAnchor_getUCInfoStage(me->anchor,
358 UCT_STAGE_MIME);
359 LYUCcharset *p_out =
360 HTAnchor_setUCInfoStage(me->anchor,
361 current_char_set,
362 UCT_STAGE_HTEXT,
363 UCT_SETBY_DEFAULT);
364
365 if (!p_out)
366 /*
367 * Try again.
368 */
369 p_out =
370 HTAnchor_getUCInfoStage(me->anchor,
371 UCT_STAGE_HTEXT);
372
373 if (!strcmp(p_in->MIMEname,
374 "x-transparent")) {
375 HTPassEightBitRaw = TRUE;
376 HTAnchor_setUCInfoStage(me->anchor,
377 HTAnchor_getUCLYhndl(me->anchor,
378 UCT_STAGE_HTEXT),
379 UCT_STAGE_MIME,
380 UCT_SETBY_DEFAULT);
381 }
382 if (!strcmp(p_out->MIMEname,
383 "x-transparent")) {
384 HTPassEightBitRaw = TRUE;
385 HTAnchor_setUCInfoStage(me->anchor,
386 HTAnchor_getUCLYhndl(me->anchor,
387 UCT_STAGE_MIME),
388 UCT_STAGE_HTEXT,
389 UCT_SETBY_DEFAULT);
390 }
391 if ((p_in->enc != UCT_ENC_CJK)
392 #ifdef USE_JAPANESEUTF8_SUPPORT
393 && ((p_in->enc != UCT_ENC_UTF8)
394 || (p_out->enc != UCT_ENC_CJK))
395 #endif
396 ) {
397 HTCJK = NOCJK;
398 if (!(p_in->codepoints &
399 UCT_CP_SUBSETOF_LAT1) &&
400 chndl == current_char_set) {
401 HTPassEightBitRaw = TRUE;
402 }
403 } else if (p_out->enc == UCT_ENC_CJK) {
404 Set_HTCJK(p_in->MIMEname, p_out->MIMEname);
405 }
406 } else {
407 /*
408 * Cannot translate. If according to some heuristic the
409 * given charset and the current display character both are
410 * likely to be like ISO-8859 in structure, pretend we have
411 * some kind of match.
412 */
413 BOOL given_is_8859 =
414 (BOOL) (!StrNCmp(cp4, "iso-8859-", 9) &&
415 isdigit(UCH(cp4[9])));
416 BOOL given_is_8859like =
417 (BOOL) (given_is_8859 ||
418 !StrNCmp(cp4, "windows-", 8) ||
419 !StrNCmp(cp4, "cp12", 4) ||
420 !StrNCmp(cp4, "cp-12", 5));
421 BOOL given_and_display_8859like =
422 (BOOL) (given_is_8859like &&
423 (strstr(LYchar_set_names[current_char_set],
424 "ISO-8859") ||
425 strstr(LYchar_set_names[current_char_set],
426 "windows-")));
427
428 if (given_and_display_8859like) {
429 *cp1 = '\0';
430 me->format = HTAtom_for(cp);
431 }
432 if (given_is_8859) {
433 cp1 = &cp4[10];
434 while (*cp1 &&
435 isdigit(UCH(*cp1)))
436 cp1++;
437 *cp1 = '\0';
438 }
439 if (given_and_display_8859like) {
440 StrAllocCopy(me->anchor->charset, cp4);
441 HTPassEightBitRaw = TRUE;
442 }
443 HTAlert(*cp4 ? cp4 : me->anchor->charset);
444 }
445 FREE(cp3);
446 } else {
447 /*
448 * No charset parameter is present. Ignore all other
449 * parameters, as we do when charset is present. - FM
450 */
451 *cp1 = '\0';
452 me->format = HTAtom_for(cp);
453 }
454 }
455 FREE(cp);
456 }
457 /*
458 * If we have an Expires header and haven't already set the no_cache
459 * element for the anchor, check if we should set it based on that header.
460 * - FM
461 */
462 if (me->anchor->no_cache == FALSE &&
463 me->anchor->expires != NULL) {
464 if (!strcmp(me->anchor->expires, "0")) {
465 /*
466 * The value is zero, which we treat as an absolute no-cache
467 * directive. - FM
468 */
469 me->anchor->no_cache = TRUE;
470 } else if (me->anchor->date != NULL) {
471 /*
472 * We have a Date header, so check if the value is less than or
473 * equal to that. - FM
474 */
475 if (LYmktime(me->anchor->expires, TRUE) <=
476 LYmktime(me->anchor->date, TRUE)) {
477 me->anchor->no_cache = TRUE;
478 }
479 } else if (LYmktime(me->anchor->expires, FALSE) == 0) {
480 /*
481 * We don't have a Date header, and the value is in past for us. -
482 * FM
483 */
484 me->anchor->no_cache = TRUE;
485 }
486 }
487 StrAllocCopy(me->anchor->content_type,
488 HTAtom_name(me->format));
489
490 if (me->set_cookie != NULL || me->set_cookie2 != NULL) {
491 LYSetCookie(me->set_cookie,
492 me->set_cookie2,
493 me->anchor->address);
494 FREE(me->set_cookie);
495 FREE(me->set_cookie2);
496 }
497 if (me->pickup_redirection) {
498 if (me->location && *me->location) {
499 redirecting_url = me->location;
500 me->location = NULL;
501 if (me->targetRep != WWW_DEBUG || me->sink)
502 me->head_only = YES;
503
504 } else {
505 permanent_redirection = FALSE;
506 if (me->location) {
507 CTRACE((tfp, "HTTP: 'Location:' is zero-length!\n"));
508 HTAlert(REDIRECTION_WITH_BAD_LOCATION);
509 }
510 CTRACE((tfp, "HTTP: Failed to pick up location.\n"));
511 if (me->location) {
512 FREE(me->location);
513 } else {
514 HTAlert(REDIRECTION_WITH_NO_LOCATION);
515 }
516 }
517 }
518 CTRACE((tfp, "...pumpData finished reading header\n"));
519 if (me->head_only) {
520 /* We are done! - kw */
521 me->state = MIME_IGNORE;
522 } else {
523
524 if (me->no_streamstack) {
525 me->target = me->sink;
526 } else {
527 if (!me->compression_encoding) {
528 CTRACE((tfp,
529 "HTMIME: MIME Content-Type is '%s', converting to '%s'\n",
530 HTAtom_name(me->format), HTAtom_name(me->targetRep)));
531 } else {
532 /*
533 * Change the format to that for "www/compressed" and set up a
534 * stream to deal with it. - FM
535 */
536 CTRACE((tfp, "HTMIME: MIME Content-Type is '%s',\n",
537 HTAtom_name(me->format)));
538 me->format = HTAtom_for("www/compressed");
539 CTRACE((tfp, " Treating as '%s'. Converting to '%s'\n",
540 HTAtom_name(me->format), HTAtom_name(me->targetRep)));
541 FREE(me->compression_encoding);
542 }
543 me->target = HTStreamStack(me->format, me->targetRep,
544 me->sink, me->anchor);
545 if (!me->target) {
546 CTRACE((tfp, "HTMIME: Can't translate! ** \n"));
547 me->target = me->sink; /* Cheat */
548 }
549 }
550 if (me->target) {
551 me->targetClass = *me->target->isa;
552 /*
553 * Pump rest of data right through, according to the transfer encoding.
554 */
555 me->state = (me->chunked_encoding
556 ? MIME_CHUNKED
557 : MIME_TRANSPARENT);
558 } else {
559 me->state = MIME_IGNORE; /* What else to do? */
560 }
561 if (me->refresh_url != NULL && !content_is_compressed(me)) {
562 char *url = NULL;
563 char *num = NULL;
564 char *txt = NULL;
565 const char *base = ""; /* FIXME: refresh_url may be relative to doc */
566
567 LYParseRefreshURL(me->refresh_url, &num, &url);
568 if (url != NULL && me->format == WWW_HTML) {
569 CTRACE((tfp,
570 "Formatting refresh-url as first line of result\n"));
571 StrAllocCopy(txt, gettext("Refresh: "));
572 HTSprintf(&txt, LY_MSG("%s seconds "), num);
573 dequote(url);
574 HTSprintf(&txt, "<a href=\"%s%s\">%s</a><br>", base, url, url);
575 CTRACE((tfp, "URL %s%s\n", base, url));
576 (me->isa->put_string) (me, txt);
577 free(txt);
578 }
579 FREE(num);
580 FREE(url);
581 }
582 }
583 CTRACE((tfp, "...end of pumpData, copied %"
584 PRI_off_t " vs %"
585 PRI_off_t "\n",
586 CAST_off_t (me->anchor->actual_length),
587 CAST_off_t (me->anchor->content_length)));
588 me->anchor->actual_length = 0;
589 return HT_OK;
590 }
591
592 static int dispatchField(HTStream *me)
593 {
594 int i, j;
595 char *cp;
596
597 *me->value_pointer = '\0';
598
599 cp = me->value_pointer;
600 while ((cp > me->value) && *(--cp) == ' ') /* S/390 -- gil -- 0146 */
601 /*
602 * Trim trailing spaces.
603 */
604 *cp = '\0';
605
606 switch (me->field) {
607 case miACCEPT_RANGES:
608 HTMIME_TrimDoubleQuotes(me->value);
609 CTRACE((tfp, "HTMIME: PICKED UP Accept-Ranges: '%s'\n",
610 me->value));
611 break;
612 case miAGE:
613 HTMIME_TrimDoubleQuotes(me->value);
614 CTRACE((tfp, "HTMIME: PICKED UP Age: '%s'\n",
615 me->value));
616 break;
617 case miALLOW:
618 HTMIME_TrimDoubleQuotes(me->value);
619 CTRACE((tfp, "HTMIME: PICKED UP Allow: '%s'\n",
620 me->value));
621 break;
622 case miALTERNATES:
623 HTMIME_TrimDoubleQuotes(me->value);
624 CTRACE((tfp, "HTMIME: PICKED UP Alternates: '%s'\n",
625 me->value));
626 break;
627 case miCACHE_CONTROL:
628 HTMIME_TrimDoubleQuotes(me->value);
629 CTRACE((tfp, "HTMIME: PICKED UP Cache-Control: '%s'\n",
630 me->value));
631 if (me->value[0] == '\0')
632 break;
633 /*
634 * Convert to lowercase and indicate in anchor. - FM
635 */
636 LYLowerCase(me->value);
637 StrAllocCopy(me->anchor->cache_control, me->value);
638 /*
639 * Check whether to set no_cache for the anchor. - FM
640 */
641 {
642 char *cp1, *cp0 = me->value;
643
644 while ((cp1 = strstr(cp0, "no-cache")) != NULL) {
645 cp1 += 8;
646 while (*cp1 != '\0' && WHITE(*cp1))
647 cp1++;
648 if (*cp1 == '\0' || *cp1 == ';') {
649 me->anchor->no_cache = TRUE;
650 break;
651 }
652 cp0 = cp1;
653 }
654 if (me->anchor->no_cache == TRUE)
655 break;
656 cp0 = me->value;
657 while ((cp1 = strstr(cp0, "max-age")) != NULL) {
658 cp1 += 7;
659 while (*cp1 != '\0' && WHITE(*cp1))
660 cp1++;
661 if (*cp1 == '=') {
662 cp1++;
663 while (*cp1 != '\0' && WHITE(*cp1))
664 cp1++;
665 if (isdigit(UCH(*cp1))) {
666 cp0 = cp1;
667 while (isdigit(UCH(*cp1)))
668 cp1++;
669 if (*cp0 == '0' && cp1 == (cp0 + 1)) {
670 me->anchor->no_cache = TRUE;
671 break;
672 }
673 }
674 }
675 cp0 = cp1;
676 }
677 }
678 break;
679 case miCOOKIE:
680 HTMIME_TrimDoubleQuotes(me->value);
681 CTRACE((tfp, "HTMIME: PICKED UP Cookie: '%s'\n",
682 me->value));
683 break;
684 case miCONNECTION:
685 HTMIME_TrimDoubleQuotes(me->value);
686 CTRACE((tfp, "HTMIME: PICKED UP Connection: '%s'\n",
687 me->value));
688 break;
689 case miCONTENT_BASE:
690 HTMIME_TrimDoubleQuotes(me->value);
691 CTRACE((tfp, "HTMIME: PICKED UP Content-Base: '%s'\n",
692 me->value));
693 if (me->value[0] == '\0')
694 break;
695 /*
696 * Indicate in anchor. - FM
697 */
698 StrAllocCopy(me->anchor->content_base, me->value);
699 break;
700 case miCONTENT_DISPOSITION:
701 HTMIME_TrimDoubleQuotes(me->value);
702 CTRACE((tfp, "HTMIME: PICKED UP Content-Disposition: '%s'\n",
703 me->value));
704 if (me->value[0] == '\0')
705 break;
706 /*
707 * Indicate in anchor. - FM
708 */
709 StrAllocCopy(me->anchor->content_disposition, me->value);
710 /*
711 * It's not clear yet from existing RFCs and IDs whether we should be
712 * looking for file;, attachment;, and/or inline; before the
713 * filename=value, so we'll just search for "filename" followed by '='
714 * and just hope we get the intended value. It is purely a suggested
715 * name, anyway. - FM
716 */
717 cp = me->anchor->content_disposition;
718 while (*cp != '\0' && strncasecomp(cp, "filename", 8))
719 cp++;
720 if (*cp == '\0')
721 break;
722 cp += 8;
723 while ((*cp != '\0') && (WHITE(*cp) || *cp == '='))
724 cp++;
725 if (*cp == '\0')
726 break;
727 while (*cp != '\0' && WHITE(*cp))
728 cp++;
729 if (*cp == '\0')
730 break;
731 StrAllocCopy(me->anchor->SugFname, cp);
732 if (*me->anchor->SugFname == '"') {
733 if ((cp = StrChr((me->anchor->SugFname + 1),
734 '"')) != NULL) {
735 *(cp + 1) = '\0';
736 HTMIME_TrimDoubleQuotes(me->anchor->SugFname);
737 } else {
738 FREE(me->anchor->SugFname);
739 break;
740 }
741 }
742 cp = me->anchor->SugFname;
743 while (*cp != '\0' && !WHITE(*cp))
744 cp++;
745 *cp = '\0';
746 if (*me->anchor->SugFname == '\0')
747 FREE(me->anchor->SugFname);
748 break;
749 case miCONTENT_ENCODING:
750 HTMIME_TrimDoubleQuotes(me->value);
751 CTRACE((tfp, "HTMIME: PICKED UP Content-Encoding: '%s'\n",
752 me->value));
753 if (me->value[0] == '\0' ||
754 !strcasecomp(me->value, "identity"))
755 break;
756 /*
757 * Convert to lowercase and indicate in anchor. - FM
758 */
759 LYLowerCase(me->value);
760 StrAllocCopy(me->anchor->content_encoding, me->value);
761 FREE(me->compression_encoding);
762 if (content_is_compressed(me)) {
763 /*
764 * Save it to use as a flag for setting up a "www/compressed"
765 * target. - FM
766 */
767 StrAllocCopy(me->compression_encoding, me->value);
768 } else {
769 /*
770 * Some server indicated "8bit", "7bit" or "binary"
771 * inappropriately. We'll ignore it. - FM
772 */
773 CTRACE((tfp, " Ignoring it!\n"));
774 }
775 break;
776 case miCONTENT_FEATURES:
777 HTMIME_TrimDoubleQuotes(me->value);
778 CTRACE((tfp, "HTMIME: PICKED UP Content-Features: '%s'\n",
779 me->value));
780 break;
781 case miCONTENT_LANGUAGE:
782 HTMIME_TrimDoubleQuotes(me->value);
783 CTRACE((tfp, "HTMIME: PICKED UP Content-Language: '%s'\n",
784 me->value));
785 if (me->value[0] == '\0')
786 break;
787 /*
788 * Convert to lowercase and indicate in anchor. - FM
789 */
790 LYLowerCase(me->value);
791 StrAllocCopy(me->anchor->content_language, me->value);
792 break;
793 case miCONTENT_LENGTH:
794 HTMIME_TrimDoubleQuotes(me->value);
795 CTRACE((tfp, "HTMIME: PICKED UP Content-Length: '%s'\n",
796 me->value));
797 if (me->value[0] == '\0')
798 break;
799 /*
800 * Convert to integer and indicate in anchor. - FM
801 */
802 me->anchor->content_length = LYatoll(me->value);
803 if (me->anchor->content_length < 0)
804 me->anchor->content_length = 0;
805 CTRACE((tfp, " Converted to integer: '%" PRI_off_t "'\n",
806 CAST_off_t (me->anchor->content_length)));
807 break;
808 case miCONTENT_LOCATION:
809 HTMIME_TrimDoubleQuotes(me->value);
810 CTRACE((tfp, "HTMIME: PICKED UP Content-Location: '%s'\n",
811 me->value));
812 if (me->value[0] == '\0')
813 break;
814 /*
815 * Indicate in anchor. - FM
816 */
817 StrAllocCopy(me->anchor->content_location, me->value);
818 break;
819 case miCONTENT_MD5:
820 HTMIME_TrimDoubleQuotes(me->value);
821 CTRACE((tfp, "HTMIME: PICKED UP Content-MD5: '%s'\n",
822 me->value));
823 if (me->value[0] == '\0')
824 break;
825 /*
826 * Indicate in anchor. - FM
827 */
828 StrAllocCopy(me->anchor->content_md5, me->value);
829 break;
830 case miCONTENT_RANGE:
831 HTMIME_TrimDoubleQuotes(me->value);
832 CTRACE((tfp, "HTMIME: PICKED UP Content-Range: '%s'\n",
833 me->value));
834 break;
835 case miCONTENT_TRANSFER_ENCODING:
836 HTMIME_TrimDoubleQuotes(me->value);
837 CTRACE((tfp, "HTMIME: PICKED UP Content-Transfer-Encoding: '%s'\n",
838 me->value));
839 if (me->value[0] == '\0')
840 break;
841 /*
842 * Force the Content-Transfer-Encoding value to all lower case. - FM
843 */
844 LYLowerCase(me->value);
845 me->c_t_encoding = HTAtom_for(me->value);
846 break;
847 case miCONTENT_TYPE:
848 HTMIME_TrimDoubleQuotes(me->value);
849 CTRACE((tfp, "HTMIME: PICKED UP Content-Type: '%s'\n",
850 me->value));
851 if (me->value[0] == '\0')
852 break;
853 /*
854 * Force the Content-Type value to all lower case and strip spaces and
855 * double-quotes. - FM
856 */
857 for (i = 0, j = 0; me->value[i]; i++) {
858 if (me->value[i] != ' ' && me->value[i] != '"') {
859 me->value[j++] = (char) TOLOWER(me->value[i]);
860 }
861 }
862 me->value[j] = '\0';
863 me->format = HTAtom_for(me->value);
864 StrAllocCopy(me->anchor->content_type_params, me->value);
865 break;
866 case miDATE:
867 HTMIME_TrimDoubleQuotes(me->value);
868 CTRACE((tfp, "HTMIME: PICKED UP Date: '%s'\n",
869 me->value));
870 if (me->value[0] == '\0')
871 break;
872 /*
873 * Indicate in anchor. - FM
874 */
875 StrAllocCopy(me->anchor->date, me->value);
876 break;
877 case miETAG:
878 /* Do not trim double quotes: an entity tag consists of an opaque
879 * quoted string, possibly prefixed by a weakness indicator.
880 */
881 CTRACE((tfp, "HTMIME: PICKED UP ETag: %s\n",
882 me->value));
883 if (me->value[0] == '\0')
884 break;
885 /*
886 * Indicate in anchor. - FM
887 */
888 StrAllocCopy(me->anchor->ETag, me->value);
889 break;
890 case miEXPIRES:
891 HTMIME_TrimDoubleQuotes(me->value);
892 CTRACE((tfp, "HTMIME: PICKED UP Expires: '%s'\n",
893 me->value));
894 if (me->value[0] == '\0')
895 break;
896 /*
897 * Indicate in anchor. - FM
898 */
899 StrAllocCopy(me->anchor->expires, me->value);
900 break;
901 case miKEEP_ALIVE:
902 HTMIME_TrimDoubleQuotes(me->value);
903 CTRACE((tfp, "HTMIME: PICKED UP Keep-Alive: '%s'\n",
904 me->value));
905 break;
906 case miLAST_MODIFIED:
907 HTMIME_TrimDoubleQuotes(me->value);
908 CTRACE((tfp, "HTMIME: PICKED UP Last-Modified: '%s'\n",
909 me->value));
910 if (me->value[0] == '\0')
911 break;
912 /*
913 * Indicate in anchor. - FM
914 */
915 StrAllocCopy(me->anchor->last_modified, me->value);
916 break;
917 case miLINK:
918 HTMIME_TrimDoubleQuotes(me->value);
919 CTRACE((tfp, "HTMIME: PICKED UP Link: '%s'\n",
920 me->value));
921 break;
922 case miLOCATION:
923 HTMIME_TrimDoubleQuotes(me->value);
924 CTRACE((tfp, "HTMIME: PICKED UP Location: '%s'\n",
925 me->value));
926 if (me->pickup_redirection && !me->location) {
927 StrAllocCopy(me->location, me->value);
928 } else {
929 CTRACE((tfp, "HTMIME: *** Ignoring Location!\n"));
930 }
931 break;
932 case miPRAGMA:
933 HTMIME_TrimDoubleQuotes(me->value);
934 CTRACE((tfp, "HTMIME: PICKED UP Pragma: '%s'\n",
935 me->value));
936 if (me->value[0] == '\0')
937 break;
938 /*
939 * Check whether to set no_cache for the anchor. - FM
940 */
941 if (!strcmp(me->value, "no-cache"))
942 me->anchor->no_cache = TRUE;
943 break;
944 case miPROXY_AUTHENTICATE:
945 HTMIME_TrimDoubleQuotes(me->value);
946 CTRACE((tfp, "HTMIME: PICKED UP Proxy-Authenticate: '%s'\n",
947 me->value));
948 break;
949 case miPUBLIC:
950 HTMIME_TrimDoubleQuotes(me->value);
951 CTRACE((tfp, "HTMIME: PICKED UP Public: '%s'\n",
952 me->value));
953 break;
954 case miREFRESH: /* nonstandard: Netscape */
955 HTMIME_TrimDoubleQuotes(me->value);
956 CTRACE((tfp, "HTMIME: PICKED UP Refresh: '%s'\n",
957 me->value));
958 StrAllocCopy(me->refresh_url, me->value);
959 break;
960 case miRETRY_AFTER:
961 HTMIME_TrimDoubleQuotes(me->value);
962 CTRACE((tfp, "HTMIME: PICKED UP Retry-After: '%s'\n",
963 me->value));
964 break;
965 case miSAFE:
966 HTMIME_TrimDoubleQuotes(me->value);
967 CTRACE((tfp, "HTMIME: PICKED UP Safe: '%s'\n",
968 me->value));
969 if (me->value[0] == '\0')
970 break;
971 /*
972 * Indicate in anchor if "YES" or "TRUE". - FM
973 */
974 if (!strcasecomp(me->value, "YES") ||
975 !strcasecomp(me->value, "TRUE")) {
976 me->anchor->safe = TRUE;
977 } else if (!strcasecomp(me->value, "NO") ||
978 !strcasecomp(me->value, "FALSE")) {
979 /*
980 * If server explicitly tells us that it has changed its mind,
981 * reset flag in anchor. - kw
982 */
983 me->anchor->safe = FALSE;
984 }
985 break;
986 case miSERVER:
987 HTMIME_TrimDoubleQuotes(me->value);
988 CTRACE((tfp, "HTMIME: PICKED UP Server: '%s'\n",
989 me->value));
990 if (me->value[0] == '\0')
991 break;
992 /*
993 * Indicate in anchor. - FM
994 */
995 StrAllocCopy(me->anchor->server, me->value);
996 break;
997 case miSET_COOKIE1:
998 HTMIME_TrimDoubleQuotes(me->value);
999 CTRACE((tfp, "HTMIME: PICKED UP Set-Cookie: '%s'\n",
1000 me->value));
1001 if (me->set_cookie == NULL) {
1002 StrAllocCopy(me->set_cookie, me->value);
1003 } else {
1004 StrAllocCat(me->set_cookie, ", ");
1005 StrAllocCat(me->set_cookie, me->value);
1006 }
1007 break;
1008 case miSET_COOKIE2:
1009 HTMIME_TrimDoubleQuotes(me->value);
1010 CTRACE((tfp, "HTMIME: PICKED UP Set-Cookie2: '%s'\n",
1011 me->value));
1012 if (me->set_cookie2 == NULL) {
1013 StrAllocCopy(me->set_cookie2, me->value);
1014 } else {
1015 StrAllocCat(me->set_cookie2, ", ");
1016 StrAllocCat(me->set_cookie2, me->value);
1017 }
1018 break;
1019 case miTITLE:
1020 HTMIME_TrimDoubleQuotes(me->value);
1021 CTRACE((tfp, "HTMIME: PICKED UP Title: '%s'\n",
1022 me->value));
1023 break;
1024 case miTRANSFER_ENCODING:
1025 HTMIME_TrimDoubleQuotes(me->value);
1026 CTRACE((tfp, "HTMIME: PICKED UP Transfer-Encoding: '%s'\n",
1027 me->value));
1028 if (!strcmp(me->value, "chunked"))
1029 me->chunked_encoding = YES;
1030 break;
1031 case miUPGRADE:
1032 HTMIME_TrimDoubleQuotes(me->value);
1033 CTRACE((tfp, "HTMIME: PICKED UP Upgrade: '%s'\n",
1034 me->value));
1035 break;
1036 case miURI:
1037 HTMIME_TrimDoubleQuotes(me->value);
1038 CTRACE((tfp, "HTMIME: PICKED UP URI: '%s'\n",
1039 me->value));
1040 break;
1041 case miVARY:
1042 HTMIME_TrimDoubleQuotes(me->value);
1043 CTRACE((tfp, "HTMIME: PICKED UP Vary: '%s'\n",
1044 me->value));
1045 break;
1046 case miVIA:
1047 HTMIME_TrimDoubleQuotes(me->value);
1048 CTRACE((tfp, "HTMIME: PICKED UP Via: '%s'\n",
1049 me->value));
1050 break;
1051 case miWARNING:
1052 HTMIME_TrimDoubleQuotes(me->value);
1053 CTRACE((tfp, "HTMIME: PICKED UP Warning: '%s'\n",
1054 me->value));
1055 break;
1056 case miWWW_AUTHENTICATE:
1057 HTMIME_TrimDoubleQuotes(me->value);
1058 CTRACE((tfp, "HTMIME: PICKED UP WWW-Authenticate: '%s'\n",
1059 me->value));
1060 break;
1061 default: /* Should never get here */
1062 return HT_ERROR;
1063 }
1064 return HT_OK;
1065 }
1066
1067 /*_________________________________________________________________________
1068 *
1069 * A C T I O N R O U T I N E S
1070 */
1071
1072 /* Character handling
1073 * ------------------
1074 *
1075 * This is a FSM parser. It ignores field names it does not understand.
1076 * Folded header fields are recognized. Lines without a fieldname at
1077 * the beginning (that are not folded continuation lines) are ignored
1078 * as unknown field names. Fields with empty values are not picked up.
1079 */
1080 static void HTMIME_put_character(HTStream *me, int c)
1081 {
1082 if (me->anchor->inHEAD) {
1083 me->anchor->header_length++;
1084 }
1085 switch (me->state) {
1086 begin_transparent:
1087 case MIME_TRANSPARENT:
1088 me->anchor->actual_length += 1;
1089 (me->targetClass.put_character) (me->target, c);
1090 return;
1091
1092 /* RFC-2616 describes chunked transfer coding */
1093 case mcCHUNKED_DATA:
1094 (*me->targetClass.put_character) (me->target, c);
1095 me->chunked_size--;
1096 if (me->chunked_size <= 0)
1097 me->state = mcCHUNKED_DATA_CR;
1098 return;
1099
1100 case mcCHUNKED_DATA_CR:
1101 me->state = mcCHUNKED_DATA_LF;
1102 if (c == CR) {
1103 return;
1104 }
1105 /* FALLTHRU */
1106
1107 case mcCHUNKED_DATA_LF:
1108 me->state = MIME_CHUNKED;
1109 if (c == LF) {
1110 return;
1111 }
1112
1113 CTRACE((tfp, "HTIME_put_character expected LF in chunked data\n"));
1114 me->state = MIME_TRANSPARENT;
1115 goto begin_transparent;
1116
1117 /* FALLTHRU */
1118 begin_chunked:
1119 case MIME_CHUNKED:
1120 me->chunked_size = 0;
1121 me->state = mcCHUNKED_COUNT_DIGIT;
1122
1123 /* FALLTHRU */
1124 case mcCHUNKED_COUNT_DIGIT:
1125 if (isxdigit(UCH(c))) {
1126 me->chunked_size <<= 4;
1127 if (isdigit(UCH(c)))
1128 me->chunked_size += UCH(c) - '0';
1129 else
1130 me->chunked_size += TOUPPER(UCH(c)) - 'A' + 10;
1131 return;
1132 }
1133 if (c == ';')
1134 me->state = mcCHUNKED_EXTENSION;
1135
1136 /* FALLTHRU */
1137 case mcCHUNKED_EXTENSION:
1138 if (c != CR && c != LF) {
1139 return;
1140 }
1141 me->state = mcCHUNKED_COUNT_CR;
1142
1143 /* FALLTHRU */
1144 case mcCHUNKED_COUNT_CR:
1145 me->state = mcCHUNKED_COUNT_LF;
1146 if (c == CR) {
1147 return;
1148 }
1149
1150 /* FALLTHRU */
1151 case mcCHUNKED_COUNT_LF:
1152 me->state = ((me->chunked_size != 0)
1153 ? mcCHUNKED_DATA
1154 : MIME_CHUNKED);
1155 if (c == LF) {
1156 return;
1157 }
1158 goto begin_chunked;
1159
1160 default:
1161 break;
1162 }
1163
1164 /*
1165 * This slightly simple conversion just strips CR and turns LF to newline.
1166 * On unix LF is \n but on Mac \n is CR for example. See NetToText for an
1167 * implementation which preserves single CR or LF.
1168 */
1169 if (me->net_ascii) {
1170 /*
1171 * <sigh> This is evidence that at one time, this code supported
1172 * local character sets other than ASCII. But there is so much
1173 * code in HTTP.c that depends on line_buffer's having been
1174 * translated to local character set that I needed to put the
1175 * FROMASCII translation there, leaving this translation purely
1176 * destructive. -- gil
1177 */
1178 /* S/390 -- gil -- 0118 */
1179 #ifndef NOT_ASCII
1180 c = FROMASCII(c);
1181 #endif /* NOT_ASCII */
1182 if (c == CR)
1183 return;
1184 else if (c == LF)
1185 c = '\n';
1186 }
1187
1188 switch (me->state) {
1189
1190 case MIME_IGNORE:
1191 return;
1192
1193 case MIME_TRANSPARENT: /* Not reached see above */
1194 case MIME_CHUNKED:
1195 case mcCHUNKED_COUNT_DIGIT:
1196 case mcCHUNKED_COUNT_CR:
1197 case mcCHUNKED_COUNT_LF:
1198 case mcCHUNKED_EXTENSION:
1199 case mcCHUNKED_DATA:
1200 case mcCHUNKED_DATA_CR:
1201 case mcCHUNKED_DATA_LF:
1202 return;
1203
1204 case MIME_NET_ASCII:
1205 (*me->targetClass.put_character) (me->target, c); /* MUST BE FAST */
1206 return;
1207
1208 case miNEWLINE:
1209 if (c != '\n' && WHITE(c)) { /* Folded line */
1210 me->state = me->fold_state; /* pop state before newline */
1211 if (me->state == miGET_VALUE &&
1212 me->value_pointer && me->value_pointer != me->value &&
1213 !WHITE(*(me->value_pointer - 1))) {
1214 c = ' ';
1215 goto GET_VALUE; /* will add space to value if it fits - kw */
1216 }
1217 break;
1218 } else if (me->fold_state == miGET_VALUE) {
1219 /* Got a field, and now we know it's complete - so
1220 * act on it. - kw */
1221 dispatchField(me);
1222 }
1223 /* FALLTHRU */
1224
1225 case miBEGINNING_OF_LINE:
1226 me->net_ascii = YES;
1227 switch (c) {
1228 case 'a':
1229 case 'A':
1230 me->state = miA;
1231 CTRACE((tfp, "HTMIME: Got 'A' at beginning of line, state now A\n"));
1232 break;
1233
1234 case 'c':
1235 case 'C':
1236 me->state = miC;
1237 CTRACE((tfp, "HTMIME: Got 'C' at beginning of line, state now C\n"));
1238 break;
1239
1240 case 'd':
1241 case 'D':
1242 me->check_pointer = "ate:";
1243 me->if_ok = miDATE;
1244 me->state = miCHECK;
1245 CTRACE((tfp,
1246 "HTMIME: Got 'D' at beginning of line, checking for 'ate:'\n"));
1247 break;
1248
1249 case 'e':
1250 case 'E':
1251 me->state = miE;
1252 CTRACE((tfp, "HTMIME: Got 'E' at beginning of line, state now E\n"));
1253 break;
1254
1255 case 'k':
1256 case 'K':
1257 me->check_pointer = "eep-alive:";
1258 me->if_ok = miKEEP_ALIVE;
1259 me->state = miCHECK;
1260 CTRACE((tfp,
1261 "HTMIME: Got 'K' at beginning of line, checking for 'eep-alive:'\n"));
1262 break;
1263
1264 case 'l':
1265 case 'L':
1266 me->state = miL;
1267 CTRACE((tfp, "HTMIME: Got 'L' at beginning of line, state now L\n"));
1268 break;
1269
1270 case 'p':
1271 case 'P':
1272 me->state = miP;
1273 CTRACE((tfp, "HTMIME: Got 'P' at beginning of line, state now P\n"));
1274 break;
1275
1276 case 'r':
1277 case 'R':
1278 me->state = miR;
1279 CTRACE((tfp, "HTMIME: Got 'R' at beginning of line, state now R\n"));
1280 break;
1281
1282 case 's':
1283 case 'S':
1284 me->state = miS;
1285 CTRACE((tfp, "HTMIME: Got 'S' at beginning of line, state now S\n"));
1286 break;
1287
1288 case 't':
1289 case 'T':
1290 me->state = miT;
1291 CTRACE((tfp, "HTMIME: Got 'T' at beginning of line, state now T\n"));
1292 break;
1293
1294 case 'u':
1295 case 'U':
1296 me->state = miU;
1297 CTRACE((tfp, "HTMIME: Got 'U' at beginning of line, state now U\n"));
1298 break;
1299
1300 case 'v':
1301 case 'V':
1302 me->state = miV;
1303 CTRACE((tfp, "HTMIME: Got 'V' at beginning of line, state now V\n"));
1304 break;
1305
1306 case 'w':
1307 case 'W':
1308 me->state = miW;
1309 CTRACE((tfp, "HTMIME: Got 'W' at beginning of line, state now W\n"));
1310 break;
1311
1312 case '\n': /* Blank line: End of Header! */
1313 {
1314 me->anchor->inHEAD = FALSE;
1315 CTRACE((tfp, "HTMIME length %" PRI_off_t "\n",
1316 CAST_off_t (me->anchor->header_length)));
1317 me->net_ascii = NO;
1318 pumpData(me);
1319 }
1320 break;
1321
1322 default:
1323 goto bad_field_name;
1324
1325 } /* switch on character */
1326 break;
1327
1328 case miA: /* Check for 'c','g' or 'l' */
1329 switch (c) {
1330 case 'c':
1331 case 'C':
1332 me->check_pointer = "cept-ranges:";
1333 me->if_ok = miACCEPT_RANGES;
1334 me->state = miCHECK;
1335 CTRACE((tfp,
1336 "HTMIME: Was A, found C, checking for 'cept-ranges:'\n"));
1337 break;
1338
1339 case 'g':
1340 case 'G':
1341 me->check_pointer = "e:";
1342 me->if_ok = miAGE;
1343 me->state = miCHECK;
1344 CTRACE((tfp, "HTMIME: Was A, found G, checking for 'e:'\n"));
1345 break;
1346
1347 case 'l':
1348 case 'L':
1349 me->state = miAL;
1350 CTRACE((tfp, "HTMIME: Was A, found L, state now AL'\n"));
1351 break;
1352
1353 default:
1354 CTRACE((tfp,
1355 "HTMIME: Bad character `%c' found where `%s' expected\n",
1356 c, "'g' or 'l'"));
1357 goto bad_field_name;
1358
1359 } /* switch on character */
1360 break;
1361
1362 case miAL: /* Check for 'l' or 't' */
1363 switch (c) {
1364 case 'l':
1365 case 'L':
1366 me->check_pointer = "ow:";
1367 me->if_ok = miALLOW;
1368 me->state = miCHECK;
1369 CTRACE((tfp, "HTMIME: Was AL, found L, checking for 'ow:'\n"));
1370 break;
1371
1372 case 't':
1373 case 'T':
1374 me->check_pointer = "ernates:";
1375 me->if_ok = miALTERNATES;
1376 me->state = miCHECK;
1377 CTRACE((tfp, "HTMIME: Was AL, found T, checking for 'ernates:'\n"));
1378 break;
1379
1380 default:
1381 CTRACE((tfp,
1382 "HTMIME: Bad character `%c' found where `%s' expected\n",
1383 c, "'l' or 't'"));
1384 goto bad_field_name;
1385
1386 } /* switch on character */
1387 break;
1388
1389 case miC: /* Check for 'a' or 'o' */
1390 switch (c) {
1391 case 'a':
1392 case 'A':
1393 me->check_pointer = "che-control:";
1394 me->if_ok = miCACHE_CONTROL;
1395 me->state = miCHECK;
1396 CTRACE((tfp,
1397 "HTMIME: Was C, found A, checking for 'che-control:'\n"));
1398 break;
1399
1400 case 'o':
1401 case 'O':
1402 me->state = miCO;
1403 CTRACE((tfp, "HTMIME: Was C, found O, state now CO'\n"));
1404 break;
1405
1406 default:
1407 CTRACE((tfp,
1408 "HTMIME: Bad character `%c' found where `%s' expected\n",
1409 c, "'a' or 'o'"));
1410 goto bad_field_name;
1411
1412 } /* switch on character */
1413 break;
1414
1415 case miCO: /* Check for 'n' or 'o' */
1416 switch (c) {
1417 case 'n':
1418 case 'N':
1419 me->state = miCON;
1420 CTRACE((tfp, "HTMIME: Was CO, found N, state now CON\n"));
1421 break;
1422
1423 case 'o':
1424 case 'O':
1425 me->check_pointer = "kie:";
1426 me->if_ok = miCOOKIE;
1427 me->state = miCHECK;
1428 CTRACE((tfp, "HTMIME: Was CO, found O, checking for 'kie:'\n"));
1429 break;
1430
1431 default:
1432 CTRACE((tfp,
1433 "HTMIME: Bad character `%c' found where `%s' expected\n",
1434 c, "'n' or 'o'"));
1435 goto bad_field_name;
1436
1437 } /* switch on character */
1438 break;
1439
1440 case miCON: /* Check for 'n' or 't' */
1441 switch (c) {
1442 case 'n':
1443 case 'N':
1444 me->check_pointer = "ection:";
1445 me->if_ok = miCONNECTION;
1446 me->state = miCHECK;
1447 CTRACE((tfp, "HTMIME: Was CON, found N, checking for 'ection:'\n"));
1448 break;
1449
1450 case 't':
1451 case 'T':
1452 me->check_pointer = "ent-";
1453 me->if_ok = miCONTENT_;
1454 me->state = miCHECK;
1455 CTRACE((tfp, "HTMIME: Was CON, found T, checking for 'ent-'\n"));
1456 break;
1457
1458 default:
1459 CTRACE((tfp,
1460 "HTMIME: Bad character `%c' found where `%s' expected\n",
1461 c, "'n' or 't'"));
1462 goto bad_field_name;
1463
1464 } /* switch on character */
1465 break;
1466
1467 case miE: /* Check for 't' or 'x' */
1468 switch (c) {
1469 case 't':
1470 case 'T':
1471 me->check_pointer = "ag:";
1472 me->if_ok = miETAG;
1473 me->state = miCHECK;
1474 CTRACE((tfp, "HTMIME: Was E, found T, checking for 'ag:'\n"));
1475 break;
1476
1477 case 'x':
1478 case 'X':
1479 me->check_pointer = "pires:";
1480 me->if_ok = miEXPIRES;
1481 me->state = miCHECK;
1482 CTRACE((tfp, "HTMIME: Was E, found X, checking for 'pires:'\n"));
1483 break;
1484
1485 default:
1486 CTRACE((tfp,
1487 "HTMIME: Bad character `%c' found where `%s' expected\n",
1488 c, "'t' or 'x'"));
1489 goto bad_field_name;
1490
1491 } /* switch on character */
1492 break;
1493
1494 case miL: /* Check for 'a', 'i' or 'o' */
1495 switch (c) {
1496 case 'a':
1497 case 'A':
1498 me->check_pointer = "st-modified:";
1499 me->if_ok = miLAST_MODIFIED;
1500 me->state = miCHECK;
1501 CTRACE((tfp,
1502 "HTMIME: Was L, found A, checking for 'st-modified:'\n"));
1503 break;
1504
1505 case 'i':
1506 case 'I':
1507 me->check_pointer = "nk:";
1508 me->if_ok = miLINK;
1509 me->state = miCHECK;
1510 CTRACE((tfp, "HTMIME: Was L, found I, checking for 'nk:'\n"));
1511 break;
1512
1513 case 'o':
1514 case 'O':
1515 me->check_pointer = "cation:";
1516 me->if_ok = miLOCATION;
1517 me->state = miCHECK;
1518 CTRACE((tfp, "HTMIME: Was L, found O, checking for 'cation:'\n"));
1519 break;
1520
1521 default:
1522 CTRACE((tfp,
1523 "HTMIME: Bad character `%c' found where `%s' expected\n",
1524 c, "'a', 'i' or 'o'"));
1525 goto bad_field_name;
1526
1527 } /* switch on character */
1528 break;
1529
1530 case miP: /* Check for 'r' or 'u' */
1531 switch (c) {
1532 case 'r':
1533 case 'R':
1534 me->state = miPR;
1535 CTRACE((tfp, "HTMIME: Was P, found R, state now PR'\n"));
1536 break;
1537
1538 case 'u':
1539 case 'U':
1540 me->check_pointer = "blic:";
1541 me->if_ok = miPUBLIC;
1542 me->state = miCHECK;
1543 CTRACE((tfp, "HTMIME: Was P, found U, checking for 'blic:'\n"));
1544 break;
1545
1546 default:
1547 CTRACE((tfp,
1548 "HTMIME: Bad character `%c' found where `%s' expected\n",
1549 c, "'r' or 'u'"));
1550 goto bad_field_name;
1551
1552 } /* switch on character */
1553 break;
1554
1555 case miPR: /* Check for 'a' or 'o' */
1556 switch (c) {
1557 case 'a':
1558 case 'A':
1559 me->check_pointer = "gma:";
1560 me->if_ok = miPRAGMA;
1561 me->state = miCHECK;
1562 CTRACE((tfp, "HTMIME: Was PR, found A, checking for 'gma'\n"));
1563 break;
1564
1565 case 'o':
1566 case 'O':
1567 me->check_pointer = "xy-authenticate:";
1568 me->if_ok = miPROXY_AUTHENTICATE;
1569 me->state = miCHECK;
1570 CTRACE((tfp,
1571 "HTMIME: Was PR, found O, checking for 'xy-authenticate'\n"));
1572 break;
1573
1574 default:
1575 CTRACE((tfp,
1576 "HTMIME: Bad character `%c' found where `%s' expected\n",
1577 c, "'a' or 'o'"));
1578 goto bad_field_name;
1579
1580 } /* switch on character */
1581 break;
1582
1583 case miR: /* Check for 'e' */
1584 switch (c) {
1585 case 'e':
1586 case 'E':
1587 me->state = miRE;
1588 CTRACE((tfp, "HTMIME: Was R, found E\n"));
1589 break;
1590 default:
1591 CTRACE((tfp,
1592 "HTMIME: Bad character `%c' found where `%s' expected\n",
1593 c, "'e'"));
1594 goto bad_field_name;
1595
1596 } /* switch on character */
1597 break;
1598
1599 case miRE: /* Check for 'a' or 'o' */
1600 switch (c) {
1601 case 'f':
1602 case 'F': /* nonstandard: Netscape */
1603 me->check_pointer = "resh:";
1604 me->if_ok = miREFRESH;
1605 me->state = miCHECK;
1606 CTRACE((tfp, "HTMIME: Was RE, found F, checking for '%s'\n", me->check_pointer));
1607 break;
1608
1609 case 't':
1610 case 'T':
1611 me->check_pointer = "ry-after:";
1612 me->if_ok = miRETRY_AFTER;
1613 me->state = miCHECK;
1614 CTRACE((tfp, "HTMIME: Was RE, found T, checking for '%s'\n", me->check_pointer));
1615 break;
1616
1617 default:
1618 CTRACE((tfp,
1619 "HTMIME: Bad character `%c' found where `%s' expected\n",
1620 c, "'f' or 't'"));
1621 goto bad_field_name;
1622
1623 } /* switch on character */
1624 break;
1625
1626 case miS: /* Check for 'a' or 'e' */
1627 switch (c) {
1628 case 'a':
1629 case 'A':
1630 me->check_pointer = "fe:";
1631 me->if_ok = miSAFE;
1632 me->state = miCHECK;
1633 CTRACE((tfp, "HTMIME: Was S, found A, checking for 'fe:'\n"));
1634 break;
1635
1636 case 'e':
1637 case 'E':
1638 me->state = miSE;
1639 CTRACE((tfp, "HTMIME: Was S, found E, state now SE'\n"));
1640 break;
1641
1642 default:
1643 CTRACE((tfp,
1644 "HTMIME: Bad character `%c' found where `%s' expected\n",
1645 c, "'a' or 'e'"));
1646 goto bad_field_name;
1647
1648 } /* switch on character */
1649 break;
1650
1651 case miSE: /* Check for 'r' or 't' */
1652 switch (c) {
1653 case 'r':
1654 case 'R':
1655 me->check_pointer = "ver:";
1656 me->if_ok = miSERVER;
1657 me->state = miCHECK;
1658 CTRACE((tfp, "HTMIME: Was SE, found R, checking for 'ver'\n"));
1659 break;
1660
1661 case 't':
1662 case 'T':
1663 me->check_pointer = "-cookie";
1664 me->if_ok = miSET_COOKIE;
1665 me->state = miCHECK;
1666 CTRACE((tfp, "HTMIME: Was SE, found T, checking for '-cookie'\n"));
1667 break;
1668
1669 default:
1670 CTRACE((tfp,
1671 "HTMIME: Bad character `%c' found where `%s' expected\n",
1672 c, "'r' or 't'"));
1673 goto bad_field_name;
1674
1675 } /* switch on character */
1676 break;
1677
1678 case miSET_COOKIE: /* Check for ':' or '2' */
1679 switch (c) {
1680 case ':':
1681 me->field = miSET_COOKIE1; /* remember it */
1682 me->state = miSKIP_GET_VALUE;
1683 CTRACE((tfp, "HTMIME: Was SET_COOKIE, found :, processing\n"));
1684 break;
1685
1686 case '2':
1687 me->check_pointer = ":";
1688 me->if_ok = miSET_COOKIE2;
1689 me->state = miCHECK;
1690 CTRACE((tfp, "HTMIME: Was SET_COOKIE, found 2, checking for ':'\n"));
1691 break;
1692
1693 default:
1694 CTRACE((tfp,
1695 "HTMIME: Bad character `%c' found where `%s' expected\n",
1696 c, "':' or '2'"));
1697 goto bad_field_name;
1698
1699 } /* switch on character */
1700 break;
1701
1702 case miT: /* Check for 'i' or 'r' */
1703 switch (c) {
1704 case 'i':
1705 case 'I':
1706 me->check_pointer = "tle:";
1707 me->if_ok = miTITLE;
1708 me->state = miCHECK;
1709 CTRACE((tfp, "HTMIME: Was T, found I, checking for 'tle:'\n"));
1710 break;
1711
1712 case 'r':
1713 case 'R':
1714 me->check_pointer = "ansfer-encoding:";
1715 me->if_ok = miTRANSFER_ENCODING;
1716 me->state = miCHECK;
1717 CTRACE((tfp,
1718 "HTMIME: Was T, found R, checking for 'ansfer-encoding'\n"));
1719 break;
1720
1721 default:
1722 CTRACE((tfp,
1723 "HTMIME: Bad character `%c' found where `%s' expected\n",
1724 c, "'i' or 'r'"));
1725 goto bad_field_name;
1726
1727 } /* switch on character */
1728 break;
1729
1730 case miU: /* Check for 'p' or 'r' */
1731 switch (c) {
1732 case 'p':
1733 case 'P':
1734 me->check_pointer = "grade:";
1735 me->if_ok = miUPGRADE;
1736 me->state = miCHECK;
1737 CTRACE((tfp, "HTMIME: Was U, found P, checking for 'grade:'\n"));
1738 break;
1739
1740 case 'r':
1741 case 'R':
1742 me->check_pointer = "i:";
1743 me->if_ok = miURI;
1744 me->state = miCHECK;
1745 CTRACE((tfp, "HTMIME: Was U, found R, checking for 'i:'\n"));
1746 break;
1747
1748 default:
1749 CTRACE((tfp,
1750 "HTMIME: Bad character `%c' found where `%s' expected\n",
1751 c, "'p' or 'r'"));
1752 goto bad_field_name;
1753
1754 } /* switch on character */
1755 break;
1756
1757 case miV: /* Check for 'a' or 'i' */
1758 switch (c) {
1759 case 'a':
1760 case 'A':
1761 me->check_pointer = "ry:";
1762 me->if_ok = miVARY;
1763 me->state = miCHECK;
1764 CTRACE((tfp, "HTMIME: Was V, found A, checking for 'ry:'\n"));
1765 break;
1766
1767 case 'i':
1768 case 'I':
1769 me->check_pointer = "a:";
1770 me->if_ok = miVIA;
1771 me->state = miCHECK;
1772 CTRACE((tfp, "HTMIME: Was V, found I, checking for 'a:'\n"));
1773 break;
1774
1775 default:
1776 CTRACE((tfp,
1777 "HTMIME: Bad character `%c' found where `%s' expected\n",
1778 c, "'a' or 'i'"));
1779 goto bad_field_name;
1780
1781 } /* switch on character */
1782 break;
1783
1784 case miW: /* Check for 'a' or 'w' */
1785 switch (c) {
1786 case 'a':
1787 case 'A':
1788 me->check_pointer = "rning:";
1789 me->if_ok = miWARNING;
1790 me->state = miCHECK;
1791 CTRACE((tfp, "HTMIME: Was W, found A, checking for 'rning:'\n"));
1792 break;
1793
1794 case 'w':
1795 case 'W':
1796 me->check_pointer = "w-authenticate:";
1797 me->if_ok = miWWW_AUTHENTICATE;
1798 me->state = miCHECK;
1799 CTRACE((tfp,
1800 "HTMIME: Was W, found W, checking for 'w-authenticate:'\n"));
1801 break;
1802
1803 default:
1804 CTRACE((tfp,
1805 "HTMIME: Bad character `%c' found where `%s' expected\n",
1806 c, "'a' or 'w'"));
1807 goto bad_field_name;
1808
1809 } /* switch on character */
1810 break;
1811
1812 case miCHECK: /* Check against string */
1813 if (TOLOWER(c) == *(me->check_pointer)++) {
1814 if (!*me->check_pointer)
1815 me->state = me->if_ok;
1816 } else { /* Error */
1817 CTRACE((tfp,
1818 "HTMIME: Bad character `%c' found where `%s' expected\n",
1819 c, me->check_pointer - 1));
1820 goto bad_field_name;
1821 }
1822 break;
1823
1824 case miCONTENT_:
1825 CTRACE((tfp, "HTMIME: in case CONTENT_\n"));
1826
1827 switch (c) {
1828 case 'b':
1829 case 'B':
1830 me->check_pointer = "ase:";
1831 me->if_ok = miCONTENT_BASE;
1832 me->state = miCHECK;
1833 CTRACE((tfp,
1834 "HTMIME: Was CONTENT_, found B, checking for 'ase:'\n"));
1835 break;
1836
1837 case 'd':
1838 case 'D':
1839 me->check_pointer = "isposition:";
1840 me->if_ok = miCONTENT_DISPOSITION;
1841 me->state = miCHECK;
1842 CTRACE((tfp,
1843 "HTMIME: Was CONTENT_, found D, checking for 'isposition:'\n"));
1844 break;
1845
1846 case 'e':
1847 case 'E':
1848 me->check_pointer = "ncoding:";
1849 me->if_ok = miCONTENT_ENCODING;
1850 me->state = miCHECK;
1851 CTRACE((tfp,
1852 "HTMIME: Was CONTENT_, found E, checking for 'ncoding:'\n"));
1853 break;
1854
1855 case 'f':
1856 case 'F':
1857 me->check_pointer = "eatures:";
1858 me->if_ok = miCONTENT_FEATURES;
1859 me->state = miCHECK;
1860 CTRACE((tfp,
1861 "HTMIME: Was CONTENT_, found F, checking for 'eatures:'\n"));
1862 break;
1863
1864 case 'l':
1865 case 'L':
1866 me->state = miCONTENT_L;
1867 CTRACE((tfp,
1868 "HTMIME: Was CONTENT_, found L, state now CONTENT_L\n"));
1869 break;
1870
1871 case 'm':
1872 case 'M':
1873 me->check_pointer = "d5:";
1874 me->if_ok = miCONTENT_MD5;
1875 me->state = miCHECK;
1876 CTRACE((tfp, "HTMIME: Was CONTENT_, found M, checking for 'd5:'\n"));
1877 break;
1878
1879 case 'r':
1880 case 'R':
1881 me->check_pointer = "ange:";
1882 me->if_ok = miCONTENT_RANGE;
1883 me->state = miCHECK;
1884 CTRACE((tfp,
1885 "HTMIME: Was CONTENT_, found R, checking for 'ange:'\n"));
1886 break;
1887
1888 case 't':
1889 case 'T':
1890 me->state = miCONTENT_T;
1891 CTRACE((tfp,
1892 "HTMIME: Was CONTENT_, found T, state now CONTENT_T\n"));
1893 break;
1894
1895 default:
1896 CTRACE((tfp, "HTMIME: Was CONTENT_, found nothing; bleah\n"));
1897 goto bad_field_name;
1898
1899 } /* switch on character */
1900 break;
1901
1902 case miCONTENT_L:
1903 CTRACE((tfp, "HTMIME: in case CONTENT_L\n"));
1904
1905 switch (c) {
1906 case 'a':
1907 case 'A':
1908 me->check_pointer = "nguage:";
1909 me->if_ok = miCONTENT_LANGUAGE;
1910 me->state = miCHECK;
1911 CTRACE((tfp,
1912 "HTMIME: Was CONTENT_L, found A, checking for 'nguage:'\n"));
1913 break;
1914
1915 case 'e':
1916 case 'E':
1917 me->check_pointer = "ngth:";
1918 me->if_ok = miCONTENT_LENGTH;
1919 me->state = miCHECK;
1920 CTRACE((tfp,
1921 "HTMIME: Was CONTENT_L, found E, checking for 'ngth:'\n"));
1922 break;
1923
1924 case 'o':
1925 case 'O':
1926 me->check_pointer = "cation:";
1927 me->if_ok = miCONTENT_LOCATION;
1928 me->state = miCHECK;
1929 CTRACE((tfp,
1930 "HTMIME: Was CONTENT_L, found O, checking for 'cation:'\n"));
1931 break;
1932
1933 default:
1934 CTRACE((tfp, "HTMIME: Was CONTENT_L, found nothing; bleah\n"));
1935 goto bad_field_name;
1936
1937 } /* switch on character */
1938 break;
1939
1940 case miCONTENT_T:
1941 CTRACE((tfp, "HTMIME: in case CONTENT_T\n"));
1942
1943 switch (c) {
1944 case 'r':
1945 case 'R':
1946 me->check_pointer = "ansfer-encoding:";
1947 me->if_ok = miCONTENT_TRANSFER_ENCODING;
1948 me->state = miCHECK;
1949 CTRACE((tfp,
1950 "HTMIME: Was CONTENT_T, found R, checking for 'ansfer-encoding:'\n"));
1951 break;
1952
1953 case 'y':
1954 case 'Y':
1955 me->check_pointer = "pe:";
1956 me->if_ok = miCONTENT_TYPE;
1957 me->state = miCHECK;
1958 CTRACE((tfp,
1959 "HTMIME: Was CONTENT_T, found Y, checking for 'pe:'\n"));
1960 break;
1961
1962 default:
1963 CTRACE((tfp, "HTMIME: Was CONTENT_T, found nothing; bleah\n"));
1964 goto bad_field_name;
1965
1966 } /* switch on character */
1967 break;
1968
1969 case miACCEPT_RANGES:
1970 case miAGE:
1971 case miALLOW:
1972 case miALTERNATES:
1973 case miCACHE_CONTROL:
1974 case miCOOKIE:
1975 case miCONNECTION:
1976 case miCONTENT_BASE:
1977 case miCONTENT_DISPOSITION:
1978 case miCONTENT_ENCODING:
1979 case miCONTENT_FEATURES:
1980 case miCONTENT_LANGUAGE:
1981 case miCONTENT_LENGTH:
1982 case miCONTENT_LOCATION:
1983 case miCONTENT_MD5:
1984 case miCONTENT_RANGE:
1985 case miCONTENT_TRANSFER_ENCODING:
1986 case miCONTENT_TYPE:
1987 case miDATE:
1988 case miETAG:
1989 case miEXPIRES:
1990 case miKEEP_ALIVE:
1991 case miLAST_MODIFIED:
1992 case miLINK:
1993 case miLOCATION:
1994 case miPRAGMA:
1995 case miPROXY_AUTHENTICATE:
1996 case miPUBLIC:
1997 case miREFRESH:
1998 case miRETRY_AFTER:
1999 case miSAFE:
2000 case miSERVER:
2001 case miSET_COOKIE1:
2002 case miSET_COOKIE2:
2003 case miTITLE:
2004 case miTRANSFER_ENCODING:
2005 case miUPGRADE:
2006 case miURI:
2007 case miVARY:
2008 case miVIA:
2009 case miWARNING:
2010 case miWWW_AUTHENTICATE:
2011 me->field = me->state; /* remember it */
2012 me->state = miSKIP_GET_VALUE;
2013 /* FALLTHRU */
2014
2015 case miSKIP_GET_VALUE:
2016 if (c == '\n') {
2017 me->fold_state = me->state;
2018 me->state = miNEWLINE;
2019 break;
2020 }
2021 if (WHITE(c))
2022 /*
2023 * Skip white space.
2024 */
2025 break;
2026
2027 me->value_pointer = me->value;
2028 me->state = miGET_VALUE;
2029 /* Fall through to store first character */
2030 /* FALLTHRU */
2031
2032 case miGET_VALUE:
2033 GET_VALUE:
2034 if (c != '\n') { /* Not end of line */
2035 if (me->value_pointer < me->value + VALUE_SIZE - 1) {
2036 *me->value_pointer++ = (char) c;
2037 break;
2038 } else {
2039 goto value_too_long;
2040 }
2041 }
2042 /* Fall through (if end of line) */
2043 /* FALLTHRU */
2044
2045 case miJUNK_LINE:
2046 if (c == '\n') {
2047 me->fold_state = me->state;
2048 me->state = miNEWLINE;
2049 }
2050 break;
2051
2052 } /* switch on state */
2053
2054 HTChunkPutc(&me->anchor->http_headers, UCH(c));
2055 if (me->state == MIME_TRANSPARENT) {
2056 HTChunkTerminate(&me->anchor->http_headers);
2057 CTRACE((tfp, "Server Headers (%d bytes):\n%.*s\n",
2058 me->anchor->http_headers.size,
2059 me->anchor->http_headers.size,
2060 me->anchor->http_headers.data));
2061 CTRACE((tfp, "Server Content-Type:%s\n",
2062 me->anchor->content_type_params));
2063 }
2064 return;
2065
2066 value_too_long:
2067 CTRACE((tfp, "HTMIME: *** Syntax error. (string too long)\n"));
2068
2069 bad_field_name: /* Ignore it */
2070 me->state = miJUNK_LINE;
2071
2072 HTChunkPutc(&me->anchor->http_headers, UCH(c));
2073
2074 return;
2075 }
2076
2077 /* String handling
2078 * ---------------
2079 *
2080 * Strings must be smaller than this buffer size.
2081 */
2082 static void HTMIME_put_string(HTStream *me,
2083 const char *s)
2084 {
2085 const char *p;
2086
2087 if (me->state == MIME_TRANSPARENT) { /* Optimisation */
2088 (*me->targetClass.put_string) (me->target, s);
2089
2090 } else if (me->state != MIME_IGNORE) {
2091 CTRACE((tfp, "HTMIME: %s\n", s));
2092
2093 for (p = s; *p; p++)
2094 HTMIME_put_character(me, *p);
2095 }
2096 }
2097
2098 /* Buffer write. Buffers can (and should!) be big.
2099 * ------------
2100 */
2101 static void HTMIME_write(HTStream *me,
2102 const char *s,
2103 int l)
2104 {
2105 const char *p;
2106
2107 if (me->state == MIME_TRANSPARENT) { /* Optimisation */
2108 (*me->targetClass.put_block) (me->target, s, l);
2109
2110 } else {
2111 CTRACE((tfp, "HTMIME: %.*s\n", l, s));
2112
2113 for (p = s; p < s + l; p++)
2114 HTMIME_put_character(me, *p);
2115 }
2116 }
2117
2118 /* Free an HTML object
2119 * -------------------
2120 *
2121 */
2122 static void HTMIME_free(HTStream *me)
2123 {
2124 if (me) {
2125 FREE(me->location);
2126 FREE(me->compression_encoding);
2127 if (me->target)
2128 (*me->targetClass._free) (me->target);
2129 FREE(me);
2130 }
2131 }
2132
2133 /* End writing
2134 */
2135 static void HTMIME_abort(HTStream *me,
2136 HTError e)
2137 {
2138 if (me) {
2139 FREE(me->location);
2140 FREE(me->compression_encoding);
2141 if (me->target)
2142 (*me->targetClass._abort) (me->target, e);
2143 FREE(me);
2144 }
2145 }
2146
2147 /* Structured Object Class
2148 * -----------------------
2149 */
2150 static const HTStreamClass HTMIME =
2151 {
2152 "MIMEParser",
2153 HTMIME_free,
2154 HTMIME_abort,
2155 HTMIME_put_character,
2156 HTMIME_put_string,
2157 HTMIME_write
2158 };
2159
2160 /* Subclass-specific Methods
2161 * -------------------------
2162 */
2163 HTStream *HTMIMEConvert(HTPresentation *pres,
2164 HTParentAnchor *anchor,
2165 HTStream *sink)
2166 {
2167 HTStream *me;
2168
2169 CTRACE((tfp, "HTMIMEConvert\n"));
2170 me = typecalloc(HTStream);
2171
2172 if (me == NULL)
2173 outofmem(__FILE__, "HTMIMEConvert");
2174
2175 me->isa = &HTMIME;
2176 me->sink = sink;
2177 me->anchor = anchor;
2178 me->anchor->safe = FALSE;
2179 me->anchor->no_cache = FALSE;
2180
2181 FREE(me->anchor->cache_control);
2182 FREE(me->anchor->SugFname);
2183 FREE(me->anchor->charset);
2184
2185 HTChunkClear(&me->anchor->http_headers);
2186 HTChunkInit(&me->anchor->http_headers, 128);
2187
2188 FREE(me->anchor->content_type_params);
2189 FREE(me->anchor->content_language);
2190 FREE(me->anchor->content_encoding);
2191 FREE(me->anchor->content_base);
2192 FREE(me->anchor->content_disposition);
2193 FREE(me->anchor->content_location);
2194 FREE(me->anchor->content_md5);
2195
2196 me->anchor->inHEAD = TRUE;
2197 me->anchor->header_length = 0;
2198 me->anchor->content_length = 0;
2199
2200 FREE(me->anchor->date);
2201 FREE(me->anchor->expires);
2202 FREE(me->anchor->last_modified);
2203 FREE(me->anchor->ETag);
2204 FREE(me->anchor->server);
2205
2206 me->target = NULL;
2207 me->state = miBEGINNING_OF_LINE;
2208 me->format = HTAtom_for(ContentTypes[LYContentType]);
2209
2210 CTRACE((tfp, "default Content-Type is %s\n", HTAtom_name(me->format)));
2211 me->targetRep = pres->rep_out;
2212 me->boundary = NULL; /* Not set yet */
2213 me->set_cookie = NULL; /* Not set yet */
2214 me->set_cookie2 = NULL; /* Not set yet */
2215 me->refresh_url = NULL; /* Not set yet */
2216 me->c_t_encoding = NULL; /* Not set yet */
2217 me->compression_encoding = NULL; /* Not set yet */
2218 me->net_ascii = NO; /* Local character set */
2219
2220 HTAnchor_setUCInfoStage(me->anchor, current_char_set,
2221 UCT_STAGE_STRUCTURED,
2222 UCT_SETBY_DEFAULT);
2223 HTAnchor_setUCInfoStage(me->anchor, current_char_set,
2224 UCT_STAGE_HTEXT,
2225 UCT_SETBY_DEFAULT);
2226 return me;
2227 }
2228
2229 HTStream *HTNetMIME(HTPresentation *pres,
2230 HTParentAnchor *anchor,
2231 HTStream *sink)
2232 {
2233 HTStream *me = HTMIMEConvert(pres, anchor, sink);
2234
2235 if (!me)
2236 return NULL;
2237
2238 me->net_ascii = YES;
2239 return me;
2240 }
2241
2242 HTStream *HTMIMERedirect(HTPresentation *pres,
2243 HTParentAnchor *anchor,
2244 HTStream *sink)
2245 {
2246 HTStream *me = HTMIMEConvert(pres, anchor, sink);
2247
2248 if (!me)
2249 return NULL;
2250
2251 me->pickup_redirection = YES;
2252 if (me->targetRep == WWW_DEBUG && sink)
2253 me->no_streamstack = YES;
2254 return me;
2255 }
2256
2257 /* Japanese header handling functions
2258 * ==================================
2259 *
2260 * K&Rized and added 07-Jun-96 by FM, based on:
2261 *
2262 ////////////////////////////////////////////////////////////////////////
2263 *
2264 * ISO-2022-JP handling routines
2265 * &
2266 * MIME decode routines (quick hack just for ISO-2022-JP)
2267 *
2268 * Thu Jan 25 10:11:42 JST 1996
2269 *
2270 * Copyright (C) 1994, 1995, 1996
2271 * Shuichi Ichikawa ([email protected])
2272 *
2273 * This program is free software; you can redistribute it and/or modify
2274 * it under the terms of the GNU General Public License as published by
2275 * the Free Software Foundation; either versions 2, or (at your option)
2276 * any later version.
2277 *
2278 * This program is distributed in the hope that it will be useful
2279 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2280 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2281 * GNU General Public License for more details.
2282 *
2283 * You should have received a copy of the GNU General Public License
2284 * along with SKK, see the file COPYING. If not, write to the Free
2285 * Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
2286 */
2287
2288 /*
2289 * MIME decoding routines
2290 *
2291 * Written by S. Ichikawa,
2292 * partially inspired by encdec.c of <[email protected]>.
2293 * Caller's buffers decode to no longer than the input strings.
2294 */
2295 #include <LYCharVals.h> /* S/390 -- gil -- 0163 */
2296
2297 static char HTmm64[] =
2298 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
2299 static char HTmmquote[] = "0123456789ABCDEF";
2300 static int HTmmcont = 0;
2301
2302 static void HTmmdec_base64(char **t,
2303 char *s)
2304 {
2305 int d, count, j, val;
2306 char *buf, *bp, nw[4], *p;
2307
2308 if ((buf = typeMallocn(char, strlen(s) * 3 + 1)) == NULL)
2309 outofmem(__FILE__, "HTmmdec_base64");
2310
2311 for (bp = buf; *s; s += 4) {
2312 val = 0;
2313 if (s[2] == '=')
2314 count = 1;
2315 else if (s[3] == '=')
2316 count = 2;
2317 else
2318 count = 3;
2319
2320 for (j = 0; j <= count; j++) {
2321 if (!(p = StrChr(HTmm64, s[j]))) {
2322 FREE(buf);
2323 return;
2324 }
2325 d = (int) (p - HTmm64);
2326 d <<= (3 - j) * 6;
2327 val += d;
2328 }
2329 for (j = 2; j >= 0; j--) {
2330 nw[j] = (char) (val & 255);
2331 val >>= 8;
2332 }
2333 if (count--)
2334 *bp++ = nw[0];
2335 if (count--)
2336 *bp++ = nw[1];
2337 if (count)
2338 *bp++ = nw[2];
2339 }
2340 *bp = '\0';
2341 StrAllocCopy(*t, buf);
2342 FREE(buf);
2343 }
2344
2345 static void HTmmdec_quote(char **t,
2346 char *s)
2347 {
2348 char *buf, cval, *bp, *p;
2349
2350 if ((buf = typeMallocn(char, strlen(s) + 1)) == NULL)
2351 outofmem(__FILE__, "HTmmdec_quote");
2352
2353 for (bp = buf; *s;) {
2354 if (*s == '=') {
2355 cval = 0;
2356 if (s[1] && (p = StrChr(HTmmquote, s[1]))) {
2357 cval = (char) (cval + (char) (p - HTmmquote));
2358 } else {
2359 *bp++ = *s++;
2360 continue;
2361 }
2362 if (s[2] && (p = StrChr(HTmmquote, s[2]))) {
2363 cval = (char) (cval << 4);
2364 cval = (char) (cval + (p - HTmmquote));
2365 *bp++ = cval;
2366 s += 3;
2367 } else {
2368 *bp++ = *s++;
2369 }
2370 } else if (*s == '_') {
2371 *bp++ = 0x20;
2372 s++;
2373 } else {
2374 *bp++ = *s++;
2375 }
2376 }
2377 *bp = '\0';
2378 StrAllocCopy(*t, buf);
2379 FREE(buf);
2380 }
2381
2382 /*
2383 * HTmmdecode for ISO-2022-JP - FM
2384 */
2385 void HTmmdecode(char **target,
2386 char *source)
2387 {
2388 char *buf;
2389 char *mmbuf = NULL;
2390 char *m2buf = NULL;
2391 char *s, *t, *u;
2392 int base64, quote;
2393
2394 if ((buf = typeMallocn(char, strlen(source) + 1)) == NULL)
2395 outofmem(__FILE__, "HTmmdecode");
2396
2397 for (s = source, *(u = buf) = '\0'; *s;) {
2398 if (!strncasecomp(s, "=?ISO-2022-JP?B?", 16)) {
2399 base64 = 1;
2400 } else {
2401 base64 = 0;
2402 }
2403 if (!strncasecomp(s, "=?ISO-2022-JP?Q?", 16)) {
2404 quote = 1;
2405 } else {
2406 quote = 0;
2407 }
2408 if (base64 || quote) {
2409 if (HTmmcont) {
2410 for (t = s - 1;
2411 t >= source && (*t == ' ' || *t == '\t'); t--) {
2412 u--;
2413 }
2414 }
2415 if (mmbuf == NULL) /* allocate buffer big enough for source */
2416 StrAllocCopy(mmbuf, source);
2417 for (s += 16, t = mmbuf; *s;) {
2418 if (s[0] == '?' && s[1] == '=') {
2419 break;
2420 } else {
2421 *t++ = *s++;
2422 *t = '\0';
2423 }
2424 }
2425 if (s[0] != '?' || s[1] != '=') {
2426 goto end;
2427 } else {
2428 s += 2;
2429 *t = '\0';
2430 }
2431 if (base64)
2432 HTmmdec_base64(&m2buf, mmbuf);
2433 else
2434 HTmmdec_quote(&m2buf, mmbuf);
2435 for (t = m2buf; non_empty(t);)
2436 *u++ = *t++;
2437 HTmmcont = 1;
2438 } else {
2439 if (*s != ' ' && *s != '\t')
2440 HTmmcont = 0;
2441 *u++ = *s++;
2442 }
2443 }
2444 *u = '\0';
2445 end:
2446 StrAllocCopy(*target, buf);
2447 FREE(m2buf);
2448 FREE(mmbuf);
2449 FREE(buf);
2450 }
2451
2452 /*
2453 * Insert ESC where it seems lost.
2454 * (The author of this function "rjis" is S. Ichikawa.)
2455 */
2456 int HTrjis(char **t,
2457 char *s)
2458 {
2459 char *p;
2460 char *buf = NULL;
2461 int kanji = 0;
2462
2463 if (StrChr(s, CH_ESC) || !StrChr(s, '$')) {
2464 if (s != *t)
2465 StrAllocCopy(*t, s);
2466 return 1;
2467 }
2468
2469 if ((buf = typeMallocn(char, strlen(s) * 2 + 1)) == NULL)
2470 outofmem(__FILE__, "HTrjis");
2471
2472 for (p = buf; *s;) {
2473 if (!kanji && s[0] == '$' && (s[1] == '@' || s[1] == 'B')) {
2474 if (HTmaybekanji((int) s[2], (int) s[3])) {
2475 kanji = 1;
2476 *p++ = CH_ESC;
2477 *p++ = *s++;
2478 *p++ = *s++;
2479 *p++ = *s++;
2480 *p++ = *s++;
2481 continue;
2482 }
2483 *p++ = *s++;
2484 continue;
2485 }
2486 if (kanji && s[0] == '(' && (s[1] == 'J' || s[1] == 'B')) {
2487 kanji = 0;
2488 *p++ = CH_ESC;
2489 *p++ = *s++;
2490 *p++ = *s++;
2491 continue;
2492 }
2493 *p++ = *s++;
2494 }
2495 *p = *s; /* terminate string */
2496
2497 StrAllocCopy(*t, buf);
2498 FREE(buf);
2499 return 0;
2500 }
2501
2502 /*
2503 * The following function "maybekanji" is derived from
2504 * RJIS-1.0 by Mr. Hironobu Takahashi.
2505 * Maybekanji() is included here under the courtesy of the author.
2506 * The original comment of rjis.c is also included here.
2507 */
2508 /*
2509 * RJIS ( Recover JIS code from broken file )
2510 * Copyright (C) 1992 1994
2511 * Hironobu Takahashi ([email protected])
2512 *
2513 * This program is free software; you can redistribute it and/or modify
2514 * it under the terms of the GNU General Public License as published by
2515 * the Free Software Foundation; either versions 2, or (at your option)
2516 * any later version.
2517 *
2518 * This program is distributed in the hope that it will be useful
2519 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2520 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2521 * GNU General Public License for more details.
2522 *
2523 * You should have received a copy of the GNU General Public License
2524 * along with SKK, see the file COPYING. If not, write to the Free
2525 * Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
2526 */
2527
2528 int HTmaybekanji(int c1,
2529 int c2)
2530 {
2531
2532 if ((c2 < 33) || (c2 > 126))
2533 return 0;
2534 if ((c1 < 33) || ((40 < c1) && (c1 < 48)) || (116 < c1))
2535 return 0;
2536 c2 -= 32;
2537 switch (c1 - 32) {
2538 case 2:
2539 if ((14 < c2) && (c2 < 26))
2540 return 0;
2541 if ((33 < c2) && (c2 < 42))
2542 return 0;
2543 if ((48 < c2) && (c2 < 60))
2544 return 0;
2545 if ((74 < c2) && (c2 < 82))
2546 return 0;
2547 if ((89 < c2) && (c2 < 94))
2548 return 0;
2549 break;
2550 case 3:
2551 if (c2 < 16)
2552 return 0;
2553 if ((25 < c2) && (c2 < 33))
2554 return 0;
2555 if ((58 < c2) && (c2 < 65))
2556 return 0;
2557 if (90 < c2)
2558 return 0;
2559 break;
2560 case 4:
2561 if (83 < c2)
2562 return 0;
2563 break;
2564 case 5:
2565 if (86 < c2)
2566 return 0;
2567 break;
2568 case 6:
2569 if ((24 < c2) && (c2 < 33))
2570 return 0;
2571 if (56 < c2)
2572 return 0;
2573 break;
2574 case 7:
2575 if ((33 < c2) && (c2 < 49))
2576 return 0;
2577 if (81 < c2)
2578 return 0;
2579 break;
2580 case 8:
2581 if (32 < c2)
2582 return 0;
2583 break;
2584 case 47:
2585 if (51 < c2)
2586 return 0;
2587 break;
2588 case 84:
2589 if (6 < c2)
2590 return 0;
2591 break;
2592 }
2593 return 1;
2594 }