#include "imap4d.h"

char *fetchpartnames[FPmax] =
{
       "",
       "HEADER",
       "HEADER.FIELDS",
       "HEADER.FIELDS.NOT",
       "MIME",
       "TEXT",
};

/*
* implicitly set the \seen flag.  done in a separate pass
* so the .imp file doesn't need to be open while the
* messages are sent to the client.
*/
int
fetchseen(Box *box, Msg *m, int uids, void *vf)
{
       Fetch *f;

       if(m->expunged)
               return uids;
       for(f = vf; f != nil; f = f->next){
               switch(f->op){
               case Frfc822:
               case Frfc822text:
               case Fbodysect:
                       msgseen(box, m);
                       return 1;
               }
       }
       return 1;
}

/*
* fetch messages
*
* imap4 body[] requests get translated to upas/fs files as follows
*      body[id.header] == id/rawheader file + extra \r\n
*      body[id.text] == id/rawbody
*      body[id.mime] == id/mimeheader + extra \r\n
*      body[id] === body[id.header] + body[id.text]
*/
int
fetchmsg(Box *, Msg *m, int uids, void *vf)
{
       char *sep;
       Fetch *f;
       Tm tm;

       if(m->expunged)
               return uids;
       for(f = vf; f != nil; f = f->next)
               switch(f->op){
               case Fflags:
                       break;
               case Fuid:
                       break;
               case Finternaldate:
               case Fenvelope:
               case Frfc822:
               case Frfc822head:
               case Frfc822text:
               case Frfc822size:
               case Fbodysect:
               case Fbodypeek:
               case Fbody:
               case Fbodystruct:
                       if(!msgstruct(m, 1)){
                               msgdead(m);
                               return uids;
                       }
                       break;
               default:
                       bye("bad implementation of fetch");
                       return 0;
               }
       if(m->expunged)
               return uids;
       if(vf == 0)
               return 1;

       /*
        * note: it is allowed to send back the responses one at a time
        * rather than all together.  this is exploited to send flags elsewhere.
        */
       Bprint(&bout, "* %ud FETCH (", m->seq);
       sep = "";
       if(uids){
               Bprint(&bout, "UID %ud", m->uid);
               sep = " ";
       }
       for(f = vf; f != nil; f = f->next){
               switch(f->op){
               default:
                       bye("bad implementation of fetch");
                       break;
               case Fflags:
                       Bprint(&bout, "%sFLAGS (", sep);
                       writeflags(&bout, m, 1);
                       Bprint(&bout, ")");
                       break;
               case Fuid:
                       if(uids)
                               continue;
                       Bprint(&bout, "%sUID %ud", sep, m->uid);
                       break;
               case Fenvelope:
                       Bprint(&bout, "%sENVELOPE ", sep);
                       fetchenvelope(m);
                       break;
               case Finternaldate:
                       Bprint(&bout, "%sINTERNALDATE %#D", sep, date2tm(&tm, m->unixdate));
                       break;
               case Fbody:
                       Bprint(&bout, "%sBODY ", sep);
                       fetchbodystruct(m, &m->head, 0);
                       break;
               case Fbodystruct:
                       Bprint(&bout, "%sBODYSTRUCTURE ", sep);
                       fetchbodystruct(m, &m->head, 1);
                       break;
               case Frfc822size:
                       Bprint(&bout, "%sRFC822.SIZE %ud", sep, msgsize(m));
                       break;
               case Frfc822:
                       f->part = FPall;
                       Bprint(&bout, "%sRFC822", sep);
                       fetchbody(m, f);
                       break;
               case Frfc822head:
                       f->part = FPhead;
                       Bprint(&bout, "%sRFC822.HEADER", sep);
                       fetchbody(m, f);
                       break;
               case Frfc822text:
                       f->part = FPtext;
                       Bprint(&bout, "%sRFC822.TEXT", sep);
                       fetchbody(m, f);
                       break;
               case Fbodysect:
               case Fbodypeek:
                       Bprint(&bout, "%sBODY", sep);
                       fetchbody(fetchsect(m, f), f);
                       break;
               }
               sep = " ";
       }
       Bprint(&bout, ")\r\n");

       return 1;
}

/*
* print out section, part, headers;
* find and return message section
*/
Msg *
fetchsect(Msg *m, Fetch *f)
{
       Bputc(&bout, '[');
       Bnlist(&bout, f->sect, ".");
       if(f->part != FPall){
               if(f->sect != nil)
                       Bputc(&bout, '.');
               Bprint(&bout, "%s", fetchpartnames[f->part]);
               if(f->hdrs != nil){
                       Bprint(&bout, " (");
                       Bslist(&bout, f->hdrs, " ");
                       Bputc(&bout, ')');
               }
       }
       Bprint(&bout, "]");
       return findmsgsect(m, f->sect);
}

