/*
* $LynxId: HTMIME.c,v 1.100 2018/03/11 21:32:38 tom Exp $
*
* 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
*
*/
#define HTSTREAM_INTERNAL 1
#include <HTUtils.h>
#include <HTMIME.h> /* Implemented here */
#include <HTTP.h> /* for redirecting_url */
#include <HTAlert.h>
#include <HTFile.h>
#include <HTCJK.h>
#include <UCMap.h>
#include <UCDefs.h>
#include <UCAux.h>
#include <LYCookie.h>
#include <LYCharSets.h>
#include <LYCharUtils.h>
#include <LYStrings.h>
#include <LYUtils.h>
#include <LYGlobalDefs.h>
#include <LYLeaks.h>
/* MIME Object
* -----------
*/
typedef enum {
MIME_TRANSPARENT, /* put straight through to target ASAP! */
/* states for "Transfer-Encoding: chunked" */
MIME_CHUNKED,
mcCHUNKED_COUNT_DIGIT,
mcCHUNKED_COUNT_CR,
mcCHUNKED_COUNT_LF,
mcCHUNKED_EXTENSION,
mcCHUNKED_DATA,
mcCHUNKED_DATA_CR,
mcCHUNKED_DATA_LF,
/* character state-machine */
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,
miR,
miRE,
miREFRESH,
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 */
BOOL head_only; /* only parsing header */
BOOL pickup_redirection; /* parsing for location */
BOOL no_streamstack; /* use sink directly */
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 */
char *location; /* Location */
char *refresh_url; /* "Refresh:" URL */
HTFormat c_t_encoding; /* Content-Transfer-Encoding */
char *compression_encoding;
BOOL chunked_encoding; /* Transfer-Encoding: chunked */
long chunked_size; /* ...counter for "chunked" */
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
*/
void HTMIME_TrimDoubleQuotes(char *value)
{
size_t i;
char *cp = value;
if (isEmpty(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)];
}
/*
* Check if the token from "Content-Encoding" corresponds to a compression
* type.
*/
static BOOL content_is_compressed(HTStream *me)
{
char *encoding = me->anchor->content_encoding;
BOOL result = (BOOL) (HTEncodingToCompressType(encoding) != cftNone);
CTRACE((tfp, "content is%s compressed\n", result ? "" : " NOT"));
return result;
}
/*
* Strip quotes from a refresh-URL.
*/
static void dequote(char *url)
{
size_t len;
len = strlen(url);
if (*url == '\'' && len > 1 && url[len - 1] == url[0]) {
url[len - 1] = '\0';
while ((url[0] = url[1]) != '\0') {
++url;
}
}
}
/*
* Strip off any compression-suffix from the address and check if the result
* looks like one of the presentable suffixes. If so, return the corresponding
* MIME type.
*/
static const char *UncompressedContentType(HTStream *me, CompressFileType method)
{
const char *result = 0;
char *address = me->anchor->address;
const char *expected = HTCompressTypeToSuffix(method);
const char *actual = strrchr(address, '.');
/*
* We have to ensure the suffix is consistent, to use HTFileFormat().
*/
if (actual != 0 && !strcasecomp(actual, expected)) {
HTFormat format;
HTAtom *pencoding = 0;
const char *description = 0;
format = HTFileFormat(address, &pencoding, &description);
result = HTAtom_name(format);
}
return result;
}
static int pumpData(HTStream *me)
{
CompressFileType method;
const char *new_encoding;
const char *new_content;
CTRACE((tfp, "Begin pumpData\n"));
/*
* If the content-type says it is compressed, and there is no
* content-encoding, check further and see if the address (omitting the
* suffix for a compressed type) looks like a type we can present. If so,
* rearrange things so we'll present the StreamStack code with the
* presentable type, already marked as compressed.
*/
CTRACE((tfp, "...address{%s}\n", me->anchor->address));
method = HTContentTypeToCompressType(me->anchor->content_type_params);
if (isEmpty(me->anchor->content_encoding))
me->anchor->no_content_encoding = TRUE;
if ((method != cftNone)
&& isEmpty(me->anchor->content_encoding)
&& (new_content = UncompressedContentType(me, method)) != 0) {
new_encoding = HTCompressTypeToEncoding(method);
CTRACE((tfp, "reinterpreting as content-type:%s, encoding:%s\n",
new_content, new_encoding));
StrAllocCopy(me->anchor->content_encoding, new_encoding);
FREE(me->compression_encoding);
StrAllocCopy(me->compression_encoding, new_encoding);
LYStrNCpy(me->value, new_content, VALUE_SIZE - 1);
StrAllocCopy(me->anchor->content_type_params, me->value);
me->format = HTAtom_for(me->value);
}
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);
}
} else {
/*
* Something like 'big5' - we cannot translate it, but
* the user may still be able to navigate the links.
*/
*cp1 = '\0';
me->format = HTAtom_for(cp);
StrAllocCopy(me->anchor->charset, cp4);
HTAnchor_setUCInfoStage(me->anchor, chndl,
UCT_STAGE_MIME,
UCT_SETBY_MIME);
}
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)
#ifdef EXP_JAPANESEUTF8_SUPPORT
&& ((p_in->enc != UCT_ENC_UTF8)
|| (p_out->enc != UCT_ENC_CJK))
#endif
) {
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 =
(BOOL) (!StrNCmp(cp4, "iso-8859-", 9) &&
isdigit(UCH(cp4[9])));
BOOL given_is_8859like =
(BOOL) (given_is_8859 ||
!StrNCmp(cp4, "windows-", 8) ||
!StrNCmp(cp4, "cp12", 4) ||
!StrNCmp(cp4, "cp-12", 5));
BOOL given_and_display_8859like =
(BOOL) (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(UCH(*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->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);
}
if (me->pickup_redirection) {
if (me->location && *me->location) {
redirecting_url = me->location;
me->location = NULL;
if (me->targetRep != WWW_DEBUG || me->sink)
me->head_only = YES;
} else {
permanent_redirection = FALSE;
if (me->location) {
CTRACE((tfp, "HTTP: 'Location:' is zero-length!\n"));
HTAlert(REDIRECTION_WITH_BAD_LOCATION);
}
CTRACE((tfp, "HTTP: Failed to pick up location.\n"));
if (me->location) {
FREE(me->location);
} else {
HTAlert(REDIRECTION_WITH_NO_LOCATION);
}
}
}
CTRACE((tfp, "...pumpData finished reading header\n"));
if (me->head_only) {
/* We are done! - kw */
me->state = MIME_IGNORE;
} else {
if (me->no_streamstack) {
me->target = me->sink;
} else {
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)));
FREE(me->compression_encoding);
}
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;
/*
* Pump rest of data right through, according to the transfer encoding.
*/
me->state = (me->chunked_encoding
? MIME_CHUNKED
: MIME_TRANSPARENT);
} else {
me->state = MIME_IGNORE; /* What else to do? */
}
if (me->refresh_url != NULL && !content_is_compressed(me)) {
char *url = NULL;
char *num = NULL;
char *txt = NULL;
const char *base = ""; /* FIXME: refresh_url may be relative to doc */
LYParseRefreshURL(me->refresh_url, &num, &url);
if (url != NULL && me->format == WWW_HTML) {
CTRACE((tfp,
"Formatting refresh-url as first line of result\n"));
HTSprintf0(&txt, gettext("Refresh: "));
HTSprintf(&txt, gettext("%s seconds "), num);
dequote(url);
HTSprintf(&txt, "<a href=\"%s%s\">%s</a><br>", base, url, url);
CTRACE((tfp, "URL %s%s\n", base, url));
(me->isa->put_string) (me, txt);
free(txt);
}
FREE(num);
FREE(url);
}
}
CTRACE((tfp, "...end of pumpData, copied %"
PRI_off_t " vs %"
PRI_off_t "\n",
CAST_off_t (me->anchor->actual_length),
CAST_off_t (me->anchor->content_length)));
me->anchor->actual_length = 0;
return HT_OK;
}
static int dispatchField(HTStream *me)
{
int i, j;
char *cp;
*me->value_pointer = '\0';
cp = me->value_pointer;
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[0] == '\0')
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(UCH(*cp1))) {
cp0 = cp1;
while (isdigit(UCH(*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[0] == '\0')
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[0] == '\0')
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[0] == '\0' ||
!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 (content_is_compressed(me)) {
/*
* Save it to use as a flag for setting up a "www/compressed"
* target. - FM
*/
StrAllocCopy(me->compression_encoding, me->value);
} else {
/*
* Some server indicated "8bit", "7bit" or "binary"
* inappropriately. We'll ignore it. - FM
*/
CTRACE((tfp, " Ignoring it!\n"));
}
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[0] == '\0')
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[0] == '\0')
break;
/*
* Convert to integer and indicate in anchor. - FM
*/
me->anchor->content_length = LYatoll(me->value);
if (me->anchor->content_length < 0)
me->anchor->content_length = 0;
CTRACE((tfp, " Converted to integer: '%" PRI_off_t "'\n",
CAST_off_t (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[0] == '\0')
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[0] == '\0')
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[0] == '\0')
break;
/*
* Force the Content-Transfer-Encoding value to all lower case. - FM
*/
LYLowerCase(me->value);
me->c_t_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[0] == '\0')
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++] = (char) TOLOWER(me->value[i]);
}
}
me->value[j] = '\0';
me->format = HTAtom_for(me->value);
StrAllocCopy(me->anchor->content_type_params, me->value);
break;
case miDATE:
HTMIME_TrimDoubleQuotes(me->value);
CTRACE((tfp, "HTMIME: PICKED UP Date: '%s'\n",
me->value));
if (me->value[0] == '\0')
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[0] == '\0')
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[0] == '\0')
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[0] == '\0')
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));
if (me->pickup_redirection && !me->location) {
StrAllocCopy(me->location, me->value);
} else {
CTRACE((tfp, "HTMIME: *** Ignoring Location!\n"));
}
break;
case miPRAGMA:
HTMIME_TrimDoubleQuotes(me->value);
CTRACE((tfp, "HTMIME: PICKED UP Pragma: '%s'\n",
me->value));
if (me->value[0] == '\0')
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 miREFRESH: /* nonstandard: Netscape */
HTMIME_TrimDoubleQuotes(me->value);
CTRACE((tfp, "HTMIME: PICKED UP Refresh: '%s'\n",
me->value));
StrAllocCopy(me->refresh_url, 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[0] == '\0')
break;
/*
* Indicate in anchor if "YES" or "TRUE". - FM
*/
if (!strcasecomp(me->value, "YES") ||
!strcasecomp(me->value, "TRUE")) {
me->anchor->safe = TRUE;
} else if (!strcasecomp(me->value, "NO") ||
!strcasecomp(me->value, "FALSE")) {
/*
* If server explicitly tells us that it has changed its mind,
* reset flag in anchor. - kw
*/
me->anchor->safe = FALSE;
}
break;
case miSERVER:
HTMIME_TrimDoubleQuotes(me->value);
CTRACE((tfp, "HTMIME: PICKED UP Server: '%s'\n",
me->value));
if (me->value[0] == '\0')
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));
if (!strcmp(me->value, "chunked"))
me->chunked_encoding = YES;
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 */
return HT_ERROR;
}
return HT_OK;
}
/*_________________________________________________________________________
*
* A C T I O N R O U T I N E S
*/
/* Character handling
* ------------------
*
* This is a FSM parser. It ignores field names it does not understand.
* Folded header fields are recognized. Lines without a fieldname at
* the beginning (that are not folded continuation lines) are ignored
* as unknown field names. Fields with empty values are not picked up.
*/
static void HTMIME_put_character(HTStream *me, int c)
{
if (me->anchor->inHEAD) {
me->anchor->header_length++;
}
switch (me->state) {
begin_transparent:
case MIME_TRANSPARENT:
me->anchor->actual_length += 1;
(me->targetClass.put_character) (me->target, c);
return;
/* RFC-2616 describes chunked transfer coding */
case mcCHUNKED_DATA:
(*me->targetClass.put_character) (me->target, c);
me->chunked_size--;
if (me->chunked_size <= 0)
me->state = mcCHUNKED_DATA_CR;
return;
case mcCHUNKED_DATA_CR:
me->state = mcCHUNKED_DATA_LF;
if (c == CR) {
return;
}
/* FALLTHRU */
case mcCHUNKED_DATA_LF:
me->state = MIME_CHUNKED;
if (c == LF) {
return;
}
CTRACE((tfp, "HTIME_put_character expected LF in chunked data\n"));
me->state = MIME_TRANSPARENT;
goto begin_transparent;
/* FALLTHRU */
begin_chunked:
case MIME_CHUNKED:
me->chunked_size = 0;
me->state = mcCHUNKED_COUNT_DIGIT;
/* FALLTHRU */
case mcCHUNKED_COUNT_DIGIT:
if (isxdigit(UCH(c))) {
me->chunked_size <<= 4;
if (isdigit(UCH(c)))
me->chunked_size += UCH(c) - '0';
else
me->chunked_size += TOUPPER(UCH(c)) - 'A' + 10;
return;
}
if (c == ';')
me->state = mcCHUNKED_EXTENSION;
/* FALLTHRU */
case mcCHUNKED_EXTENSION:
if (c != CR && c != LF) {
return;
}
me->state = mcCHUNKED_COUNT_CR;
/* FALLTHRU */
case mcCHUNKED_COUNT_CR:
me->state = mcCHUNKED_COUNT_LF;
if (c == CR) {
return;
}
/* FALLTHRU */
case mcCHUNKED_COUNT_LF:
me->state = ((me->chunked_size != 0)
? mcCHUNKED_DATA
: MIME_CHUNKED);
if (c == LF) {
return;
}
goto begin_chunked;
default:
break;
}
/*
* 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) {
/*
* <sigh> 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 */
case MIME_CHUNKED:
case mcCHUNKED_COUNT_DIGIT:
case mcCHUNKED_COUNT_CR:
case mcCHUNKED_COUNT_LF:
case mcCHUNKED_EXTENSION:
case mcCHUNKED_DATA:
case mcCHUNKED_DATA_CR:
case mcCHUNKED_DATA_LF:
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 */
if (me->state == miGET_VALUE &&
me->value_pointer && me->value_pointer != me->value &&
!WHITE(*(me->value_pointer - 1))) {
c = ' ';
goto GET_VALUE; /* will add space to value if it fits - kw */
}
break;
} else if (me->fold_state == miGET_VALUE) {
/* Got a field, and now we know it's complete - so
* act on it. - kw */
dispatchField(me);
}
/* FALLTHRU */
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->state = miR;
CTRACE((tfp, "HTMIME: Got 'R' at beginning of line, state now R\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->anchor->inHEAD = FALSE;
CTRACE((tfp, "HTMIME length %" PRI_off_t "\n",
CAST_off_t (me->anchor->header_length)));
me->net_ascii = NO;
pumpData(me);
}
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 miR: /* Check for 'e' */
switch (c) {
case 'e':
case 'E':
me->state = miRE;
CTRACE((tfp, "HTMIME: Was R, found E\n"));
break;
default:
CTRACE((tfp,
"HTMIME: Bad character `%c' found where `%s' expected\n",
c, "'e'"));
goto bad_field_name;
} /* switch on character */
break;
case miRE: /* Check for 'a' or 'o' */
switch (c) {
case 'f':
case 'F': /* nonstandard: Netscape */
me->check_pointer = "resh:";
me->if_ok = miREFRESH;
me->state = miCHECK;
CTRACE((tfp, "HTMIME: Was RE, found F, checking for '%s'\n", me->check_pointer));
break;
case 't':
case 'T':
me->check_pointer = "ry-after:";
me->if_ok = miRETRY_AFTER;
me->state = miCHECK;
CTRACE((tfp, "HTMIME: Was RE, found T, checking for '%s'\n", me->check_pointer));
break;
default:
CTRACE((tfp,
"HTMIME: Bad character `%c' found where `%s' expected\n",
c, "'f' or 't'"));
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 miREFRESH:
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;
/* FALLTHRU */
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 */
/* FALLTHRU */
case miGET_VALUE:
GET_VALUE:
if (c != '\n') { /* Not end of line */
if (me->value_pointer < me->value + VALUE_SIZE - 1) {
*me->value_pointer++ = (char) c;
break;
} else {
goto value_too_long;
}
}
/* Fall through (if end of line) */
/* FALLTHRU */
case miJUNK_LINE:
if (c == '\n') {
me->fold_state = me->state;
me->state = miNEWLINE;
}
break;
} /* switch on state */
HTChunkPutc(&me->anchor->http_headers, UCH(c));
if (me->state == MIME_TRANSPARENT) {
HTChunkTerminate(&me->anchor->http_headers);
CTRACE((tfp, "Server Headers (%d bytes):\n%.*s\n",
me->anchor->http_headers.size,
me->anchor->http_headers.size,
me->anchor->http_headers.data));
CTRACE((tfp, "Server Content-Type:%s\n",
me->anchor->content_type_params));
}
return;
value_too_long:
CTRACE((tfp, "HTMIME: *** Syntax error. (string too long)\n"));
bad_field_name: /* Ignore it */
me->state = miJUNK_LINE;
HTChunkPutc(&me->anchor->http_headers, UCH(c));
return;
}
/* String handling
* ---------------
*
* Strings must be smaller than this buffer size.
*/
static void HTMIME_put_string(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.
* ------------
*/
static void HTMIME_write(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
* -------------------
*
*/
static void HTMIME_free(HTStream *me)
{
if (me) {
FREE(me->location);
FREE(me->compression_encoding);
if (me->target)
(*me->targetClass._free) (me->target);
FREE(me);
}
}
/* End writing
*/
static void HTMIME_abort(HTStream *me,
HTError e)
{
if (me) {
FREE(me->location);
FREE(me->compression_encoding);
if (me->target)
(*me->targetClass._abort) (me->target, e);
FREE(me);
}
}
/* Structured Object Class
* -----------------------
*/
static const HTStreamClass HTMIME =
{
"MIMEParser",
HTMIME_free,
HTMIME_abort,
HTMIME_put_character,
HTMIME_put_string,
HTMIME_write
};
/* Subclass-specific Methods
* -------------------------
*/
HTStream *HTMIMEConvert(HTPresentation *pres,
HTParentAnchor *anchor,
HTStream *sink)
{
HTStream *me;
CTRACE((tfp, "HTMIMEConvert\n"));
me = typecalloc(HTStream);
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);
HTChunkClear(&me->anchor->http_headers);
HTChunkInit(&me->anchor->http_headers, 128);
FREE(me->anchor->content_type_params);
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->inHEAD = TRUE;
me->anchor->header_length = 0;
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;
me->format = HTAtom_for(ContentTypes[LYContentType]);
CTRACE((tfp, "default Content-Type is %s\n", HTAtom_name(me->format)));
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->refresh_url = NULL; /* Not set yet */
me->c_t_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;
}
HTStream *HTNetMIME(HTPresentation *pres,
HTParentAnchor *anchor,
HTStream *sink)
{
HTStream *me = HTMIMEConvert(pres, anchor, sink);
if (!me)
return NULL;
me->net_ascii = YES;
return me;
}
HTStream *HTMIMERedirect(HTPresentation *pres,
HTParentAnchor *anchor,
HTStream *sink)
{
HTStream *me = HTMIMEConvert(pres, anchor, sink);
if (!me)
return NULL;
me->pickup_redirection = YES;
if (me->targetRep == WWW_DEBUG && sink)
me->no_streamstack = 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 <jh@efd.lth.se>.
* Caller's buffers decode to no longer than the input strings.
*/
#include <LYCharVals.h> /* S/390 -- gil -- 0163 */
static char HTmm64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
static char HTmmquote[] = "0123456789ABCDEF";
static int HTmmcont = 0;
static void HTmmdec_base64(char **t,
char *s)
{
int d, count, j, val;
char *buf, *bp, nw[4], *p;
if ((buf = typeMallocn(char, strlen(s) * 3 + 1)) == 0)
outofmem(__FILE__, "HTmmdec_base64");
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]))) {
FREE(buf);
return;
}
d = (int) (p - HTmm64);
d <<= (3 - j) * 6;
val += d;
}
for (j = 2; j >= 0; j--) {
nw[j] = (char) (val & 255);
val >>= 8;
}
if (count--)
*bp++ = nw[0];
if (count--)
*bp++ = nw[1];
if (count)
*bp++ = nw[2];
}
*bp = '\0';
StrAllocCopy(*t, buf);
FREE(buf);
}
static void HTmmdec_quote(char **t,
char *s)
{
char *buf, cval, *bp, *p;
if ((buf = typeMallocn(char, strlen(s) + 1)) == 0)
outofmem(__FILE__, "HTmmdec_quote");
for (bp = buf; *s;) {
if (*s == '=') {
cval = 0;
if (s[1] && (p = StrChr(HTmmquote, s[1]))) {
cval = (char) (cval + (char) (p - HTmmquote));
} else {
*bp++ = *s++;
continue;
}
if (s[2] && (p = StrChr(HTmmquote, s[2]))) {
cval = (char) (cval << 4);
cval = (char) (cval + (p - HTmmquote));
*bp++ = cval;
s += 3;
} else {
*bp++ = *s++;
}
} else if (*s == '_') {
*bp++ = 0x20;
s++;
} else {
*bp++ = *s++;
}
}
*bp = '\0';
StrAllocCopy(*t, buf);
FREE(buf);
}
/*
* HTmmdecode for ISO-2022-JP - FM
*/
void HTmmdecode(char **target,
char *source)
{
char *buf;
char *mmbuf = NULL;
char *m2buf = NULL;
char *s, *t, *u;
int base64, quote;
if ((buf = typeMallocn(char, strlen(source) + 1)) == 0)
outofmem(__FILE__, "HTmmdecode");
for (s = source, 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 >= source && (*t == ' ' || *t == '\t'); t--) {
u--;
}
}
if (mmbuf == 0) /* allocate buffer big enough for source */
StrAllocCopy(mmbuf, source);
for (s += 16, t = mmbuf; *s;) {
if (s[0] == '?' && s[1] == '=') {
break;
} else {
*t++ = *s++;
*t = '\0';
}
}
if (s[0] != '?' || s[1] != '=') {
goto end;
} else {
s += 2;
*t = '\0';
}
if (base64)
HTmmdec_base64(&m2buf, mmbuf);
else
HTmmdec_quote(&m2buf, mmbuf);
for (t = m2buf; non_empty(t);)
*u++ = *t++;
HTmmcont = 1;
} else {
if (*s != ' ' && *s != '\t')
HTmmcont = 0;
*u++ = *s++;
}
}
*u = '\0';
end:
StrAllocCopy(*target, buf);
FREE(m2buf);
FREE(mmbuf);
FREE(buf);
}
/*
* Insert ESC where it seems lost.
* (The author of this function "rjis" is S. Ichikawa.)
*/
int HTrjis(char **t,
char *s)
{
char *p;
char *buf = NULL;
int kanji = 0;
if (StrChr(s, CH_ESC) || !StrChr(s, '$')) {
if (s != *t)
StrAllocCopy(*t, s);
return 1;
}
if ((buf = typeMallocn(char, strlen(s) * 2 + 1)) == 0)
outofmem(__FILE__, "HTrjis");
for (p = buf; *s;) {
if (!kanji && s[0] == '$' && (s[1] == '@' || s[1] == 'B')) {
if (HTmaybekanji((int) s[2], (int) s[3])) {
kanji = 1;
*p++ = CH_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++ = CH_ESC;
*p++ = *s++;
*p++ = *s++;
continue;
}
*p++ = *s++;
}
*p = *s; /* terminate string */
StrAllocCopy(*t, buf);
FREE(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 )
* 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.
*/
int HTmaybekanji(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;
}