/* MIME Message Parse HTMIME.c ** ================== ** ** This is RFC 1341-specific code. ** The input stream pushed into this parser is assumed to be ** stripped on CRs, ie lines end with LF, not CR LF. ** (It is easy to change this except for the body part where ** conversion can be slow.) ** ** History: ** Feb 92 Written Tim Berners-Lee, CERN ** */ #include #include /* Implemented here */ #include #include #include #include #include #include #include #include #include #include extern BOOL HTPassEightBitRaw; extern HTCJKlang HTCJK; /* MIME Object ** ----------- */ typedef enum _MIME_state { MIME_TRANSPARENT, /* put straight through to target ASAP! */ miBEGINNING_OF_LINE, /* first character and not a continuation */ miA, miACCEPT_RANGES, miAGE, miAL, miALLOW, miALTERNATES, miC, miCACHE_CONTROL, miCO, miCOOKIE, miCON, miCONNECTION, miCONTENT_, miCONTENT_BASE, miCONTENT_DISPOSITION, miCONTENT_ENCODING, miCONTENT_FEATURES, miCONTENT_L, miCONTENT_LANGUAGE, miCONTENT_LENGTH, miCONTENT_LOCATION, miCONTENT_MD5, miCONTENT_RANGE, miCONTENT_T, miCONTENT_TRANSFER_ENCODING, miCONTENT_TYPE, miDATE, miE, miETAG, miEXPIRES, miKEEP_ALIVE, miL, miLAST_MODIFIED, miLINK, miLOCATION, miP, miPR, miPRAGMA, miPROXY_AUTHENTICATE, miPUBLIC, miRETRY_AFTER, miS, miSAFE, miSE, miSERVER, miSET_COOKIE, miSET_COOKIE1, miSET_COOKIE2, miT, miTITLE, miTRANSFER_ENCODING, miU, miUPGRADE, miURI, miV, miVARY, miVIA, miW, miWARNING, miWWW_AUTHENTICATE, miSKIP_GET_VALUE, /* Skip space then get value */ miGET_VALUE, /* Get value till white space */ miJUNK_LINE, /* Ignore the rest of this folded line */ miNEWLINE, /* Just found a LF .. maybe continuation */ miCHECK, /* check against check_pointer */ MIME_NET_ASCII, /* Translate from net ascii */ MIME_IGNORE /* Ignore entire file */ /* TRANSPARENT and IGNORE are defined as stg else in _WINDOWS */ } MIME_state; #define VALUE_SIZE 5120 /* @@@@@@@ Arbitrary? */ struct _HTStream { CONST HTStreamClass * isa; BOOL net_ascii; /* Is input net ascii? */ MIME_state state; /* current state */ MIME_state if_ok; /* got this state if match */ MIME_state field; /* remember which field */ MIME_state fold_state; /* state on a fold */ CONST char * check_pointer; /* checking input */ char * value_pointer; /* storing values */ char value[VALUE_SIZE]; HTParentAnchor * anchor; /* Given on creation */ HTStream * sink; /* Given on creation */ char * boundary; /* For multipart */ char * set_cookie; /* Set-Cookie */ char * set_cookie2; /* Set-Cookie2 */ HTFormat encoding; /* Content-Transfer-Encoding */ char * compression_encoding; HTFormat format; /* Content-Type */ HTStream * target; /* While writing out */ HTStreamClass targetClass; HTAtom * targetRep; /* Converting into? */ }; /* ** This function is for trimming off any paired ** open- and close-double quotes from header values. ** It does not parse the string for embedded quotes, ** and will not modify the string unless both the ** first and last characters are double-quotes. - FM */ PUBLIC void HTMIME_TrimDoubleQuotes ARGS1( char *, value) { int i; char *cp = value; if (!(cp && *cp) || *cp != '\"') return; i = strlen(cp); if (cp[(i - 1)] != '\"') return; else cp[(i - 1)] = '\0'; for (i = 0; value[i]; i++) value[i] = cp[(i +1)]; } /*_________________________________________________________________________ ** ** A C T I O N R O U T I N E S */ /* Character handling ** ------------------ ** ** This is a FSM parser which is tolerant as it can be of all ** syntax errors. It ignores field names it does not understand, ** and resynchronises on line beginnings. */ PRIVATE void HTMIME_put_character ARGS2( HTStream *, me, char, c) { int i, j; if (me->state == MIME_TRANSPARENT) { (*me->targetClass.put_character)(me->target, c);/* MUST BE FAST */ return; } /* ** This slightly simple conversion just strips CR and turns LF to ** newline. On unix LF is \n but on Mac \n is CR for example. ** See NetToText for an implementation which preserves single CR or LF. */ if (me->net_ascii) { /* ** This is evidence that at one time, this code supported ** local character sets other than ASCII. But there is so much ** code in HTTP.c that depends on line_buffer's having been ** translated to local character set that I needed to put the ** FROMASCII translation there, leaving this translation purely ** destructive. -- gil */ /* S/390 -- gil -- 0118 */ #ifndef NOT_ASCII c = FROMASCII(c); #endif /* NOT_ASCII */ if (c == CR) return; else if (c == LF) c = '\n'; } switch(me->state) { case MIME_IGNORE: return; case MIME_TRANSPARENT: /* Not reached see above */ (*me->targetClass.put_character)(me->target, c); return; case MIME_NET_ASCII: (*me->targetClass.put_character)(me->target, c); /* MUST BE FAST */ return; case miNEWLINE: if (c != '\n' && WHITE(c)) { /* Folded line */ me->state = me->fold_state; /* pop state before newline */ break; } /* else Falls through */ case miBEGINNING_OF_LINE: me->net_ascii = YES; switch (c) { case 'a': case 'A': me->state = miA; CTRACE(tfp, "HTMIME: Got 'A' at beginning of line, state now A\n"); break; case 'c': case 'C': me->state = miC; CTRACE (tfp, "HTMIME: Got 'C' at beginning of line, state now C\n"); break; case 'd': case 'D': me->check_pointer = "ate:"; me->if_ok = miDATE; me->state = miCHECK; CTRACE (tfp, "HTMIME: Got 'D' at beginning of line, checking for 'ate:'\n"); break; case 'e': case 'E': me->state = miE; CTRACE (tfp, "HTMIME: Got 'E' at beginning of line, state now E\n"); break; case 'k': case 'K': me->check_pointer = "eep-alive:"; me->if_ok = miKEEP_ALIVE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Got 'K' at beginning of line, checking for 'eep-alive:'\n"); break; case 'l': case 'L': me->state = miL; CTRACE (tfp, "HTMIME: Got 'L' at beginning of line, state now L\n"); break; case 'p': case 'P': me->state = miP; CTRACE (tfp, "HTMIME: Got 'P' at beginning of line, state now P\n"); break; case 'r': case 'R': me->check_pointer = "etry-after:"; me->if_ok = miRETRY_AFTER; me->state = miCHECK; CTRACE(tfp, "HTMIME: Got 'R' at beginning of line, checking for 'etry-after'\n"); break; case 's': case 'S': me->state = miS; CTRACE (tfp, "HTMIME: Got 'S' at beginning of line, state now S\n"); break; case 't': case 'T': me->state = miT; CTRACE (tfp, "HTMIME: Got 'T' at beginning of line, state now T\n"); break; case 'u': case 'U': me->state = miU; CTRACE (tfp, "HTMIME: Got 'U' at beginning of line, state now U\n"); break; case 'v': case 'V': me->state = miV; CTRACE (tfp, "HTMIME: Got 'V' at beginning of line, state now V\n"); break; case 'w': case 'W': me->state = miW; CTRACE (tfp, "HTMIME: Got 'W' at beginning of line, state now W\n"); break; case '\n': /* Blank line: End of Header! */ { me->net_ascii = NO; if (strchr(HTAtom_name(me->format), ';') != NULL) { char *cp = NULL, *cp1, *cp2, *cp3 = NULL, *cp4; CTRACE(tfp, "HTMIME: Extended MIME Content-Type is %s\n", HTAtom_name(me->format)); StrAllocCopy(cp, HTAtom_name(me->format)); /* ** Note that the Content-Type value was converted ** to lower case when we loaded into me->format, ** but there may have been a mixed or upper-case ** atom, so we'll force lower-casing again. We ** also stripped spaces and double-quotes, but ** we'll make sure they're still gone from any ** charset parameter we check. - FM */ LYLowerCase(cp); if ((cp1 = strchr(cp, ';')) != NULL) { BOOL chartrans_ok = NO; if ((cp2 = strstr(cp1, "charset")) != NULL) { int chndl; cp2 += 7; while (*cp2 == ' ' || *cp2 == '=' || *cp2 == '\"') cp2++; StrAllocCopy(cp3, cp2); /* copy to mutilate more */ for (cp4 = cp3; (*cp4 != '\0' && *cp4 != '\"' && *cp4 != ';' && *cp4 != ':' && !WHITE(*cp4)); cp4++) ; /* do nothing */ *cp4 = '\0'; cp4 = cp3; chndl = UCGetLYhndl_byMIME(cp3); if (UCCanTranslateFromTo(chndl, current_char_set)) { chartrans_ok = YES; *cp1 = '\0'; me->format = HTAtom_for(cp); StrAllocCopy(me->anchor->charset, cp4); HTAnchor_setUCInfoStage(me->anchor, chndl, UCT_STAGE_MIME, UCT_SETBY_MIME); } else if (chndl < 0) {/* got something but we don't recognize it */ chndl = UCLYhndl_for_unrec; if (chndl < 0) /* ** UCLYhndl_for_unrec not defined :-( ** fallback to UCLYhndl_for_unspec ** which always valid. */ chndl = UCLYhndl_for_unspec; /* always >= 0 */ if (UCCanTranslateFromTo(chndl, current_char_set)) { chartrans_ok = YES; *cp1 = '\0'; me->format = HTAtom_for(cp); HTAnchor_setUCInfoStage(me->anchor, chndl, UCT_STAGE_MIME, UCT_SETBY_DEFAULT); } } if (chartrans_ok) { LYUCcharset * p_in = HTAnchor_getUCInfoStage(me->anchor, UCT_STAGE_MIME); LYUCcharset * p_out = HTAnchor_setUCInfoStage(me->anchor, current_char_set, UCT_STAGE_HTEXT, UCT_SETBY_DEFAULT); if (!p_out) /* ** Try again. */ p_out = HTAnchor_getUCInfoStage(me->anchor, UCT_STAGE_HTEXT); if (!strcmp(p_in->MIMEname, "x-transparent")) { HTPassEightBitRaw = TRUE; HTAnchor_setUCInfoStage(me->anchor, HTAnchor_getUCLYhndl(me->anchor, UCT_STAGE_HTEXT), UCT_STAGE_MIME, UCT_SETBY_DEFAULT); } if (!strcmp(p_out->MIMEname, "x-transparent")) { HTPassEightBitRaw = TRUE; HTAnchor_setUCInfoStage(me->anchor, HTAnchor_getUCLYhndl(me->anchor, UCT_STAGE_MIME), UCT_STAGE_HTEXT, UCT_SETBY_DEFAULT); } if (p_in->enc != UCT_ENC_CJK) { HTCJK = NOCJK; if (!(p_in->codepoints & UCT_CP_SUBSETOF_LAT1) && chndl == current_char_set) { HTPassEightBitRaw = TRUE; } } else if (p_out->enc == UCT_ENC_CJK) { Set_HTCJK(p_in->MIMEname, p_out->MIMEname); } } else { /* ** Cannot translate. ** If according to some heuristic the given ** charset and the current display character ** both are likely to be like ISO-8859 in ** structure, pretend we have some kind ** of match. */ BOOL given_is_8859 = (!strncmp(cp4, "iso-8859-", 9) && isdigit((unsigned char)cp4[9])); BOOL given_is_8859like = (given_is_8859 || !strncmp(cp4, "windows-", 8) || !strncmp(cp4, "cp12", 4) || !strncmp(cp4, "cp-12", 5)); BOOL given_and_display_8859like = (given_is_8859like && (strstr(LYchar_set_names[current_char_set], "ISO-8859") || strstr(LYchar_set_names[current_char_set], "windows-"))); if (given_and_display_8859like) { *cp1 = '\0'; me->format = HTAtom_for(cp); } if (given_is_8859) { cp1 = &cp4[10]; while (*cp1 && isdigit((unsigned char)(*cp1))) cp1++; *cp1 = '\0'; } if (given_and_display_8859like) { StrAllocCopy(me->anchor->charset, cp4); HTPassEightBitRaw = TRUE; } HTAlert(*cp4 ? cp4 : me->anchor->charset); } FREE(cp3); } else { /* ** No charset parameter is present. ** Ignore all other parameters, as ** we do when charset is present. - FM */ *cp1 = '\0'; me->format = HTAtom_for(cp); } } FREE(cp); } /* ** If we have an Expires header and haven't ** already set the no_cache element for the ** anchor, check if we should set it based ** on that header. - FM */ if (me->anchor->no_cache == FALSE && me->anchor->expires != NULL) { if (!strcmp(me->anchor->expires, "0")) { /* * The value is zero, which we treat as * an absolute no-cache directive. - FM */ me->anchor->no_cache = TRUE; } else if (me->anchor->date != NULL) { /* ** We have a Date header, so check if ** the value is less than or equal to ** that. - FM */ if (LYmktime(me->anchor->expires, TRUE) <= LYmktime(me->anchor->date, TRUE)) { me->anchor->no_cache = TRUE; } } else if (LYmktime(me->anchor->expires, FALSE) <= 0) { /* ** We don't have a Date header, and ** the value is in past for us. - FM */ me->anchor->no_cache = TRUE; } } StrAllocCopy(me->anchor->content_type, HTAtom_name(me->format)); if (!me->compression_encoding) { CTRACE(tfp, "HTMIME: MIME Content-Type is '%s', converting to '%s'\n", HTAtom_name(me->format), HTAtom_name(me->targetRep)); } else { /* ** Change the format to that for "www/compressed" ** and set up a stream to deal with it. - FM */ CTRACE(tfp, "HTMIME: MIME Content-Type is '%s',\n", HTAtom_name(me->format)); me->format = HTAtom_for("www/compressed"); CTRACE(tfp, " Treating as '%s'. Converting to '%s'\n", HTAtom_name(me->format), HTAtom_name(me->targetRep)); } if (me->set_cookie != NULL || me->set_cookie2 != NULL) { LYSetCookie(me->set_cookie, me->set_cookie2, me->anchor->address); FREE(me->set_cookie); FREE(me->set_cookie2); } me->target = HTStreamStack(me->format, me->targetRep, me->sink , me->anchor); if (!me->target) { CTRACE(tfp, "HTMIME: Can't translate! ** \n"); me->target = me->sink; /* Cheat */ } if (me->target) { me->targetClass = *me->target->isa; /* ** Check for encoding and select state from there, ** someday, but until we have the relevant code, ** from now push straight through. - FM */ me->state = MIME_TRANSPARENT; } else { me->state = MIME_IGNORE; /* What else to do? */ } FREE(me->compression_encoding); } break; default: goto bad_field_name; } /* switch on character */ break; case miA: /* Check for 'c','g' or 'l' */ switch (c) { case 'c': case 'C': me->check_pointer = "cept-ranges:"; me->if_ok = miACCEPT_RANGES; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was A, found C, checking for 'cept-ranges:'\n"); break; case 'g': case 'G': me->check_pointer = "e:"; me->if_ok = miAGE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was A, found G, checking for 'e:'\n"); break; case 'l': case 'L': me->state = miAL; CTRACE(tfp, "HTMIME: Was A, found L, state now AL'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'g' or 'l'"); goto bad_field_name; } /* switch on character */ break; case miAL: /* Check for 'l' or 't' */ switch (c) { case 'l': case 'L': me->check_pointer = "ow:"; me->if_ok = miALLOW; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was AL, found L, checking for 'ow:'\n"); break; case 't': case 'T': me->check_pointer = "ernates:"; me->if_ok = miALTERNATES; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was AL, found T, checking for 'ernates:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'l' or 't'"); goto bad_field_name; } /* switch on character */ break; case miC: /* Check for 'a' or 'o' */ switch (c) { case 'a': case 'A': me->check_pointer = "che-control:"; me->if_ok = miCACHE_CONTROL; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was C, found A, checking for 'che-control:'\n"); break; case 'o': case 'O': me->state = miCO; CTRACE(tfp, "HTMIME: Was C, found O, state now CO'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a' or 'o'"); goto bad_field_name; } /* switch on character */ break; case miCO: /* Check for 'n' or 'o' */ switch (c) { case 'n': case 'N': me->state = miCON; CTRACE(tfp, "HTMIME: Was CO, found N, state now CON\n"); break; case 'o': case 'O': me->check_pointer = "kie:"; me->if_ok = miCOOKIE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CO, found O, checking for 'kie:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'n' or 'o'"); goto bad_field_name; } /* switch on character */ break; case miCON: /* Check for 'n' or 't' */ switch (c) { case 'n': case 'N': me->check_pointer = "ection:"; me->if_ok = miCONNECTION; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CON, found N, checking for 'ection:'\n"); break; case 't': case 'T': me->check_pointer = "ent-"; me->if_ok = miCONTENT_; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CON, found T, checking for 'ent-'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'n' or 't'"); goto bad_field_name; } /* switch on character */ break; case miE: /* Check for 't' or 'x' */ switch (c) { case 't': case 'T': me->check_pointer = "ag:"; me->if_ok = miETAG; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was E, found T, checking for 'ag:'\n"); break; case 'x': case 'X': me->check_pointer = "pires:"; me->if_ok = miEXPIRES; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was E, found X, checking for 'pires:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'t' or 'x'"); goto bad_field_name; } /* switch on character */ break; case miL: /* Check for 'a', 'i' or 'o' */ switch (c) { case 'a': case 'A': me->check_pointer = "st-modified:"; me->if_ok = miLAST_MODIFIED; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was L, found A, checking for 'st-modified:'\n"); break; case 'i': case 'I': me->check_pointer = "nk:"; me->if_ok = miLINK; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was L, found I, checking for 'nk:'\n"); break; case 'o': case 'O': me->check_pointer = "cation:"; me->if_ok = miLOCATION; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was L, found O, checking for 'cation:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a', 'i' or 'o'"); goto bad_field_name; } /* switch on character */ break; case miP: /* Check for 'r' or 'u' */ switch (c) { case 'r': case 'R': me->state = miPR; CTRACE(tfp, "HTMIME: Was P, found R, state now PR'\n"); break; case 'u': case 'U': me->check_pointer = "blic:"; me->if_ok = miPUBLIC; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was P, found U, checking for 'blic:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'r' or 'u'"); goto bad_field_name; } /* switch on character */ break; case miPR: /* Check for 'a' or 'o' */ switch (c) { case 'a': case 'A': me->check_pointer = "gma:"; me->if_ok = miPRAGMA; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was PR, found A, checking for 'gma'\n"); break; case 'o': case 'O': me->check_pointer = "xy-authenticate:"; me->if_ok = miPROXY_AUTHENTICATE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was PR, found O, checking for 'xy-authenticate'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a' or 'o'"); goto bad_field_name; } /* switch on character */ break; case miS: /* Check for 'a' or 'e' */ switch (c) { case 'a': case 'A': me->check_pointer = "fe:"; me->if_ok = miSAFE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was S, found A, checking for 'fe:'\n"); break; case 'e': case 'E': me->state = miSE; CTRACE(tfp, "HTMIME: Was S, found E, state now SE'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a' or 'e'"); goto bad_field_name; } /* switch on character */ break; case miSE: /* Check for 'r' or 't' */ switch (c) { case 'r': case 'R': me->check_pointer = "ver:"; me->if_ok = miSERVER; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was SE, found R, checking for 'ver'\n"); break; case 't': case 'T': me->check_pointer = "-cookie"; me->if_ok = miSET_COOKIE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was SE, found T, checking for '-cookie'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'r' or 't'"); goto bad_field_name; } /* switch on character */ break; case miSET_COOKIE: /* Check for ':' or '2' */ switch (c) { case ':': me->field = miSET_COOKIE1; /* remember it */ me->state = miSKIP_GET_VALUE; CTRACE(tfp, "HTMIME: Was SET_COOKIE, found :, processing\n"); break; case '2': me->check_pointer = ":"; me->if_ok = miSET_COOKIE2; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was SET_COOKIE, found 2, checking for ':'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "':' or '2'"); goto bad_field_name; } /* switch on character */ break; case miT: /* Check for 'i' or 'r' */ switch (c) { case 'i': case 'I': me->check_pointer = "tle:"; me->if_ok = miTITLE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was T, found I, checking for 'tle:'\n"); break; case 'r': case 'R': me->check_pointer = "ansfer-encoding:"; me->if_ok = miTRANSFER_ENCODING; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was T, found R, checking for 'ansfer-encoding'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'i' or 'r'"); goto bad_field_name; } /* switch on character */ break; case miU: /* Check for 'p' or 'r' */ switch (c) { case 'p': case 'P': me->check_pointer = "grade:"; me->if_ok = miUPGRADE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was U, found P, checking for 'grade:'\n"); break; case 'r': case 'R': me->check_pointer = "i:"; me->if_ok = miURI; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was U, found R, checking for 'i:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'p' or 'r'"); goto bad_field_name; } /* switch on character */ break; case miV: /* Check for 'a' or 'i' */ switch (c) { case 'a': case 'A': me->check_pointer = "ry:"; me->if_ok = miVARY; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was V, found A, checking for 'ry:'\n"); break; case 'i': case 'I': me->check_pointer = "a:"; me->if_ok = miVIA; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was V, found I, checking for 'a:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a' or 'i'"); goto bad_field_name; } /* switch on character */ break; case miW: /* Check for 'a' or 'w' */ switch (c) { case 'a': case 'A': me->check_pointer = "rning:"; me->if_ok = miWARNING; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was W, found A, checking for 'rning:'\n"); break; case 'w': case 'W': me->check_pointer = "w-authenticate:"; me->if_ok = miWWW_AUTHENTICATE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was W, found W, checking for 'w-authenticate:'\n"); break; default: CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, "'a' or 'w'"); goto bad_field_name; } /* switch on character */ break; case miCHECK: /* Check against string */ if (TOLOWER(c) == *(me->check_pointer)++) { if (!*me->check_pointer) me->state = me->if_ok; } else { /* Error */ CTRACE(tfp, "HTMIME: Bad character `%c' found where `%s' expected\n", c, me->check_pointer - 1); goto bad_field_name; } break; case miCONTENT_: CTRACE (tfp, "HTMIME: in case CONTENT_\n"); switch(c) { case 'b': case 'B': me->check_pointer = "ase:"; me->if_ok = miCONTENT_BASE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found B, checking for 'ase:'\n"); break; case 'd': case 'D': me->check_pointer = "isposition:"; me->if_ok = miCONTENT_DISPOSITION; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found D, checking for 'isposition:'\n"); break; case 'e': case 'E': me->check_pointer = "ncoding:"; me->if_ok = miCONTENT_ENCODING; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found E, checking for 'ncoding:'\n"); break; case 'f': case 'F': me->check_pointer = "eatures:"; me->if_ok = miCONTENT_FEATURES; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found F, checking for 'eatures:'\n"); break; case 'l': case 'L': me->state = miCONTENT_L; CTRACE (tfp, "HTMIME: Was CONTENT_, found L, state now CONTENT_L\n"); break; case 'm': case 'M': me->check_pointer = "d5:"; me->if_ok = miCONTENT_MD5; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found M, checking for 'd5:'\n"); break; case 'r': case 'R': me->check_pointer = "ange:"; me->if_ok = miCONTENT_RANGE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_, found R, checking for 'ange:'\n"); break; case 't': case 'T': me->state = miCONTENT_T; CTRACE(tfp, "HTMIME: Was CONTENT_, found T, state now CONTENT_T\n"); break; default: CTRACE(tfp, "HTMIME: Was CONTENT_, found nothing; bleah\n"); goto bad_field_name; } /* switch on character */ break; case miCONTENT_L: CTRACE (tfp, "HTMIME: in case CONTENT_L\n"); switch(c) { case 'a': case 'A': me->check_pointer = "nguage:"; me->if_ok = miCONTENT_LANGUAGE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_L, found A, checking for 'nguage:'\n"); break; case 'e': case 'E': me->check_pointer = "ngth:"; me->if_ok = miCONTENT_LENGTH; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_L, found E, checking for 'ngth:'\n"); break; case 'o': case 'O': me->check_pointer = "cation:"; me->if_ok = miCONTENT_LOCATION; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_L, found O, checking for 'cation:'\n"); break; default: CTRACE (tfp, "HTMIME: Was CONTENT_L, found nothing; bleah\n"); goto bad_field_name; } /* switch on character */ break; case miCONTENT_T: CTRACE (tfp, "HTMIME: in case CONTENT_T\n"); switch(c) { case 'r': case 'R': me->check_pointer = "ansfer-encoding:"; me->if_ok = miCONTENT_TRANSFER_ENCODING; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_T, found R, checking for 'ansfer-encoding:'\n"); break; case 'y': case 'Y': me->check_pointer = "pe:"; me->if_ok = miCONTENT_TYPE; me->state = miCHECK; CTRACE(tfp, "HTMIME: Was CONTENT_T, found Y, checking for 'pe:'\n"); break; default: CTRACE (tfp, "HTMIME: Was CONTENT_T, found nothing; bleah\n"); goto bad_field_name; } /* switch on character */ break; case miACCEPT_RANGES: case miAGE: case miALLOW: case miALTERNATES: case miCACHE_CONTROL: case miCOOKIE: case miCONNECTION: case miCONTENT_BASE: case miCONTENT_DISPOSITION: case miCONTENT_ENCODING: case miCONTENT_FEATURES: case miCONTENT_LANGUAGE: case miCONTENT_LENGTH: case miCONTENT_LOCATION: case miCONTENT_MD5: case miCONTENT_RANGE: case miCONTENT_TRANSFER_ENCODING: case miCONTENT_TYPE: case miDATE: case miETAG: case miEXPIRES: case miKEEP_ALIVE: case miLAST_MODIFIED: case miLINK: case miLOCATION: case miPRAGMA: case miPROXY_AUTHENTICATE: case miPUBLIC: case miRETRY_AFTER: case miSAFE: case miSERVER: case miSET_COOKIE1: case miSET_COOKIE2: case miTITLE: case miTRANSFER_ENCODING: case miUPGRADE: case miURI: case miVARY: case miVIA: case miWARNING: case miWWW_AUTHENTICATE: me->field = me->state; /* remember it */ me->state = miSKIP_GET_VALUE; /* Fall through! */ case miSKIP_GET_VALUE: if (c == '\n') { me->fold_state = me->state; me->state = miNEWLINE; break; } if (WHITE(c)) /* ** Skip white space. */ break; me->value_pointer = me->value; me->state = miGET_VALUE; /* Fall through to store first character */ case miGET_VALUE: if (WHITE(c) && c != ' ') { /* End of field */ char *cp; *me->value_pointer = '\0'; cp = (me->value_pointer - 1); while ((cp >= me->value) && *cp == ' ') /* S/390 -- gil -- 0146 */ /* ** Trim trailing spaces. */ *cp = '\0'; switch (me->field) { case miACCEPT_RANGES: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Accept-Ranges: '%s'\n", me->value); break; case miAGE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Age: '%s'\n", me->value); break; case miALLOW: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Allow: '%s'\n", me->value); break; case miALTERNATES: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Alternates: '%s'\n", me->value); break; case miCACHE_CONTROL: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Cache-Control: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Convert to lowercase and indicate in anchor. - FM */ LYLowerCase(me->value); StrAllocCopy(me->anchor->cache_control, me->value); /* ** Check whether to set no_cache for the anchor. - FM */ { char *cp1, *cp0 = me->value; while ((cp1 = strstr(cp0, "no-cache")) != NULL) { cp1 += 8; while (*cp1 != '\0' && WHITE(*cp1)) cp1++; if (*cp1 == '\0' || *cp1 == ';') { me->anchor->no_cache = TRUE; break; } cp0 = cp1; } if (me->anchor->no_cache == TRUE) break; cp0 = me->value; while ((cp1 = strstr(cp0, "max-age")) != NULL) { cp1 += 7; while (*cp1 != '\0' && WHITE(*cp1)) cp1++; if (*cp1 == '=') { cp1++; while (*cp1 != '\0' && WHITE(*cp1)) cp1++; if (isdigit((unsigned char)*cp1)) { cp0 = cp1; while (isdigit((unsigned char)*cp1)) cp1++; if (*cp0 == '0' && cp1 == (cp0 + 1)) { me->anchor->no_cache = TRUE; break; } } } cp0 = cp1; } } break; case miCOOKIE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Cookie: '%s'\n", me->value); break; case miCONNECTION: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Connection: '%s'\n", me->value); break; case miCONTENT_BASE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Base: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->content_base, me->value); break; case miCONTENT_DISPOSITION: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Disposition: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->content_disposition, me->value); /* ** It's not clear yet from existing RFCs and IDs ** whether we should be looking for file;, attachment;, ** and/or inline; before the filename=value, so we'll ** just search for "filename" followed by '=' and just ** hope we get the intended value. It is purely a ** suggested name, anyway. - FM */ cp = me->anchor->content_disposition; while (*cp != '\0' && strncasecomp(cp, "filename", 8)) cp++; if (*cp == '\0') break; cp += 8; while ((*cp != '\0') && (WHITE(*cp) || *cp == '=')) cp++; if (*cp == '\0') break; while (*cp != '\0' && WHITE(*cp)) cp++; if (*cp == '\0') break; StrAllocCopy(me->anchor->SugFname, cp); if (*me->anchor->SugFname == '\"') { if ((cp = strchr((me->anchor->SugFname + 1), '\"')) != NULL) { *(cp + 1) = '\0'; HTMIME_TrimDoubleQuotes(me->anchor->SugFname); } else { FREE(me->anchor->SugFname); break; } } cp = me->anchor->SugFname; while (*cp != '\0' && !WHITE(*cp)) cp++; *cp = '\0'; if (*me->anchor->SugFname == '\0') FREE(me->anchor->SugFname); break; case miCONTENT_ENCODING: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Encoding: '%s'\n", me->value); if (!(me->value && *me->value) || !strcasecomp(me->value, "identity")) break; /* ** Convert to lowercase and indicate in anchor. - FM */ LYLowerCase(me->value); StrAllocCopy(me->anchor->content_encoding, me->value); FREE(me->compression_encoding); if (!strcmp(me->value, "8bit") || !strcmp(me->value, "7bit") || !strcmp(me->value, "binary")) { /* ** Some server indicated "8bit", "7bit" or "binary" ** inappropriately. We'll ignore it. - FM */ CTRACE(tfp, " Ignoring it!\n"); } else { /* ** Save it to use as a flag for setting ** up a "www/compressed" target. - FM */ StrAllocCopy(me->compression_encoding, me->value); } break; case miCONTENT_FEATURES: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Features: '%s'\n", me->value); break; case miCONTENT_LANGUAGE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Language: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Convert to lowercase and indicate in anchor. - FM */ LYLowerCase(me->value); StrAllocCopy(me->anchor->content_language, me->value); break; case miCONTENT_LENGTH: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Length: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Convert to integer and indicate in anchor. - FM */ me->anchor->content_length = atoi(me->value); if (me->anchor->content_length < 0) me->anchor->content_length = 0; CTRACE(tfp, " Converted to integer: '%d'\n", me->anchor->content_length); break; case miCONTENT_LOCATION: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Location: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->content_location, me->value); break; case miCONTENT_MD5: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-MD5: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->content_md5, me->value); break; case miCONTENT_RANGE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Range: '%s'\n", me->value); break; case miCONTENT_TRANSFER_ENCODING: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Transfer-Encoding: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Force the Content-Transfer-Encoding value ** to all lower case. - FM */ LYLowerCase(me->value); me->encoding = HTAtom_for(me->value); break; case miCONTENT_TYPE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Content-Type: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Force the Content-Type value to all lower case ** and strip spaces and double-quotes. - FM */ for (i = 0, j = 0; me->value[i]; i++) { if (me->value[i] != ' ' && me->value[i] != '\"') { me->value[j++] = TOLOWER(me->value[i]); } } me->value[j] = '\0'; me->format = HTAtom_for(me->value); break; case miDATE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Date: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->date, me->value); break; case miETAG: /* Do not trim double quotes: * an entity tag consists of an opaque quoted string, * possibly prefixed by a weakness indicator. */ CTRACE(tfp, "HTMIME: PICKED UP ETag: %s\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->ETag, me->value); break; case miEXPIRES: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Expires: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->expires, me->value); break; case miKEEP_ALIVE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Keep-Alive: '%s'\n", me->value); break; case miLAST_MODIFIED: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Last-Modified: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->last_modified, me->value); break; case miLINK: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Link: '%s'\n", me->value); break; case miLOCATION: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Location: '%s'\n", me->value); break; case miPRAGMA: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Pragma: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Check whether to set no_cache for the anchor. - FM */ if (!strcmp(me->value, "no-cache")) me->anchor->no_cache = TRUE; break; case miPROXY_AUTHENTICATE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Proxy-Authenticate: '%s'\n", me->value); break; case miPUBLIC: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Public: '%s'\n", me->value); break; case miRETRY_AFTER: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Retry-After: '%s'\n", me->value); break; case miSAFE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Safe: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor if "YES" or "TRUE". - FM */ if (!strcasecomp(me->value, "YES") || !strcasecomp(me->value, "TRUE")) { me->anchor->safe = TRUE; } break; case miSERVER: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Server: '%s'\n", me->value); if (!(me->value && *me->value)) break; /* ** Indicate in anchor. - FM */ StrAllocCopy(me->anchor->server, me->value); break; case miSET_COOKIE1: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Set-Cookie: '%s'\n", me->value); if (me->set_cookie == NULL) { StrAllocCopy(me->set_cookie, me->value); } else { StrAllocCat(me->set_cookie, ", "); StrAllocCat(me->set_cookie, me->value); } break; case miSET_COOKIE2: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Set-Cookie2: '%s'\n", me->value); if (me->set_cookie2 == NULL) { StrAllocCopy(me->set_cookie2, me->value); } else { StrAllocCat(me->set_cookie2, ", "); StrAllocCat(me->set_cookie2, me->value); } break; case miTITLE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Title: '%s'\n", me->value); break; case miTRANSFER_ENCODING: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Transfer-Encoding: '%s'\n", me->value); break; case miUPGRADE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Upgrade: '%s'\n", me->value); break; case miURI: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP URI: '%s'\n", me->value); break; case miVARY: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Vary: '%s'\n", me->value); break; case miVIA: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Via: '%s'\n", me->value); break; case miWARNING: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP Warning: '%s'\n", me->value); break; case miWWW_AUTHENTICATE: HTMIME_TrimDoubleQuotes(me->value); CTRACE(tfp, "HTMIME: PICKED UP WWW-Authenticate: '%s'\n", me->value); break; default: /* Should never get here */ break; } } else { if (me->value_pointer < me->value + VALUE_SIZE - 1) { *me->value_pointer++ = c; break; } else { goto value_too_long; } } /* Fall through */ case miJUNK_LINE: if (c == '\n') { me->state = miNEWLINE; me->fold_state = me->state; } break; } /* switch on state*/ return; value_too_long: CTRACE(tfp, "HTMIME: *** Syntax error. (string too long)\n"); bad_field_name: /* Ignore it */ me->state = miJUNK_LINE; return; } /* String handling ** --------------- ** ** Strings must be smaller than this buffer size. */ PRIVATE void HTMIME_put_string ARGS2( HTStream *, me, CONST char *, s) { CONST char * p; if (me->state == MIME_TRANSPARENT) { /* Optimisation */ (*me->targetClass.put_string)(me->target,s); } else if (me->state != MIME_IGNORE) { CTRACE(tfp, "HTMIME: %s\n", s); for (p=s; *p; p++) HTMIME_put_character(me, *p); } } /* Buffer write. Buffers can (and should!) be big. ** ------------ */ PRIVATE void HTMIME_write ARGS3( HTStream *, me, CONST char *, s, int, l) { CONST char * p; if (me->state == MIME_TRANSPARENT) { /* Optimisation */ (*me->targetClass.put_block)(me->target, s, l); } else { CTRACE(tfp, "HTMIME: %.*s\n", l, s); for (p = s; p < s+l; p++) HTMIME_put_character(me, *p); } } /* Free an HTML object ** ------------------- ** */ PRIVATE void HTMIME_free ARGS1( HTStream *, me) { if (me->target) (*me->targetClass._free)(me->target); FREE(me); } /* End writing */ PRIVATE void HTMIME_abort ARGS2( HTStream *, me, HTError, e) { if (me->target) (*me->targetClass._abort)(me->target, e); FREE(me); } /* Structured Object Class ** ----------------------- */ PRIVATE CONST HTStreamClass HTMIME = { "MIMEParser", HTMIME_free, HTMIME_abort, HTMIME_put_character, HTMIME_put_string, HTMIME_write }; /* Subclass-specific Methods ** ------------------------- */ PUBLIC HTStream* HTMIMEConvert ARGS3( HTPresentation *, pres, HTParentAnchor *, anchor, HTStream *, sink) { HTStream* me; me = (HTStream *)calloc(1, sizeof(*me)); if (me == NULL) outofmem(__FILE__, "HTMIMEConvert"); me->isa = &HTMIME; me->sink = sink; me->anchor = anchor; me->anchor->safe = FALSE; me->anchor->no_cache = FALSE; FREE(me->anchor->cache_control); FREE(me->anchor->SugFname); FREE(me->anchor->charset); FREE(me->anchor->content_language); FREE(me->anchor->content_encoding); FREE(me->anchor->content_base); FREE(me->anchor->content_disposition); FREE(me->anchor->content_location); FREE(me->anchor->content_md5); me->anchor->content_length = 0; FREE(me->anchor->date); FREE(me->anchor->expires); FREE(me->anchor->last_modified); FREE(me->anchor->ETag); FREE(me->anchor->server); me->target = NULL; me->state = miBEGINNING_OF_LINE; /* * Sadly enough, change this to always default to WWW_HTML * to parse all text as HTML for the users. * GAB 06-30-94 * Thanks to Robert Rowland robert@cyclops.pei.edu * * After discussion of the correct handline, should be application/octet- * stream or unknown; causing servers to send a correct content * type. * * The consequence of using WWW_UNKNOWN is that you end up downloading * as a binary file what 99.9% of the time is an HTML file, which should * have been rendered or displayed. So sadly enough, I'm changing it * back to WWW_HTML, and it will handle the situation like Mosaic does, * and as Robert Rowland suggested, because being functionally correct * 99.9% of the time is better than being technically correct but * functionally nonsensical. - FM *//*** me->format = WWW_UNKNOWN; ***/ me->format = WWW_HTML; me->targetRep = pres->rep_out; me->boundary = NULL; /* Not set yet */ me->set_cookie = NULL; /* Not set yet */ me->set_cookie2 = NULL; /* Not set yet */ me->encoding = 0; /* Not set yet */ me->compression_encoding = NULL; /* Not set yet */ me->net_ascii = NO; /* Local character set */ HTAnchor_setUCInfoStage(me->anchor, current_char_set, UCT_STAGE_STRUCTURED, UCT_SETBY_DEFAULT); HTAnchor_setUCInfoStage(me->anchor, current_char_set, UCT_STAGE_HTEXT, UCT_SETBY_DEFAULT); return me; } PUBLIC HTStream* HTNetMIME ARGS3( HTPresentation *, pres, HTParentAnchor *, anchor, HTStream *, sink) { HTStream* me = HTMIMEConvert(pres,anchor, sink); if (!me) return NULL; me->net_ascii = YES; return me; } /* Japanese header handling functions ** ================================== ** ** K&Rized and added 07-Jun-96 by FM, based on: ** //////////////////////////////////////////////////////////////////////// ** ** ISO-2022-JP handling routines ** & ** MIME decode routines (quick hack just for ISO-2022-JP) ** ** Thu Jan 25 10:11:42 JST 1996 ** ** Copyright (C) 1994, 1995, 1996 ** Shuichi Ichikawa (ichikawa@nuee.nagoya-u.ac.jp) ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either versions 2, or (at your option) ** any later version. ** ** This program is distributed in the hope that it will be useful ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with SKK, see the file COPYING. If not, write to the Free ** Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* ** MIME decoding routines ** ** Written by S. Ichikawa, ** partially inspired by encdec.c of . */ #define BUFLEN 1024 #ifdef ESC #undef ESC #endif /* ESC */ #include /* S/390 -- gil -- 0163 */ #define ESC CH_ESC PRIVATE char HTmm64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ; PRIVATE char HTmmquote[] = "0123456789ABCDEF"; PRIVATE int HTmmcont = 0; PUBLIC void HTmmdec_base64 ARGS2( char *, t, char *, s) { int d, count, j, val; char buf[BUFLEN], *bp, nw[4], *p; for (bp = buf; *s; s += 4) { val = 0; if (s[2] == '=') count = 1; else if (s[3] == '=') count = 2; else count = 3; for (j = 0; j <= count; j++) { if (!(p = strchr(HTmm64, s[j]))) { return; } d = p - HTmm64; d <<= (3-j)*6; val += d; } for (j = 2; j >= 0; j--) { nw[j] = val & 255; val >>= 8; } if (count--) *bp++ = nw[0]; if (count--) *bp++ = nw[1]; if (count) *bp++ = nw[2]; } *bp = '\0'; strcpy(t, buf); } PUBLIC void HTmmdec_quote ARGS2( char *, t, char *, s) { char buf[BUFLEN], cval, *bp, *p; for (bp = buf; *s; ) { if (*s == '=') { cval = 0; if (s[1] && (p = strchr(HTmmquote, s[1]))) { cval += (p - HTmmquote); } else { *bp++ = *s++; continue; } if (s[2] && (p = strchr(HTmmquote, s[2]))) { cval <<= 4; cval += (p - HTmmquote); *bp++ = cval; s += 3; } else { *bp++ = *s++; } } else if (*s == '_') { *bp++ = 0x20; s++; } else { *bp++ = *s++; } } *bp = '\0'; strcpy(t, buf); } #ifdef NOTDEFINED /* ** Generalized HTmmdecode for chartrans - K. Weide 1997-03-06 */ PUBLIC void HTmmdecode ARGS2( char *, trg, char *, str) { char buf[BUFLEN], mmbuf[BUFLEN]; char *s, *t, *u, *qm2; int base64, quote; buf[0] = '\0'; /* ** Encoded-words look like ** =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?= */ for (s = str, u = buf; *s; ) { base64 = quote = 0; if (*s == '=' && s[1] == '?' && (s == str || *(s-1) == '(' || WHITE(*(s-1)))) { /* must be beginning of word */ qm2 = strchr(s+2, '?'); /* 2nd question mark */ if (qm2 && (qm2[1] == 'B' || qm2[1] == 'b' || qm2[1] == 'Q' || qm2[1] == 'q') && qm2[2] == '?') { /* 3rd question mark */ char * qm4 = strchr(qm2 + 3, '?'); /* 4th question mark */ if (qm4 && qm4 - s < 74 && /* RFC 2047 length restriction */ qm4[1] == '=') { char *p; BOOL invalid = NO; for (p = s+2; p < qm4; p++) if (WHITE(*p)) { invalid = YES; break; } if (!invalid) { int LYhndl; *qm2 = '\0'; invalid = ((LYhndl = UCGetLYhndl_byMIME(s+2)) < 0 || UCCanTranslateFromTo(LYhndl, current_char_set)); *qm2 = '?'; } if (!invalid) { if (qm2[1] == 'B' || qm2[1] == 'b') base64 = 1; else if (qm2[1] == 'Q' || qm2[1] == 'q') quote = 1; } } } } if (base64 || quote) { if (HTmmcont) { for (t = s - 1; t >= str && (*t == ' ' || *t == '\t'); t--) { u--; } } for (s = qm2 + 3, t = mmbuf; *s; ) { if (s[0] == '?' && s[1] == '=') { break; } else { *t++ = *s++; } } if (s[0] != '?' || s[1] != '=') { goto end; } else { s += 2; *t = '\0'; } if (base64) HTmmdec_base64(mmbuf, mmbuf); if (quote) HTmmdec_quote(mmbuf, mmbuf); for (t = mmbuf; *t; ) *u++ = *t++; HTmmcont = 1; /* if (*s == ' ' || *s == '\t') *u++ = *s; */ /* for ( ; *s == ' ' || *s == '\t'; s++) ; */ } else { if (*s != ' ' && *s != '\t') HTmmcont = 0; *u++ = *s++; } } *u = '\0'; end: strcpy(trg, buf); } #else /* ** HTmmdecode for ISO-2022-JP - FM */ PUBLIC void HTmmdecode ARGS2( char *, trg, char *, str) { char buf[BUFLEN], mmbuf[BUFLEN]; char *s, *t, *u; int base64, quote; buf[0] = '\0'; for (s = str, u = buf; *s; ) { if (!strncasecomp(s, "=?ISO-2022-JP?B?", 16)) { base64 = 1; } else { base64 = 0; } if (!strncasecomp(s, "=?ISO-2022-JP?Q?", 16)) { quote = 1; } else { quote = 0; } if (base64 || quote) { if (HTmmcont) { for (t = s - 1; t >= str && (*t == ' ' || *t == '\t'); t--) { u--; } } for (s += 16, t = mmbuf; *s; ) { if (s[0] == '?' && s[1] == '=') { break; } else { *t++ = *s++; } } if (s[0] != '?' || s[1] != '=') { goto end; } else { s += 2; *t = '\0'; } if (base64) HTmmdec_base64(mmbuf, mmbuf); if (quote) HTmmdec_quote(mmbuf, mmbuf); for (t = mmbuf; *t; ) *u++ = *t++; HTmmcont = 1; /* if (*s == ' ' || *s == '\t') *u++ = *s; */ /* for ( ; *s == ' ' || *s == '\t'; s++) ; */ } else { if (*s != ' ' && *s != '\t') HTmmcont = 0; *u++ = *s++; } } *u = '\0'; end: strcpy(trg, buf); } #endif /* NOTDEFINED */ /* ** Insert ESC where it seems lost. ** (The author of this function "rjis" is S. Ichikawa.) */ PUBLIC int HTrjis ARGS2( char *, t, char *, s) { char *p, buf[BUFLEN]; int kanji = 0; if (strchr(s, ESC) || !strchr(s, '$')) { if (s != t) strcpy(t, s); return 1; } for (p = buf; *s; ) { if (!kanji && s[0] == '$' && (s[1] == '@' || s[1] == 'B')) { if (HTmaybekanji((int)s[2], (int)s[3])) { kanji = 1; *p++ = ESC; *p++ = *s++; *p++ = *s++; *p++ = *s++; *p++ = *s++; continue; } *p++ = *s++; continue; } if (kanji && s[0] == '(' && (s[1] == 'J' || s[1] == 'B')) { kanji = 0; *p++ = ESC; *p++ = *s++; *p++ = *s++; continue; } *p++ = *s++; } *p = *s; /* terminate string */ strcpy(t, buf); return 0; } /* ** The following function "maybekanji" is derived from ** RJIS-1.0 by Mr. Hironobu Takahashi. ** Maybekanji() is included here under the courtesy of the author. ** The original comment of rjis.c is also included here. */ /* * RJIS ( Recover JIS code from broken file ) * $Header: rjis.c,v 0.2 92/09/04 takahasi Exp $ * Copyright (C) 1992 1994 * Hironobu Takahashi (takahasi@tiny.or.jp) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either versions 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with SKK, see the file COPYING. If not, write to the Free * Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ PUBLIC int HTmaybekanji ARGS2( int, c1, int, c2) { if ((c2 < 33) || (c2 > 126)) return 0; if ((c1 < 33) || ((40 < c1) && (c1 < 48)) || (116 < c1)) return 0; c2 -= 32; switch(c1-32) { case 2: if ((14 < c2) && ( c2 < 26)) return 0; if ((33 < c2) && ( c2 < 42)) return 0; if ((48 < c2) && ( c2 < 60)) return 0; if ((74 < c2) && ( c2 < 82)) return 0; if ((89 < c2) && ( c2 < 94)) return 0; break; case 3: if (c2 < 16) return 0; if ((25 < c2) && ( c2 < 33)) return 0; if ((58 < c2) && ( c2 < 65)) return 0; if (90 < c2) return 0; break; case 4: if (83 < c2) return 0; break; case 5: if (86 < c2) return 0; break; case 6: if ((24 < c2) && ( c2 < 33)) return 0; if (56 < c2) return 0; break; case 7: if ((33 < c2) && ( c2 < 49)) return 0; if (81 < c2) return 0; break; case 8: if (32 < c2) return 0; break; case 47: if (51 < c2) return 0; break; case 84: if (6 < c2) return 0; break; } return 1; }