/*
* actually return the body pieces
*/
void
fetchbody(Msg *m, Fetch *f)
{
       char *s, *t, *e, buf[Bufsize + 2];
       uint n, start, stop, pos;
       int fd, nn;
       Pair p;

       if(m == nil){
               fetchbodystr(f, "", 0);
               return;
       }
       switch(f->part){
       case FPheadfields:
       case FPheadfieldsnot:
               n = m->head.size + 3;
               s = emalloc(n);
               n = selectfields(s, n, m->head.buf, f->hdrs, f->part == FPheadfields);
               fetchbodystr(f, s, n);
               free(s);
               return;
       case FPhead:
//ilog("head.size %d", m->head.size);
               fetchbodystr(f, m->head.buf, m->head.size);
               return;
       case FPmime:
               fetchbodystr(f, m->mime.buf, m->mime.size);
               return;
       case FPall:
               fd = msgfile(m, "rawbody");
               if(fd < 0){
                       msgdead(m);
                       fetchbodystr(f, "", 0);
                       return;
               }
               p = fetchbodypart(f, msgsize(m));
               start = p.start;
//ilog("head.size %d", m->head.size);
               if(start < m->head.size){
                       stop = p.stop;
                       if(stop > m->head.size)
                               stop = m->head.size;
//ilog("fetch header %ld.%ld (%ld)", start, stop, m->head.size);
                       Bwrite(&bout, m->head.buf + start, stop - start);
                       start = 0;
                       stop = p.stop;
                       if(stop <= m->head.size){
                               close(fd);
                               return;
                       }
               }else
                       start -= m->head.size;
               stop = p.stop - m->head.size;
               break;
       case FPtext:
               fd = msgfile(m, "rawbody");
               if(fd < 0){
                       msgdead(m);
                       fetchbodystr(f, "", 0);
                       return;
               }
               p = fetchbodypart(f, m->size);
               start = p.start;
               stop = p.stop;
               break;
       default:
               fetchbodystr(f, "", 0);
               return;
       }

       /*
        * read in each block, convert \n without \r to \r\n.
        * this means partial fetch requires fetching everything
        * through stop, since we don't know how many \r's will be added
        */
       buf[0] = ' ';
       for(pos = 0; pos < stop; ){
               n = Bufsize;
               if(n > stop - pos)
                       n = stop - pos;
               n = read(fd, &buf[1], n);
//ilog("read %ld at %d stop %ld\n", n, pos, stop);
               if(n <= 0){
ilog("must fill %ld bytes\n", stop - pos);
fprint(2, "must fill %d bytes\n", stop - pos);
                       fetchbodyfill(stop - pos);
                       break;
               }
               e = &buf[n + 1];
               *e = 0;
               for(s = &buf[1]; s < e && pos < stop; s = t + 1){
                       t = memchr(s, '\n', e - s);
                       if(t == nil)
                               t = e;
                       n = t - s;
                       if(pos < start){
                               if(pos + n <= start){
                                       s = t;
                                       pos += n;
                               }else{
                                       s += start - pos;
                                       pos = start;
                               }
                               n = t - s;
                       }
                       nn = n;
                       if(pos + nn > stop)
                               nn = stop - pos;
                       if(Bwrite(&bout, s, nn) != nn)
                               writeerr();
//ilog("w %ld at %ld->%ld stop %ld\n", nn, pos, pos + nn, stop);
                       pos += n;
                       if(*t == '\n'){
                               if(t[-1] != '\r'){
                                       if(pos >= start && pos < stop)
                                               Bputc(&bout, '\r');
                                       pos++;
                               }
                               if(pos >= start && pos < stop)
                                       Bputc(&bout, '\n');
                               pos++;
                       }
               }
               buf[0] = e[-1];
       }
       close(fd);
}

/*
* resolve the actual bounds of any partial fetch,
* and print out the bounds & size of string returned
*/
Pair
fetchbodypart(Fetch *f, uint size)
{
       uint start, stop;
       Pair p;

       start = 0;
       stop = size;
       if(f->partial){
               start = f->start;
               if(start > size)
                       start = size;
               stop = start + f->size;
               if(stop > size)
                       stop = size;
               Bprint(&bout, "<%ud>", start);
       }
       Bprint(&bout, " {%ud}\r\n", stop - start);
       p.start = start;
       p.stop = stop;
       return p;
}

/*
* something went wrong fetching data
* produce fill bytes for what we've committed to produce
*/
void
fetchbodyfill(uint n)
{
       while(n-- > 0)
               if(Bputc(&bout, ' ') < 0)
                       writeerr();
}

/*
* return a simple string
*/
void
fetchbodystr(Fetch *f, char *buf, uint size)
{
       Pair p;

       p = fetchbodypart(f, size);
       Bwrite(&bout, buf + p.start, p.stop - p.start);
}

char*
printnlist(Nlist *sect)
{
       static char buf[100];
       char *p;

       for(p = buf; sect; sect = sect->next){
               p += sprint(p, "%ud", sect->n);
               if(sect->next)
                       *p++ = '.';
       }
       *p = 0;
       return buf;
}

/*
* find the numbered sub-part of the message
*/
Msg*
findmsgsect(Msg *m, Nlist *sect)
{
       uint id;

       for(; sect != nil; sect = sect->next){
               id = sect->n;
               for(m = m->kids; m != nil; m = m->next)
                       if(m->id == id)
                               break;
               if(m == nil)
                       return nil;
       }
       return m;
}

