1127 lines
20 KiB
C
1127 lines
20 KiB
C
#include <u.h>
|
|
#include <libc.h>
|
|
#include <ctype.h>
|
|
#include <libsec.h>
|
|
#include <bin.h>
|
|
#include <httpd.h>
|
|
#include "escape.h"
|
|
|
|
typedef struct Hlex Hlex;
|
|
typedef struct MimeHead MimeHead;
|
|
|
|
enum
|
|
{
|
|
/*
|
|
* tokens
|
|
*/
|
|
Word = 1,
|
|
QString,
|
|
};
|
|
|
|
#define UlongMax 4294967295UL
|
|
|
|
struct Hlex
|
|
{
|
|
int tok;
|
|
int eoh;
|
|
int eol; /* end of header line encountered? */
|
|
uchar *hstart; /* start of header */
|
|
jmp_buf jmp; /* jmp here to parse header */
|
|
char wordval[HMaxWord];
|
|
HConnect *c;
|
|
};
|
|
|
|
struct MimeHead
|
|
{
|
|
char *name;
|
|
void (*parse)(Hlex*, char*);
|
|
uchar seen;
|
|
uchar ignore;
|
|
};
|
|
|
|
static void mimeaccept(Hlex*, char*);
|
|
static void mimeacceptchar(Hlex*, char*);
|
|
static void mimeacceptenc(Hlex*, char*);
|
|
static void mimeacceptlang(Hlex*, char*);
|
|
static void mimeagent(Hlex*, char*);
|
|
static void mimeauthorization(Hlex*, char*);
|
|
static void mimeconnection(Hlex*, char*);
|
|
static void mimecontlen(Hlex*, char*);
|
|
static void mimecookie(Hlex*, char*);
|
|
static void mimeexpect(Hlex*, char*);
|
|
static void mimefresh(Hlex*, char*);
|
|
static void mimefrom(Hlex*, char*);
|
|
static void mimehost(Hlex*, char*);
|
|
static void mimeifrange(Hlex*, char*);
|
|
static void mimeignore(Hlex*, char*);
|
|
static void mimematch(Hlex*, char*);
|
|
static void mimemodified(Hlex*, char*);
|
|
static void mimenomatch(Hlex*, char*);
|
|
static void mimerange(Hlex*, char*);
|
|
static void mimetransenc(Hlex*, char*);
|
|
static void mimeunmodified(Hlex*, char*);
|
|
|
|
/*
|
|
* headers seen also include
|
|
* allow cache-control chargeto
|
|
* content-encoding content-language content-location content-md5 content-range content-type
|
|
* date etag expires forwarded last-modified max-forwards pragma
|
|
* proxy-agent proxy-authorization proxy-connection
|
|
* ua-color ua-cpu ua-os ua-pixels
|
|
* upgrade via x-afs-tokens x-serial-number
|
|
*/
|
|
static MimeHead mimehead[] =
|
|
{
|
|
{"accept", mimeaccept},
|
|
{"accept-charset", mimeacceptchar},
|
|
{"accept-encoding", mimeacceptenc},
|
|
{"accept-language", mimeacceptlang},
|
|
{"authorization", mimeauthorization},
|
|
{"connection", mimeconnection},
|
|
{"content-length", mimecontlen},
|
|
{"cookie", mimecookie},
|
|
{"expect", mimeexpect},
|
|
{"fresh", mimefresh},
|
|
{"from", mimefrom},
|
|
{"host", mimehost},
|
|
{"if-match", mimematch},
|
|
{"if-modified-since", mimemodified},
|
|
{"if-none-match", mimenomatch},
|
|
{"if-range", mimeifrange},
|
|
{"if-unmodified-since", mimeunmodified},
|
|
{"range", mimerange},
|
|
{"transfer-encoding", mimetransenc},
|
|
{"user-agent", mimeagent},
|
|
};
|
|
|
|
char* hmydomain;
|
|
char* hversion = "HTTP/1.1";
|
|
|
|
static void lexhead(Hlex*);
|
|
static void parsejump(Hlex*, char*);
|
|
static int getc(Hlex*);
|
|
static void ungetc(Hlex*);
|
|
static int wordcr(Hlex*);
|
|
static int wordnl(Hlex*);
|
|
static void word(Hlex*, char*);
|
|
static int lex1(Hlex*, int);
|
|
static int lex(Hlex*);
|
|
static int lexbase64(Hlex*);
|
|
static ulong digtoul(char *s, char **e);
|
|
|
|
/*
|
|
* flush and clean up junk from a request
|
|
*/
|
|
void
|
|
hreqcleanup(HConnect *c)
|
|
{
|
|
int i;
|
|
|
|
hxferenc(&c->hout, 0);
|
|
memset(&c->req, 0, sizeof(c->req));
|
|
memset(&c->head, 0, sizeof(c->head));
|
|
c->hpos = c->header;
|
|
c->hstop = c->header;
|
|
binfree(&c->bin);
|
|
for(i = 0; i < nelem(mimehead); i++){
|
|
mimehead[i].seen = 0;
|
|
mimehead[i].ignore = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* list of tokens
|
|
* if the client is HTTP/1.0,
|
|
* ignore headers which match one of the tokens.
|
|
* restarts parsing if necessary.
|
|
*/
|
|
static void
|
|
mimeconnection(Hlex *h, char *)
|
|
{
|
|
char *u, *p;
|
|
int reparse, i;
|
|
|
|
reparse = 0;
|
|
for(;;){
|
|
while(lex(h) != Word)
|
|
if(h->tok != ',')
|
|
goto breakout;
|
|
|
|
if(cistrcmp(h->wordval, "keep-alive") == 0)
|
|
h->c->head.persist = 1;
|
|
else if(cistrcmp(h->wordval, "close") == 0)
|
|
h->c->head.closeit = 1;
|
|
else if(!http11(h->c)){
|
|
for(i = 0; i < nelem(mimehead); i++){
|
|
if(cistrcmp(mimehead[i].name, h->wordval) == 0){
|
|
reparse = mimehead[i].seen && !mimehead[i].ignore;
|
|
mimehead[i].ignore = 1;
|
|
if(cistrcmp(mimehead[i].name, "authorization") == 0){
|
|
h->c->head.authuser = nil;
|
|
h->c->head.authpass = nil;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(lex(h) != ',')
|
|
break;
|
|
}
|
|
|
|
breakout:;
|
|
/*
|
|
* if need to ignore headers we've already parsed,
|
|
* reset & start over. need to save authorization
|
|
* info because it's written over when parsed.
|
|
*/
|
|
if(reparse){
|
|
u = h->c->head.authuser;
|
|
p = h->c->head.authpass;
|
|
memset(&h->c->head, 0, sizeof(h->c->head));
|
|
h->c->head.authuser = u;
|
|
h->c->head.authpass = p;
|
|
|
|
h->c->hpos = h->hstart;
|
|
longjmp(h->jmp, 1);
|
|
}
|
|
}
|
|
|
|
int
|
|
hparseheaders(HConnect *c, int timeout)
|
|
{
|
|
Hlex h;
|
|
|
|
c->head.fresh_thresh = 0;
|
|
c->head.fresh_have = 0;
|
|
c->head.persist = 0;
|
|
if(c->req.vermaj == 0){
|
|
c->head.host = hmydomain;
|
|
return 1;
|
|
}
|
|
|
|
memset(&h, 0, sizeof(h));
|
|
h.c = c;
|
|
if(timeout)
|
|
alarm(timeout);
|
|
if(hgethead(c, 1) < 0)
|
|
return -1;
|
|
if(timeout)
|
|
alarm(0);
|
|
h.hstart = c->hpos;
|
|
|
|
if(setjmp(h.jmp) == -1)
|
|
return -1;
|
|
|
|
h.eol = 0;
|
|
h.eoh = 0;
|
|
h.tok = '\n';
|
|
while(lex(&h) != '\n'){
|
|
if(h.tok == Word && lex(&h) == ':')
|
|
parsejump(&h, hstrdup(c, h.wordval));
|
|
while(h.tok != '\n')
|
|
lex(&h);
|
|
h.eol = h.eoh;
|
|
}
|
|
|
|
if(http11(c)){
|
|
/*
|
|
* according to the http/1.1 spec,
|
|
* these rules must be followed
|
|
*/
|
|
if(c->head.host == nil){
|
|
hfail(c, HBadReq, nil);
|
|
return -1;
|
|
}
|
|
if(c->req.urihost != nil)
|
|
c->head.host = c->req.urihost;
|
|
/*
|
|
* also need to check host is actually this one
|
|
*/
|
|
}else if(c->head.host == nil)
|
|
c->head.host = hmydomain;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* mimeparams : | mimeparams ";" mimepara
|
|
* mimeparam : token "=" token | token "=" qstring
|
|
*/
|
|
static HSPairs*
|
|
mimeparams(Hlex *h)
|
|
{
|
|
HSPairs *p;
|
|
char *s;
|
|
|
|
p = nil;
|
|
for(;;){
|
|
if(lex(h) != Word)
|
|
break;
|
|
s = hstrdup(h->c, h->wordval);
|
|
if(lex(h) != Word && h->tok != QString)
|
|
break;
|
|
p = hmkspairs(h->c, s, hstrdup(h->c, h->wordval), p);
|
|
}
|
|
return hrevspairs(p);
|
|
}
|
|
|
|
/*
|
|
* mimehfields : mimehfield | mimehfields commas mimehfield
|
|
* mimehfield : token mimeparams
|
|
* commas : "," | commas ","
|
|
*/
|
|
static HFields*
|
|
mimehfields(Hlex *h)
|
|
{
|
|
HFields *f;
|
|
|
|
f = nil;
|
|
for(;;){
|
|
while(lex(h) != Word)
|
|
if(h->tok != ',')
|
|
goto breakout;
|
|
|
|
f = hmkhfields(h->c, hstrdup(h->c, h->wordval), nil, f);
|
|
|
|
if(lex(h) == ';')
|
|
f->params = mimeparams(h);
|
|
if(h->tok != ',')
|
|
break;
|
|
}
|
|
breakout:;
|
|
return hrevhfields(f);
|
|
}
|
|
|
|
/*
|
|
* parse a list of acceptable types, encodings, languages, etc.
|
|
*/
|
|
static HContent*
|
|
mimeok(Hlex *h, char *name, int multipart, HContent *head)
|
|
{
|
|
char *generic, *specific, *s;
|
|
float v;
|
|
|
|
/*
|
|
* each type is separated by one or more commas
|
|
*/
|
|
while(lex(h) != Word)
|
|
if(h->tok != ',')
|
|
return head;
|
|
|
|
generic = hstrdup(h->c, h->wordval);
|
|
lex(h);
|
|
if(h->tok == '/' || multipart){
|
|
/*
|
|
* at one time, IE5 improperly said '*' for single types
|
|
*/
|
|
if(h->tok != '/')
|
|
return nil;
|
|
if(lex(h) != Word)
|
|
return head;
|
|
specific = hstrdup(h->c, h->wordval);
|
|
if(!multipart && strcmp(specific, "*") != 0)
|
|
return head;
|
|
lex(h);
|
|
}else
|
|
specific = nil;
|
|
head = hmkcontent(h->c, generic, specific, head);
|
|
|
|
for(;;){
|
|
switch(h->tok){
|
|
case ';':
|
|
/*
|
|
* should make a list of these params
|
|
* for accept, they fall into two classes:
|
|
* up to a q=..., they modify the media type.
|
|
* afterwards, they acceptance criteria
|
|
*/
|
|
if(lex(h) == Word){
|
|
s = hstrdup(h->c, h->wordval);
|
|
if(lex(h) != '=' || lex(h) != Word && h->tok != QString)
|
|
return head;
|
|
v = strtod(h->wordval, nil);
|
|
if(strcmp(s, "q") == 0)
|
|
head->q = v;
|
|
else if(strcmp(s, "mxb") == 0)
|
|
head->mxb = v;
|
|
else{
|
|
/* cope with accept: application/xhtml+xml; profile=http://www.wapforum.org/xhtml, */
|
|
while(lex(h) == Word || (h->tok != ',' && h->eol == 0) )
|
|
;
|
|
return mimeok(h, name, multipart, head);
|
|
}
|
|
}
|
|
break;
|
|
case ',':
|
|
return mimeok(h, name, multipart, head);
|
|
default:
|
|
return head;
|
|
}
|
|
lex(h);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* parse a list of entity tags
|
|
* 1#entity-tag
|
|
* entity-tag = [weak] opaque-tag
|
|
* weak = "W/"
|
|
* opaque-tag = quoted-string
|
|
*/
|
|
static HETag*
|
|
mimeetag(Hlex *h, HETag *head)
|
|
{
|
|
HETag *e;
|
|
int weak;
|
|
|
|
for(;;){
|
|
while(lex(h) != Word && h->tok != QString)
|
|
if(h->tok != ',')
|
|
return head;
|
|
|
|
weak = 0;
|
|
if(h->tok == Word && strcmp(h->wordval, "*") != 0){
|
|
if(strcmp(h->wordval, "W") != 0)
|
|
return head;
|
|
if(lex(h) != '/' || lex(h) != QString)
|
|
return head;
|
|
weak = 1;
|
|
}
|
|
|
|
e = halloc(h->c, sizeof(HETag));
|
|
e->etag = hstrdup(h->c, h->wordval);
|
|
e->weak = weak;
|
|
e->next = head;
|
|
head = e;
|
|
|
|
if(lex(h) != ',')
|
|
return head;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ranges-specifier = byte-ranges-specifier
|
|
* byte-ranges-specifier = "bytes" "=" byte-range-set
|
|
* byte-range-set = 1#(byte-range-spec|suffix-byte-range-spec)
|
|
* byte-range-spec = byte-pos "-" [byte-pos]
|
|
* byte-pos = 1*DIGIT
|
|
* suffix-byte-range-spec = "-" suffix-length
|
|
* suffix-length = 1*DIGIT
|
|
*
|
|
* syntactically invalid range specifiers cause the
|
|
* entire header field to be ignored.
|
|
* it is syntactically incorrect for the second byte pos
|
|
* to be smaller than the first byte pos
|
|
*/
|
|
static HRange*
|
|
mimeranges(Hlex *h, HRange *head)
|
|
{
|
|
HRange *r, *rh, *tail;
|
|
char *w;
|
|
ulong start, stop;
|
|
int suf;
|
|
|
|
if(lex(h) != Word || strcmp(h->wordval, "bytes") != 0 || lex(h) != '=')
|
|
return head;
|
|
|
|
rh = nil;
|
|
tail = nil;
|
|
for(;;){
|
|
while(lex(h) != Word){
|
|
if(h->tok != ','){
|
|
if(h->tok == '\n')
|
|
goto breakout;
|
|
return head;
|
|
}
|
|
}
|
|
|
|
w = h->wordval;
|
|
start = 0;
|
|
suf = 1;
|
|
if(w[0] != '-'){
|
|
suf = 0;
|
|
start = digtoul(w, &w);
|
|
if(w[0] != '-')
|
|
return head;
|
|
}
|
|
w++;
|
|
stop = ~0UL;
|
|
if(w[0] != '\0'){
|
|
stop = digtoul(w, &w);
|
|
if(w[0] != '\0')
|
|
return head;
|
|
if(!suf && stop < start)
|
|
return head;
|
|
}
|
|
|
|
r = halloc(h->c, sizeof(HRange));
|
|
r->suffix = suf;
|
|
r->start = start;
|
|
r->stop = stop;
|
|
r->next = nil;
|
|
if(rh == nil)
|
|
rh = r;
|
|
else
|
|
tail->next = r;
|
|
tail = r;
|
|
|
|
if(lex(h) != ','){
|
|
if(h->tok == '\n')
|
|
break;
|
|
return head;
|
|
}
|
|
}
|
|
breakout:;
|
|
|
|
if(head == nil)
|
|
return rh;
|
|
|
|
for(tail = head; tail->next != nil; tail = tail->next)
|
|
;
|
|
tail->next = rh;
|
|
return head;
|
|
}
|
|
|
|
static void
|
|
mimeaccept(Hlex *h, char *name)
|
|
{
|
|
h->c->head.oktype = mimeok(h, name, 1, h->c->head.oktype);
|
|
}
|
|
|
|
static void
|
|
mimeacceptchar(Hlex *h, char *name)
|
|
{
|
|
h->c->head.okchar = mimeok(h, name, 0, h->c->head.okchar);
|
|
}
|
|
|
|
static void
|
|
mimeacceptenc(Hlex *h, char *name)
|
|
{
|
|
h->c->head.okencode = mimeok(h, name, 0, h->c->head.okencode);
|
|
}
|
|
|
|
static void
|
|
mimeacceptlang(Hlex *h, char *name)
|
|
{
|
|
h->c->head.oklang = mimeok(h, name, 0, h->c->head.oklang);
|
|
}
|
|
|
|
static void
|
|
mimemodified(Hlex *h, char *)
|
|
{
|
|
lexhead(h);
|
|
h->c->head.ifmodsince = hdate2sec(h->wordval);
|
|
}
|
|
|
|
static void
|
|
mimeunmodified(Hlex *h, char *)
|
|
{
|
|
lexhead(h);
|
|
h->c->head.ifunmodsince = hdate2sec(h->wordval);
|
|
}
|
|
|
|
static void
|
|
mimematch(Hlex *h, char *)
|
|
{
|
|
h->c->head.ifmatch = mimeetag(h, h->c->head.ifmatch);
|
|
}
|
|
|
|
static void
|
|
mimenomatch(Hlex *h, char *)
|
|
{
|
|
h->c->head.ifnomatch = mimeetag(h, h->c->head.ifnomatch);
|
|
}
|
|
|
|
/*
|
|
* argument is either etag or date
|
|
*/
|
|
static void
|
|
mimeifrange(Hlex *h, char *)
|
|
{
|
|
int c, d, et;
|
|
|
|
et = 0;
|
|
c = getc(h);
|
|
while(c == ' ' || c == '\t')
|
|
c = getc(h);
|
|
if(c == '"')
|
|
et = 1;
|
|
else if(c == 'W'){
|
|
d = getc(h);
|
|
if(d == '/')
|
|
et = 1;
|
|
ungetc(h);
|
|
}
|
|
ungetc(h);
|
|
if(et){
|
|
h->c->head.ifrangeetag = mimeetag(h, h->c->head.ifrangeetag);
|
|
}else{
|
|
lexhead(h);
|
|
h->c->head.ifrangedate = hdate2sec(h->wordval);
|
|
}
|
|
}
|
|
|
|
static void
|
|
mimerange(Hlex *h, char *)
|
|
{
|
|
h->c->head.range = mimeranges(h, h->c->head.range);
|
|
}
|
|
|
|
/*
|
|
* parse it like cookies
|
|
*/
|
|
static void
|
|
authdigest(Hlex *h, char *)
|
|
{
|
|
char *s;
|
|
HSPairs *p;
|
|
|
|
p = nil;
|
|
for(;;){
|
|
while(lex(h) != Word)
|
|
if(h->tok != ';' && h->tok != ',')
|
|
goto breakout;
|
|
s = hstrdup(h->c, h->wordval);
|
|
while (lex(h) != Word && h->tok != QString)
|
|
if (h->tok != '=')
|
|
goto breakout;
|
|
p = hmkspairs(h->c, s, hstrdup(h->c, h->wordval), p);
|
|
}
|
|
breakout:
|
|
h->c->head.authinfo = hrevspairs(p);
|
|
}
|
|
|
|
/*
|
|
* note: netscape and ie through versions 4.7 and 4
|
|
* support only basic authorization, so that is all that is supported here
|
|
*
|
|
* "Authorization" ":" "Basic" base64-user-pass
|
|
* where base64-user-pass is the base64 encoding of
|
|
* username ":" password
|
|
*/
|
|
static void
|
|
authbasic(Hlex *h, char *)
|
|
{
|
|
char *up, *p;
|
|
int n;
|
|
|
|
n = lexbase64(h);
|
|
if(!n)
|
|
return;
|
|
|
|
/*
|
|
* wipe out source for password, so it won't be logged.
|
|
* it is replaced by a single =,
|
|
* which is valid base64, but not ok for an auth reponse.
|
|
* therefore future parses of the header field will not overwrite
|
|
* authuser and authpass.
|
|
*/
|
|
memmove(h->c->hpos - (n - 1), h->c->hpos, h->c->hstop - h->c->hpos);
|
|
h->c->hstop -= n - 1;
|
|
*h->c->hstop = '\0';
|
|
h->c->hpos -= n - 1;
|
|
h->c->hpos[-1] = '=';
|
|
|
|
up = halloc(h->c, n + 1);
|
|
n = dec64((uchar*)up, n, h->wordval, n);
|
|
up[n] = '\0';
|
|
p = strchr(up, ':');
|
|
if(p != nil){
|
|
*p++ = '\0';
|
|
h->c->head.authuser = hstrdup(h->c, up);
|
|
h->c->head.authpass = hstrdup(h->c, p);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* "Authorization" ":" "Basic" | "Digest" ...
|
|
*/
|
|
static void
|
|
mimeauthorization(Hlex *h, char *)
|
|
{
|
|
int i;
|
|
static MimeHead authparser[] = {
|
|
{ "basic", authbasic },
|
|
{ "digest", authdigest },
|
|
};
|
|
|
|
if(lex(h) != Word)
|
|
return;
|
|
|
|
for (i = 0; i < nelem(authparser); i++)
|
|
if (cistrcmp(h->wordval, authparser[i].name) == 0) {
|
|
(*authparser[i].parse)(h, nil);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
mimeagent(Hlex *h, char *)
|
|
{
|
|
lexhead(h);
|
|
h->c->head.client = hstrdup(h->c, h->wordval);
|
|
}
|
|
|
|
static void
|
|
mimefrom(Hlex *h, char *)
|
|
{
|
|
lexhead(h);
|
|
}
|
|
|
|
static void
|
|
mimehost(Hlex *h, char *)
|
|
{
|
|
char *hd;
|
|
|
|
lexhead(h);
|
|
for(hd = h->wordval; *hd == ' ' || *hd == '\t'; hd++)
|
|
;
|
|
h->c->head.host = hlower(hstrdup(h->c, hd));
|
|
}
|
|
|
|
/*
|
|
* if present, implies that a message body follows the headers
|
|
* "content-length" ":" digits
|
|
*/
|
|
static void
|
|
mimecontlen(Hlex *h, char *)
|
|
{
|
|
char *e;
|
|
ulong v;
|
|
|
|
if(lex(h) != Word)
|
|
return;
|
|
e = h->wordval;
|
|
v = digtoul(e, &e);
|
|
if(v == ~0UL || *e != '\0')
|
|
return;
|
|
h->c->head.contlen = v;
|
|
}
|
|
|
|
/*
|
|
* mimexpect : "expect" ":" expects
|
|
* expects : | expects "," expect
|
|
* expect : "100-continue" | token | token "=" token expectparams | token "=" qstring expectparams
|
|
* expectparams : ";" token | ";" token "=" token | token "=" qstring
|
|
* for now, we merely parse "100-continue" or anything else.
|
|
*/
|
|
static void
|
|
mimeexpect(Hlex *h, char *)
|
|
{
|
|
if(lex(h) != Word || cistrcmp(h->wordval, "100-continue") != 0 || lex(h) != '\n')
|
|
h->c->head.expectother = 1;
|
|
h->c->head.expectcont = 1;
|
|
}
|
|
|
|
static void
|
|
mimetransenc(Hlex *h, char *)
|
|
{
|
|
h->c->head.transenc = mimehfields(h);
|
|
}
|
|
|
|
static void
|
|
mimecookie(Hlex *h, char *)
|
|
{
|
|
char *s;
|
|
HSPairs *p;
|
|
|
|
p = nil;
|
|
for(;;){
|
|
while(lex(h) != Word)
|
|
if(h->tok != ';' && h->tok != ',')
|
|
goto breakout;
|
|
s = hstrdup(h->c, h->wordval);
|
|
while (lex(h) != Word && h->tok != QString)
|
|
if (h->tok != '=')
|
|
goto breakout;
|
|
p = hmkspairs(h->c, s, hstrdup(h->c, h->wordval), p);
|
|
}
|
|
breakout:
|
|
h->c->head.cookie = hrevspairs(p);
|
|
}
|
|
|
|
static void
|
|
mimefresh(Hlex *h, char *)
|
|
{
|
|
char *s;
|
|
|
|
lexhead(h);
|
|
for(s = h->wordval; *s && (*s==' ' || *s=='\t'); s++)
|
|
;
|
|
if(strncmp(s, "pathstat/", 9) == 0)
|
|
h->c->head.fresh_thresh = atoi(s+9);
|
|
else if(strncmp(s, "have/", 5) == 0)
|
|
h->c->head.fresh_have = atoi(s+5);
|
|
}
|
|
|
|
static void
|
|
mimeignore(Hlex *h, char *)
|
|
{
|
|
lexhead(h);
|
|
}
|
|
|
|
static void
|
|
parsejump(Hlex *h, char *k)
|
|
{
|
|
int l, r, m;
|
|
|
|
l = 1;
|
|
r = nelem(mimehead) - 1;
|
|
while(l <= r){
|
|
m = (r + l) >> 1;
|
|
if(cistrcmp(mimehead[m].name, k) <= 0)
|
|
l = m + 1;
|
|
else
|
|
r = m - 1;
|
|
}
|
|
m = l - 1;
|
|
if(cistrcmp(mimehead[m].name, k) == 0 && !mimehead[m].ignore){
|
|
mimehead[m].seen = 1;
|
|
(*mimehead[m].parse)(h, k);
|
|
}else
|
|
mimeignore(h, k);
|
|
}
|
|
|
|
static int
|
|
lex(Hlex *h)
|
|
{
|
|
return h->tok = lex1(h, 0);
|
|
}
|
|
|
|
static int
|
|
lexbase64(Hlex *h)
|
|
{
|
|
int c, n;
|
|
|
|
n = 0;
|
|
lex1(h, 1);
|
|
|
|
while((c = getc(h)) >= 0){
|
|
if(!isalnum(c) && c != '+' && c != '/'){
|
|
ungetc(h);
|
|
break;
|
|
}
|
|
if(n < HMaxWord-1)
|
|
h->wordval[n++] = c;
|
|
}
|
|
h->wordval[n] = '\0';
|
|
return n;
|
|
}
|
|
|
|
/*
|
|
* rfc 822/rfc 1521 lexical analyzer
|
|
*/
|
|
static int
|
|
lex1(Hlex *h, int skipwhite)
|
|
{
|
|
int level, c;
|
|
|
|
if(h->eol)
|
|
return '\n';
|
|
|
|
top:
|
|
c = getc(h);
|
|
switch(c){
|
|
case '(':
|
|
level = 1;
|
|
while((c = getc(h)) >= 0){
|
|
if(c == '\\'){
|
|
c = getc(h);
|
|
if(c < 0)
|
|
return '\n';
|
|
continue;
|
|
}
|
|
if(c == '(')
|
|
level++;
|
|
else if(c == ')' && --level == 0)
|
|
break;
|
|
else if(c == '\n'){
|
|
c = getc(h);
|
|
if(c < 0)
|
|
return '\n';
|
|
if(c == ')' && --level == 0)
|
|
break;
|
|
if(c != ' ' && c != '\t'){
|
|
ungetc(h);
|
|
return '\n';
|
|
}
|
|
}
|
|
}
|
|
goto top;
|
|
|
|
case ' ': case '\t':
|
|
goto top;
|
|
|
|
case '\r':
|
|
c = getc(h);
|
|
if(c != '\n'){
|
|
ungetc(h);
|
|
goto top;
|
|
}
|
|
|
|
case '\n':
|
|
if(h->tok == '\n'){
|
|
h->eol = 1;
|
|
h->eoh = 1;
|
|
return '\n';
|
|
}
|
|
c = getc(h);
|
|
if(c < 0){
|
|
h->eol = 1;
|
|
return '\n';
|
|
}
|
|
if(c != ' ' && c != '\t'){
|
|
ungetc(h);
|
|
h->eol = 1;
|
|
return '\n';
|
|
}
|
|
goto top;
|
|
|
|
case ')':
|
|
case '<': case '>':
|
|
case '[': case ']':
|
|
case '@': case '/':
|
|
case ',': case ';': case ':': case '?': case '=':
|
|
if(skipwhite){
|
|
ungetc(h);
|
|
return c;
|
|
}
|
|
return c;
|
|
|
|
case '"':
|
|
if(skipwhite){
|
|
ungetc(h);
|
|
return c;
|
|
}
|
|
word(h, "\"");
|
|
getc(h); /* skip the closing quote */
|
|
return QString;
|
|
|
|
default:
|
|
ungetc(h);
|
|
if(skipwhite)
|
|
return c;
|
|
word(h, "\"(){}<>@,;:/[]?=\r\n \t");
|
|
if(h->wordval[0] == '\0'){
|
|
h->c->head.closeit = 1;
|
|
hfail(h->c, HSyntax);
|
|
longjmp(h->jmp, -1);
|
|
}
|
|
return Word;
|
|
}
|
|
/* not reached */
|
|
}
|
|
|
|
/*
|
|
* return the rest of an rfc 822, including \n
|
|
* do not map to lower case
|
|
*/
|
|
static void
|
|
lexhead(Hlex *h)
|
|
{
|
|
int c, n;
|
|
|
|
n = 0;
|
|
while((c = getc(h)) >= 0){
|
|
if(c == '\r')
|
|
c = wordcr(h);
|
|
else if(c == '\n')
|
|
c = wordnl(h);
|
|
if(c == '\n')
|
|
break;
|
|
if(c == '\\'){
|
|
c = getc(h);
|
|
if(c < 0)
|
|
break;
|
|
}
|
|
|
|
if(n < HMaxWord-1)
|
|
h->wordval[n++] = c;
|
|
}
|
|
h->tok = '\n';
|
|
h->eol = 1;
|
|
h->wordval[n] = '\0';
|
|
}
|
|
|
|
static void
|
|
word(Hlex *h, char *stop)
|
|
{
|
|
int c, n;
|
|
|
|
n = 0;
|
|
while((c = getc(h)) >= 0){
|
|
if(c == '\r')
|
|
c = wordcr(h);
|
|
else if(c == '\n')
|
|
c = wordnl(h);
|
|
if(c == '\\'){
|
|
c = getc(h);
|
|
if(c < 0)
|
|
break;
|
|
}else if(c < 32 || strchr(stop, c) != nil){
|
|
ungetc(h);
|
|
break;
|
|
}
|
|
|
|
if(n < HMaxWord-1)
|
|
h->wordval[n++] = c;
|
|
}
|
|
h->wordval[n] = '\0';
|
|
}
|
|
|
|
static int
|
|
wordcr(Hlex *h)
|
|
{
|
|
int c;
|
|
|
|
c = getc(h);
|
|
if(c == '\n')
|
|
return wordnl(h);
|
|
ungetc(h);
|
|
return ' ';
|
|
}
|
|
|
|
static int
|
|
wordnl(Hlex *h)
|
|
{
|
|
int c;
|
|
|
|
c = getc(h);
|
|
if(c == ' ' || c == '\t')
|
|
return c;
|
|
ungetc(h);
|
|
|
|
return '\n';
|
|
}
|
|
|
|
static int
|
|
getc(Hlex *h)
|
|
{
|
|
if(h->eoh)
|
|
return -1;
|
|
if(h->c->hpos < h->c->hstop)
|
|
return *h->c->hpos++;
|
|
h->eoh = 1;
|
|
h->eol = 1;
|
|
return -1;
|
|
}
|
|
|
|
static void
|
|
ungetc(Hlex *h)
|
|
{
|
|
if(h->eoh)
|
|
return;
|
|
h->c->hpos--;
|
|
}
|
|
|
|
static ulong
|
|
digtoul(char *s, char **e)
|
|
{
|
|
ulong v;
|
|
int c, ovfl;
|
|
|
|
v = 0;
|
|
ovfl = 0;
|
|
for(;;){
|
|
c = *s;
|
|
if(c < '0' || c > '9')
|
|
break;
|
|
s++;
|
|
c -= '0';
|
|
if(v > UlongMax/10 || v == UlongMax/10 && c >= UlongMax%10)
|
|
ovfl = 1;
|
|
v = v * 10 + c;
|
|
}
|
|
|
|
if(e)
|
|
*e = s;
|
|
if(ovfl)
|
|
return UlongMax;
|
|
return v;
|
|
}
|
|
|
|
int
|
|
http11(HConnect *c)
|
|
{
|
|
return c->req.vermaj > 1 || c->req.vermaj == 1 && c->req.vermin > 0;
|
|
}
|
|
|
|
char*
|
|
hmkmimeboundary(HConnect *c)
|
|
{
|
|
char buf[32];
|
|
int i;
|
|
|
|
srand((time(0)<<16)|getpid());
|
|
strcpy(buf, "upas-");
|
|
for(i = 5; i < sizeof(buf)-1; i++)
|
|
buf[i] = 'a' + nrand(26);
|
|
buf[i] = 0;
|
|
return hstrdup(c, buf);
|
|
}
|
|
|
|
HSPairs*
|
|
hmkspairs(HConnect *c, char *s, char *t, HSPairs *next)
|
|
{
|
|
HSPairs *sp;
|
|
|
|
sp = halloc(c, sizeof *sp);
|
|
sp->s = s;
|
|
sp->t = t;
|
|
sp->next = next;
|
|
return sp;
|
|
}
|
|
|
|
HSPairs*
|
|
hrevspairs(HSPairs *sp)
|
|
{
|
|
HSPairs *last, *next;
|
|
|
|
last = nil;
|
|
for(; sp != nil; sp = next){
|
|
next = sp->next;
|
|
sp->next = last;
|
|
last = sp;
|
|
}
|
|
return last;
|
|
}
|
|
|
|
HFields*
|
|
hmkhfields(HConnect *c, char *s, HSPairs *p, HFields *next)
|
|
{
|
|
HFields *hf;
|
|
|
|
hf = halloc(c, sizeof *hf);
|
|
hf->s = s;
|
|
hf->params = p;
|
|
hf->next = next;
|
|
return hf;
|
|
}
|
|
|
|
HFields*
|
|
hrevhfields(HFields *hf)
|
|
{
|
|
HFields *last, *next;
|
|
|
|
last = nil;
|
|
for(; hf != nil; hf = next){
|
|
next = hf->next;
|
|
hf->next = last;
|
|
last = hf;
|
|
}
|
|
return last;
|
|
}
|
|
|
|
HContent*
|
|
hmkcontent(HConnect *c, char *generic, char *specific, HContent *next)
|
|
{
|
|
HContent *ct;
|
|
|
|
ct = halloc(c, sizeof(HContent));
|
|
ct->generic = generic;
|
|
ct->specific = specific;
|
|
ct->next = next;
|
|
ct->q = 1;
|
|
ct->mxb = 0;
|
|
return ct;
|
|
}
|