ref: 5f7a6b7ea3c4ae1b51beffe3309e9b6b0491e71f
dir: /sys/src/cmd/upas/imap4d/msg.c/
#include "imap4d.h"
static char *headaddrspec(char*, char*);
static Maddr *headaddresses(void);
static Maddr *headaddress(void);
static char *headatom(char*);
static int headchar(int eat);
static char *headdomain(char*);
static Maddr *headmaddr(Maddr*);
static char *headphrase(char*, char*);
static char *headquoted(int start, int stop);
static char *headskipwhite(int);
static void headskip(void);
static char *headsubdomain(void);
static char *headtext(void);
static void headtoend(void);
static char *headword(void);
static void mimedescription(Header*);
static void mimedisposition(Header*);
static void mimeencoding(Header*);
static void mimeid(Header*);
static void mimelanguage(Header*);
//static void mimemd5(Header*);
static void mimetype(Header*);
static int msgbodysize(Msg*);
static int msgheader(Msg*, Header*, char*);
/*
* stop list for header fields
*/
static char *headfieldstop = ":";
static char *mimetokenstop = "()<>@,;:\\\"/[]?=";
static char *headatomstop = "()<>@,;:\\\".[]";
static uchar *headstr;
static uchar *lastwhite;
long
selectfields(char *dst, long n, char *hdr, Slist *fields, int matches)
{
char *s;
uchar *start;
long m, nf;
Slist *f;
headstr = (uchar*)hdr;
m = 0;
for(;;){
start = headstr;
s = headatom(headfieldstop);
if(s == nil)
break;
headskip();
for(f = fields; f != nil; f = f->next){
if(cistrcmp(s, f->s) == !matches){
nf = headstr - start;
if(m + nf > n)
return 0;
memmove(&dst[m], start, nf);
m += nf;
}
}
free(s);
}
if(m + 3 > n)
return 0;
dst[m++] = '\r';
dst[m++] = '\n';
dst[m] = '\0';
return m;
}
static Mimehdr*
mkmimehdr(char *s, char *t, Mimehdr *next)
{
Mimehdr *mh;
mh = MK(Mimehdr);
mh->s = s;
mh->t = t;
mh->next = next;
return mh;
}
static void
freemimehdr(Mimehdr *mh)
{
Mimehdr *last;
while(mh != nil){
last = mh;
mh = mh->next;
free(last->s);
free(last->t);
free(last);
}
}
static void
freeheader(Header *h)
{
freemimehdr(h->type);
freemimehdr(h->id);
freemimehdr(h->description);
freemimehdr(h->encoding);
// freemimehdr(h->md5);
freemimehdr(h->disposition);
freemimehdr(h->language);
free(h->buf);
}
static void
freemaddr(Maddr *a)
{
Maddr *p;
while(a != nil){
p = a;
a = a->next;
free(p->personal);
free(p->box);
free(p->host);
free(p);
}
}
void
freemsg(Box *box, Msg *m)
{
Msg *k, *last;
if(box != nil)
fstreedelete(box, m);
free(m->ibuf);
freemaddr(m->to);
if(m->replyto != m->from)
freemaddr(m->replyto);
if(m->sender != m->from)
freemaddr(m->sender);
if(m->from != m->unixfrom)
freemaddr(m->from);
freemaddr(m->unixfrom);
freemaddr(m->cc);
freemaddr(m->bcc);
free(m->unixdate);
freeheader(&m->head);
freeheader(&m->mime);
for(k = m->kids; k != nil; ){
last = k;
k = k->next;
freemsg(0, last);
}
free(m->fs);
free(m);
}
uint
msgsize(Msg *m)
{
return m->head.size + m->size;
}
char*
maddrstr(Maddr *a)
{
char *host, *addr;
host = a->host;
if(host == nil)
host = "";
if(a->personal != nil)
addr = smprint("%s <%s@%s>", a->personal, a->box, host);
else
addr = smprint("%s@%s", a->box, host);
return addr;
}
int
msgfile(Msg *m, char *f)
{
if(strlen(f) > Filelen)
bye("internal error: msgfile name too long");
strcpy(m->efs, f);
return cdopen(m->fsdir, m->fs, OREAD);
}
int
msgismulti(Header *h)
{
return h->type != nil && cistrcmp("multipart", h->type->s) == 0;
}
int
msgis822(Header *h)
{
Mimehdr *t;
t = h->type;
return t != nil && cistrcmp("message", t->s) == 0 && cistrcmp("rfc822", t->t) == 0;
}
/*
* check if a message has been deleted by someone else
*/
void
msgdead(Msg *m)
{
if(m->expunged)
return;
*m->efs = '\0';
if(!cdexists(m->fsdir, m->fs))
m->expunged = 1;
}
static long
msgreadfile(Msg *m, char *file, char **ss)
{
char *s, buf[Bufsize];
int fd;
long n, nn;
vlong length;
Dir *d;
fd = msgfile(m, file);
if(fd < 0){
msgdead(m);
return -1;
}
n = read(fd, buf, Bufsize);
if(n < Bufsize){
close(fd);
if(n < 0){
*ss = nil;
return -1;
}
s = emalloc(n + 1);
memmove(s, buf, n);
s[n] = '\0';
*ss = s;
return n;
}
d = dirfstat(fd);
if(d == nil){
close(fd);
return -1;
}
length = d->length;
free(d);
nn = length;
s = emalloc(nn + 1);
memmove(s, buf, n);
if(nn > n)
nn = readn(fd, s + n, nn - n) + n;
close(fd);
if(nn != length){
free(s);
return -1;
}
s[nn] = '\0';
*ss = s;
return nn;
}
/*
* parse the address in the unix header
* last line of defence, so must return something
*/
static Maddr *
unixfrom(char *s)
{
char *e, *t;
Maddr *a;
if(s == nil)
return nil;
headstr = (uchar*)s;
t = emalloc(strlen(s) + 2);
e = headaddrspec(t, nil);
if(e == nil)
a = nil;
else{
if(*e != '\0')
*e++ = '\0';
else
e = site;
a = MKZ(Maddr);
a->box = estrdup(t);
a->host = estrdup(e);
}
free(t);
return a;
}
/*
* retrieve information from the unixheader file
*/
static int
msgunix(Msg *m, int top)
{
char *s, *ss;
Tm tm;
if(m->unixdate != nil)
return 1;
if(!top){
bogus:
m->unixdate = estrdup("");
m->unixfrom = unixfrom(nil);
return 1;
}
if(msgreadfile(m, "unixheader", &ss) < 0)
goto bogus;
s = ss;
s = strchr(s, ' ');
if(s == nil){
free(ss);
goto bogus;
}
s++;
m->unixfrom = unixfrom(s);
s = (char*)headstr;
if(date2tm(&tm, s) == nil)
s = m->info[Iunixdate];
if(s == nil){
free(ss);
goto bogus;
}
m->unixdate = estrdup(s);
free(ss);
return 1;
}
/*
* make sure the message has valid associated info
* used for Isubject, Idigest, Iinreplyto, Imessageid.
*/
int
msginfo(Msg *m)
{
char *s;
int i;
if(m->info[0] != nil)
return 1;
if(msgreadfile(m, "info", &m->ibuf) < 0)
return 0;
s = m->ibuf;
for(i = 0; i < Imax; i++){
m->info[i] = s;
s = strchr(s, '\n');
if(s == nil)
return 0;
if(s == m->info[i])
m->info[i] = 0;
*s++ = '\0';
}
// m->lines = strtoul(m->info[Ilines], 0, 0);
// m->size = strtoull(m->info[Isize], 0, 0);
// m->size += m->lines; /* BOTCH: this hack belongs elsewhere */
return 1;
}
/*
* make sure the message has valid mime structure
* and sub-messages
*/
int
msgstruct(Msg *m, int top)
{
char buf[12];
int fd, ns, max;
Msg *k, head, *last;
if(m->kids != nil)
return 1;
if(m->expunged
|| !msginfo(m)
|| !msgheader(m, &m->mime, "mimeheader")){
msgdead(m);
return 0;
}
/* gack. we need to get the header from the subpart here. */
if(msgis822(&m->mime)){
free(m->ibuf);
m->info[0] = 0;
m->efs = seprint(m->efs, m->efs + 5, "/1/");
if(!msginfo(m)){
msgdead(m);
return 0;
}
}
if(!msgunix(m, top)
|| !msgbodysize(m)
|| (top || msgis822(&m->mime) || msgismulti(&m->mime)) && !msgheader(m, &m->head, "rawheader")){
msgdead(m);
return 0;
}
/*
* if a message has no kids, it has a kid which is just the body of the real message
*/
if(!msgismulti(&m->head) && !msgismulti(&m->mime) && !msgis822(&m->head) && !msgis822(&m->mime)){
k = MKZ(Msg);
k->id = 1;
k->fsdir = m->fsdir;
k->parent = m->parent;
ns = m->efs - m->fs;
k->fs = emalloc(ns + (Filelen + 1));
memmove(k->fs, m->fs, ns);
k->efs = k->fs + ns;
*k->efs = '\0';
k->size = m->size;
m->kids = k;
return 1;
}
/*
* read in all child messages messages
*/
head.next = nil;
last = &head;
for(max = 1;; max++){
snprint(buf, sizeof buf, "%d", max);
fd = msgfile(m, buf);
if(fd == -1)
break;
close(fd);
m->efs[0] = 0; /* BOTCH! */
k = MKZ(Msg);
k->id = max;
k->fsdir = m->fsdir;
k->parent = m;
ns = strlen(m->fs) + 2*(Filelen + 1);
k->fs = emalloc(ns);
k->efs = seprint(k->fs, k->fs + ns, "%s%d/", m->fs, max);
k->size = ~0UL;
k->lines = ~0UL;
last->next = k;
last = k;
}
m->kids = head.next;
/*
* if kids fail, just whack them
*/
top = top && (msgis822(&m->head) || msgismulti(&m->head));
for(k = m->kids; k != nil; k = k->next)
if(!msgstruct(k, top)){
debuglog("kid fail %p %s", k, k->fs);
for(k = m->kids; k != nil; ){
last = k;
k = k->next;
freemsg(0, last);
}
m->kids = nil;
break;
}
return 1;
}
/*
* read in the message body to count \n without a preceding \r
*/
static int
msgbodysize(Msg *m)
{
char buf[Bufsize + 2], *s, *se;
uint length, size, lines, needr;
int n, fd, c;
Dir *d;
if(m->lines != ~0UL)
return 1;
fd = msgfile(m, "rawbody");
if(fd < 0)
return 0;
d = dirfstat(fd);
if(d == nil){
close(fd);
return 0;
}
length = d->length;
free(d);
size = 0;
lines = 0;
needr = 0;
buf[0] = ' ';
for(;;){
n = read(fd, &buf[1], Bufsize);
if(n <= 0)
break;
size += n;
se = &buf[n + 1];
for(s = &buf[1]; s < se; s++){
c = *s;
if(c == '\0')
*s = ' ';
if(c != '\n')
continue;
if(s[-1] != '\r')
needr++;
lines++;
}
buf[0] = buf[n];
}
if(size != length)
bye("bad length reading rawbody %d != %d; n %d %s", size, length, n, m->fs);
size += needr;
m->size = size;
m->lines = lines;
close(fd);
return 1;
}
/*
* prepend hdrname: val to the cached header
*/
static void
msgaddhead(Msg *m, char *hdrname, char *val)
{
char *s;
long size, n;
n = strlen(hdrname) + strlen(val) + 4;
size = m->head.size + n;
s = emalloc(size + 1);
snprint(s, size + 1, "%s: %s\r\n%s", hdrname, val, m->head.buf);
free(m->head.buf);
m->head.buf = s;
m->head.size = size;
m->head.lines++;
}
static void
msgadddate(Msg *m)
{
char buf[64];
Tm tm;
/* don't bother if we don't have a date */
if(m->info[Idate] == 0)
return;
date2tm(&tm, m->info[Idate]);
snprint(buf, sizeof buf, "%δ", &tm);
msgaddhead(m, "Date", buf);
}
/*
* read in the entire header,
* and parse out any existing mime headers
*/
static int
msgheader(Msg *m, Header *h, char *file)
{
char *s, *ss, *t, *te;
int dated, c;
long ns;
uint lines, n, nn;
if(h->buf != nil)
return 1;
ns = msgreadfile(m, file, &ss);
if(ns < 0)
return 0;
s = ss;
n = ns;
/*
* count lines ending with \n and \r\n
* add an extra line at the end, since upas/fs headers
* don't have a terminating \r\n
*/
lines = 1;
te = s + ns;
for(t = s; t < te; t++){
c = *t;
if(c == '\0')
*t = ' ';
if(c != '\n')
continue;
if(t == s || t[-1] != '\r')
n++;
lines++;
}
if(t > s && t[-1] != '\n'){
if(t[-1] != '\r')
n++;
n++;
}
if(n > 0)
n += 2;
h->buf = emalloc(n + 1);
h->size = n;
h->lines = lines;
/*
* make sure all headers end in \r\n
*/
nn = 0;
for(t = s; t < te; t++){
c = *t;
if(c == '\n'){
if(!nn || h->buf[nn - 1] != '\r')
h->buf[nn++] = '\r';
lines++;
}
h->buf[nn++] = c;
}
if(nn && h->buf[nn-1] != '\n'){
if(h->buf[nn-1] != '\r')
h->buf[nn++] = '\r';
h->buf[nn++] = '\n';
}
if(nn > 0){
h->buf[nn++] = '\r';
h->buf[nn++] = '\n';
}
h->buf[nn] = '\0';
if(nn != n)
bye("misconverted header %d %d", nn, n);
free(s);
/*
* and parse some mime headers
*/
headstr = (uchar*)h->buf;
dated = 0;
while(s = headatom(headfieldstop)){
if(cistrcmp(s, "content-type") == 0)
mimetype(h);
else if(cistrcmp(s, "content-transfer-encoding") == 0)
mimeencoding(h);
else if(cistrcmp(s, "content-id") == 0)
mimeid(h);
else if(cistrcmp(s, "content-description") == 0)
mimedescription(h);
else if(cistrcmp(s, "content-disposition") == 0)
mimedisposition(h);
// else if(cistrcmp(s, "content-md5") == 0)
// mimemd5(h);
else if(cistrcmp(s, "content-language") == 0)
mimelanguage(h);
else if(h == &m->head){
if(cistrcmp(s, "from") == 0)
m->from = headmaddr(m->from);
else if(cistrcmp(s, "to") == 0)
m->to = headmaddr(m->to);
else if(cistrcmp(s, "reply-to") == 0)
m->replyto = headmaddr(m->replyto);
else if(cistrcmp(s, "sender") == 0)
m->sender = headmaddr(m->sender);
else if(cistrcmp(s, "cc") == 0)
m->cc = headmaddr(m->cc);
else if(cistrcmp(s, "bcc") == 0)
m->bcc = headmaddr(m->bcc);
else if(cistrcmp(s, "date") == 0)
dated = 1;
}
headskip();
free(s);
}
if(h == &m->head){
if(m->from == nil){
m->from = m->unixfrom;
if(m->from != nil){
s = maddrstr(m->from);
msgaddhead(m, "From", s);
free(s);
}
}
if(m->sender == nil)
m->sender = m->from;
if(m->replyto == nil)
m->replyto = m->from;
if(m->info[Idate] == 0)
m->info[Idate] = m->unixdate;
if(!dated && m->from != nil)
msgadddate(m);
}
return 1;
}
/*
* q is a quoted string. remove enclosing " and and \ escapes
*/
static void
stripquotes(char *q)
{
char *s;
int c;
if(q == nil)
return;
s = q++;
while(c = *q++){
if(c == '\\'){
c = *q++;
if(!c)
return;
}
*s++ = c;
}
s[-1] = '\0';
}
/*
* parser for rfc822 & mime header fields
*/
/*
* params :
* | params ';' token '=' token
* | params ';' token '=' quoted-str
*/
static Mimehdr*
mimeparams(void)
{
char *s, *t;
Mimehdr head, *last;
head.next = nil;
last = &head;
for(;;){
if(headchar(1) != ';')
break;
s = headatom(mimetokenstop);
if(s == nil || headchar(1) != '='){
free(s);
break;
}
if(headchar(0) == '"'){
t = headquoted('"', '"');
stripquotes(t);
}else
t = headatom(mimetokenstop);
if(t == nil){
free(s);
break;
}
last->next = mkmimehdr(s, t, nil);
last = last->next;
}
return head.next;
}
/*
* type : 'content-type' ':' token '/' token params
*/
static void
mimetype(Header *h)
{
char *s, *t;
if(headchar(1) != ':')
return;
s = headatom(mimetokenstop);
if(s == nil || headchar(1) != '/'){
free(s);
return;
}
t = headatom(mimetokenstop);
if(t == nil){
free(s);
return;
}
h->type = mkmimehdr(s, t, mimeparams());
}
/*
* encoding : 'content-transfer-encoding' ':' token
*/
static void
mimeencoding(Header *h)
{
char *s;
if(headchar(1) != ':')
return;
s = headatom(mimetokenstop);
if(s == nil)
return;
h->encoding = mkmimehdr(s, nil, nil);
}
/*
* mailaddr : ':' addresses
*/
static Maddr*
headmaddr(Maddr *old)
{
Maddr *a;
if(headchar(1) != ':')
return old;
if(headchar(0) == '\n')
return old;
a = headaddresses();
if(a == nil)
return old;
freemaddr(old);
return a;
}
/*
* addresses : address | addresses ',' address
*/
static Maddr*
headaddresses(void)
{
Maddr *addr, *tail, *a;
addr = headaddress();
if(addr == nil)
return nil;
tail = addr;
while(headchar(0) == ','){
headchar(1);
a = headaddress();
if(a == nil){
freemaddr(addr);
return nil;
}
tail->next = a;
tail = a;
}
return addr;
}
/*
* address : mailbox | group
* group : phrase ':' mboxes ';' | phrase ':' ';'
* mailbox : addr-spec
* | optphrase '<' addr-spec '>'
* | optphrase '<' route ':' addr-spec '>'
* optphrase : | phrase
* route : '@' domain
* | route ',' '@' domain
* personal names are the phrase before '<',
* or a comment before or after a simple addr-spec
*/
static Maddr*
headaddress(void)
{
char *s, *e, *w, *personal;
uchar *hs;
int c;
Maddr *addr;
s = emalloc(strlen((char*)headstr) + 2);
e = s;
personal = headskipwhite(1);
c = headchar(0);
if(c == '<')
w = nil;
else{
w = headword();
c = headchar(0);
}
if(c == '.' || c == '@' || c == ',' || c == '\n' || c == '\0'){
lastwhite = headstr;
e = headaddrspec(s, w);
if(personal == nil){
hs = headstr;
headstr = lastwhite;
personal = headskipwhite(1);
headstr = hs;
}
}else{
if(c != '<' || w != nil){
free(personal);
if(!headphrase(e, w)){
free(s);
return nil;
}
/*
* ignore addresses with groups,
* so the only thing left if <
*/
c = headchar(1);
if(c != '<'){
free(s);
return nil;
}
personal = estrdup(s);
}else
headchar(1);
/*
* after this point, we need to free personal before returning.
* set e to nil to everything afterwards fails.
*
* ignore routes, they are useless, and heavily discouraged in rfc1123.
* imap4 reports them up to, but not including, the terminating :
*/
e = s;
c = headchar(0);
if(c == '@'){
for(;;){
c = headchar(1);
if(c != '@'){
e = nil;
break;
}
headdomain(e);
c = headchar(1);
if(c != ','){
e = s;
break;
}
}
if(c != ':')
e = nil;
}
if(e != nil)
e = headaddrspec(s, nil);
if(headchar(1) != '>')
e = nil;
}
/*
* e points to @host, or nil if an error occured
*/
if(e == nil){
free(personal);
addr = nil;
}else{
if(*e != '\0')
*e++ = '\0';
else
e = site;
addr = MKZ(Maddr);
addr->personal = personal;
addr->box = estrdup(s);
addr->host = estrdup(e);
}
free(s);
return addr;
}
/*
* phrase : word
* | phrase word
* w is the optional initial word of the phrase
* returns the end of the phrase, or nil if a failure occured
*/
static char*
headphrase(char *e, char *w)
{
int c;
for(;;){
if(w == nil){
w = headword();
if(w == nil)
return nil;
}
if(w[0] == '"')
stripquotes(w);
strcpy(e, w);
free(w);
w = nil;
e = strchr(e, '\0');
c = headchar(0);
if(c <= ' ' || strchr(headatomstop, c) != nil && c != '"')
break;
*e++ = ' ';
*e = '\0';
}
return e;
}
/*
* find the ! in domain!rest, where domain must have at least
* one internal '.'
*/
static char*
dombang(char *s)
{
int dot, c;
dot = 0;
for(; c = *s; s++){
if(c == '!'){
if(!dot || dot == 1 && s[-1] == '.' || s[1] == '\0')
return nil;
return s;
}
if(c == '"')
break;
if(c == '.')
dot++;
}
return nil;
}
/*
* addr-spec : local-part '@' domain
* | local-part extension to allow ! and local names
* local-part : word
* | local-part '.' word
*
* if no '@' is present, rewrite d!e!f!u as @d,@e:u@f,
* where d, e, f are valid domain components.
* the @d,@e: is ignored, since routes are ignored.
* perhaps they should be rewritten as e!f!u@d, but that is inconsistent with upas.
*
* returns a pointer to '@', the end if none, or nil if there was an error
*/
static char*
headaddrspec(char *e, char *w)
{
char *s, *at, *b, *bang, *dom;
int c;
s = e;
for(;;){
if(w == nil){
w = headword();
if(w == nil)
return nil;
}
strcpy(e, w);
free(w);
w = nil;
e = strchr(e, '\0');
lastwhite = headstr;
c = headchar(0);
if(c != '.')
break;
headchar(1);
*e++ = '.';
*e = '\0';
}
if(c != '@'){
/*
* extenstion: allow name without domain
* check for domain!xxx
*/
bang = dombang(s);
if(bang == nil)
return e;
/*
* if dom1!dom2!xxx, ignore dom1!
*/
dom = s;
for(; b = dombang(bang + 1); bang = b)
dom = bang + 1;
/*
* convert dom!mbox into mbox@dom
*/
*bang = '@';
strrev(dom, bang);
strrev(bang + 1, e);
strrev(dom, e);
bang = &dom[e - bang - 1];
if(dom > s){
bang -= dom - s;
for(e = s; *e = *dom; e++)
dom++;
}
/*
* eliminate a trailing '.'
*/
if(e[-1] == '.')
e[-1] = '\0';
return bang;
}
headchar(1);
at = e;
*e++ = '@';
*e = '\0';
if(!headdomain(e))
return nil;
return at;
}
/*
* domain : sub-domain
* | domain '.' sub-domain
* returns the end of the domain, or nil if a failure occured
*/
static char*
headdomain(char *e)
{
char *w;
for(;;){
w = headsubdomain();
if(w == nil)
return nil;
strcpy(e, w);
free(w);
e = strchr(e, '\0');
lastwhite = headstr;
if(headchar(0) != '.')
break;
headchar(1);
*e++ = '.';
*e = '\0';
}
return e;
}
/*
* id : 'content-id' ':' msg-id
* msg-id : '<' addr-spec '>'
*/
static void
mimeid(Header *h)
{
char *s, *e, *w;
if(headchar(1) != ':')
return;
if(headchar(1) != '<')
return;
s = emalloc(strlen((char*)headstr) + 3);
e = s;
*e++ = '<';
e = headaddrspec(e, nil);
if(e == nil || headchar(1) != '>'){
free(s);
return;
}
e = strchr(e, '\0');
*e++ = '>';
e[0] = '\0';
w = strdup(s);
free(s);
h->id = mkmimehdr(w, nil, nil);
}
/*
* description : 'content-description' ':' *text
*/
static void
mimedescription(Header *h)
{
if(headchar(1) != ':')
return;
headskipwhite(0);
h->description = mkmimehdr(headtext(), nil, nil);
}
/*
* disposition : 'content-disposition' ':' token params
*/
static void
mimedisposition(Header *h)
{
char *s;
if(headchar(1) != ':')
return;
s = headatom(mimetokenstop);
if(s == nil)
return;
h->disposition = mkmimehdr(s, nil, mimeparams());
}
/*
* md5 : 'content-md5' ':' token
*/
//static void
//mimemd5(Header *h)
//{
// char *s;
//
// if(headchar(1) != ':')
// return;
// s = headatom(mimetokenstop);
// if(s == nil)
// return;
// h->md5 = mkmimehdr(s, nil, nil);
//}
/*
* language : 'content-language' ':' langs
* langs : token
* | langs commas token
* commas : ','
* | commas ','
*/
static void
mimelanguage(Header *h)
{
char *s;
Mimehdr head, *last;
head.next = nil;
last = &head;
for(;;){
s = headatom(mimetokenstop);
if(s == nil)
break;
last->next = mkmimehdr(s, nil, nil);
last = last->next;
while(headchar(0) != ',')
headchar(1);
}
h->language = head.next;
}
/*
* token : 1*<char 33-255, except "()<>@,;:\\\"/[]?=" aka mimetokenstop>
* atom : 1*<chars 33-255, except "()<>@,;:\\\".[]" aka headatomstop>
* note this allows 8 bit characters, which occur in utf.
*/
static char*
headatom(char *disallowed)
{
char *s;
int c, ns, as;
headskipwhite(0);
s = emalloc(Stralloc);
as = Stralloc;
ns = 0;
for(;;){
c = *headstr++;
if(c <= ' ' || strchr(disallowed, c) != nil){
headstr--;
break;
}
s[ns++] = c;
if(ns >= as){
as += Stralloc;
s = erealloc(s, as);
}
}
if(ns == 0){
free(s);
return 0;
}
s[ns] = '\0';
return s;
}
/*
* sub-domain : atom | domain-lit
*/
static char *
headsubdomain(void)
{
if(headchar(0) == '[')
return headquoted('[', ']');
return headatom(headatomstop);
}
/*
* word : atom | quoted-str
*/
static char *
headword(void)
{
if(headchar(0) == '"')
return headquoted('"', '"');
return headatom(headatomstop);
}
/*
* quoted-str : '"' *(any char but '"\\\r', or '\' any char, or linear-white-space) '"'
* domain-lit : '[' *(any char but '[]\\\r', or '\' any char, or linear-white-space) ']'
*/
static char *
headquoted(int start, int stop)
{
char *s;
int c, ns, as;
if(headchar(1) != start)
return nil;
s = emalloc(Stralloc);
as = Stralloc;
ns = 0;
s[ns++] = start;
for(;;){
c = *headstr;
if(c == stop){
headstr++;
break;
}
if(c == '\0'){
free(s);
return nil;
}
if(c == '\r'){
headstr++;
continue;
}
if(c == '\n'){
headstr++;
while(*headstr == ' ' || *headstr == '\t' || *headstr == '\r' || *headstr == '\n')
headstr++;
c = ' ';
}else if(c == '\\'){
headstr++;
s[ns++] = c;
c = *headstr;
if(c == '\0'){
free(s);
return nil;
}
headstr++;
}else
headstr++;
s[ns++] = c;
if(ns + 1 >= as){ /* leave room for \c or "0 */
as += Stralloc;
s = erealloc(s, as);
}
}
s[ns++] = stop;
s[ns] = '\0';
return s;
}
/*
* headtext : contents of rest of header line
*/
static char *
headtext(void)
{
uchar *v;
char *s;
v = headstr;
headtoend();
s = emalloc(headstr - v + 1);
memmove(s, v, headstr - v);
s[headstr - v] = '\0';
return s;
}
/*
* white space is ' ' '\t' or nested comments.
* skip white space.
* if com and a comment is seen,
* return it's contents and stop processing white space.
*/
static char*
headskipwhite(int com)
{
char *s;
int c, incom, as, ns;
s = nil;
as = Stralloc;
ns = 0;
if(com)
s = emalloc(Stralloc);
incom = 0;
for(; c = *headstr; headstr++){
switch(c){
case ' ':
case '\t':
case '\r':
c = ' ';
break;
case '\n':
c = headstr[1];
if(c != ' ' && c != '\t')
goto done;
c = ' ';
break;
case '\\':
if(com && incom)
s[ns++] = c;
c = headstr[1];
if(c == '\0')
goto done;
headstr++;
break;
case '(':
incom++;
if(incom == 1)
continue;
break;
case ')':
incom--;
if(com && !incom){
s[ns] = '\0';
return s;
}
break;
default:
if(!incom)
goto done;
break;
}
if(com && incom && (c != ' ' || ns > 0 && s[ns-1] != ' ')){
s[ns++] = c;
if(ns + 1 >= as){ /* leave room for \c or 0 */
as += Stralloc;
s = erealloc(s, as);
}
}
}
done:
free(s);
return nil;
}
/*
* return the next non-white character
*/
static int
headchar(int eat)
{
int c;
headskipwhite(0);
c = *headstr;
if(eat && c != '\0' && c != '\n')
headstr++;
return c;
}
static void
headtoend(void)
{
uchar *s;
int c;
for(;;){
s = headstr;
c = *s++;
while(c == '\r')
c = *s++;
if(c == '\n'){
c = *s++;
if(c != ' ' && c != '\t')
return;
}
if(c == '\0')
return;
headstr = s;
}
}
static void
headskip(void)
{
int c;
while(c = *headstr){
headstr++;
if(c == '\n'){
c = *headstr;
if(c == ' ' || c == '\t')
continue;
return;
}
}
}