void
fetchenvelope(Msg *m)
{
       Tm tm;

       Bprint(&bout, "(%#D %Z ", date2tm(&tm, m->info[Idate]), m->info[Isubject]);
       Bimapaddr(&bout, m->from);
       Bputc(&bout, ' ');
       Bimapaddr(&bout, m->sender);
       Bputc(&bout, ' ');
       Bimapaddr(&bout, m->replyto);
       Bputc(&bout, ' ');
       Bimapaddr(&bout, m->to);
       Bputc(&bout, ' ');
       Bimapaddr(&bout, m->cc);
       Bputc(&bout, ' ');
       Bimapaddr(&bout, m->bcc);
       Bprint(&bout, " %Z %Z)", m->info[Iinreplyto], m->info[Imessageid]);
}

static int
Bmime(Biobuf *b, Mimehdr *mh)
{
       char *sep;

       if(mh == nil)
               return Bprint(b, "NIL");
       sep = "(";
       for(; mh != nil; mh = mh->next){
               Bprint(b, "%s%Z %Z", sep, mh->s, mh->t);
               sep = " ";
       }
       Bputc(b, ')');
       return 0;
}

static void
fetchext(Biobuf *b, Header *h)
{
       Bputc(b, ' ');
       if(h->disposition != nil){
               Bprint(b, "(%Z ", h->disposition->s);
               Bmime(b, h->disposition->next);
               Bputc(b, ')');
       }else
               Bprint(b, "NIL");
       Bputc(b, ' ');
       if(h->language != nil){
               if(h->language->next != nil)
                       Bmime(b, h->language->next);
               else
                       Bprint(&bout, "%Z", h->language->s);
       }else
               Bprint(b, "NIL");
}

void
fetchbodystruct(Msg *m, Header *h, int extensions)
{
       uint len;
       Msg *k;

       if(msgismulti(h)){
               Bputc(&bout, '(');
               for(k = m->kids; k != nil; k = k->next)
                       fetchbodystruct(k, &k->mime, extensions);
               if(m->kids)
                       Bputc(&bout, ' ');
               Bprint(&bout, "%Z", h->type->t);
               if(extensions){
                       Bputc(&bout, ' ');
                       Bmime(&bout, h->type->next);
                       fetchext(&bout, h);
               }

               Bputc(&bout, ')');
               return;
       }

       Bputc(&bout, '(');
       if(h->type != nil){
               Bprint(&bout, "%Z %Z ", h->type->s, h->type->t);
               Bmime(&bout, h->type->next);
       }else
               Bprint(&bout, "\"text\" \"plain\" NIL");

       Bputc(&bout, ' ');
       if(h->id != nil)
               Bprint(&bout, "%Z", h->id->s);
       else
               Bprint(&bout, "NIL");

       Bputc(&bout, ' ');
       if(h->description != nil)
               Bprint(&bout, "%Z", h->description->s);
       else
               Bprint(&bout, "NIL");

       Bputc(&bout, ' ');
       if(h->encoding != nil)
               Bprint(&bout, "%Z", h->encoding->s);
       else
               Bprint(&bout, "NIL");

       /*
        * this is so strange: return lengths for a body[text] response,
        * except in the case of a multipart message, when return lengths for a body[] response
        */
       len = m->size;
       if(h == &m->mime)
               len += m->head.size;
       Bprint(&bout, " %ud", len);

       len = m->lines;
       if(h == &m->mime)
               len += m->head.lines;

       if(h->type == nil || cistrcmp(h->type->s, "text") == 0)
               Bprint(&bout, " %ud", len);
       else if(msgis822(h)){
               Bputc(&bout, ' ');
               k = m;
               if(h != &m->mime)
                       k = m->kids;
               if(k == nil)
                       Bprint(&bout, "(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL) (\"text\" \"plain\" NIL NIL NIL NIL 0 0) 0");
               else{
                       fetchenvelope(k);
                       Bputc(&bout, ' ');
                       fetchbodystruct(k, &k->head, extensions);
                       Bprint(&bout, " %ud", len);
               }
       }

       if(extensions){
               Bprint(&bout, " NIL");  /* md5 */
               fetchext(&bout, h);
       }
       Bputc(&bout, ')');
}

/*
* print a list of addresses;
* each address is printed as '(' personalname atdomainlist mboxname hostname ')'
* the atdomainlist is always NIL
*/
int
Bimapaddr(Biobuf *b, Maddr *a)
{
       char *host, *sep;

       if(a == nil)
               return Bprint(b, "NIL");
       Bputc(b, '(');
       sep = "";
       for(; a != nil; a = a->next){
               /*
                * can't send NIL as hostname, since that is code for a group
                */
               host = a->host? a->host: "";
               Bprint(b, "%s(%Z NIL %Z %Z)", sep, a->personal, a->box, host);
               sep = " ";
       }
       return Bputc(b, ')');
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.