822mimeparts.c

Go to the documentation of this file.

#include <unistd.h>
#include "buffer.h"
#include "logmsg.h"
#include "getln.h"
#include "mess822.h"
#include "exit.h"
#include "case.h"
#include "str.h"
#include "open.h"
#include "fmt.h"
#include "getoptb.h"
#include "byte.h"
 
#define WHO "822mimeparts"
 
#define LINELEN 1000
 
int match;
int flag;
int slink = 0;
int verbose = 0;
stralloc line = {0};
stralloc valuem = {0};
stralloc valuet = {0};
stralloc valuec = {0};
stralloc boundary = {0};
stralloc mname = {0};
stralloc bodybuf = {0};
stralloc partbuf = {0};
stralloc partname = {0};
stralloc alias = {0};
 
static void nomem()
{
  logmsg(WHO,111,FATAL,"out of memory");
}
 
static int issafe(char ch)
{
  if ((ch >= 'a') && (ch <= 'z')) return 1;
  if ((ch >= 'A') && (ch <= 'Z')) return 1;
  if ((ch >= '0') && (ch <= '9')) return 1;
  return 0;
}
 
static void die_write(char *fn) { unlink(fn); _exit(1); };
 
/* We use the "Message-ID" line and take
   ten valid and significant characters 
   out of it to be used as file name part.
*/
char name[11] = { '0', '0', '0', 'u', 'n', 'k', 'n', 'o', 'w', 'n', '\0' };
char pname[7] = { '0', '0', '0', '0', '0', '0', '\0' };
 
static int msgname(char *out,const char *in)
{
  int c;
  int j = 9;
 
  int at = str_chr(in,'@');
  if (in[at] == '@' && at > 9) {
    int i = 1;
    do {
      c = *(in + at - i);
      if (issafe(c)) out[j--] = c;
      i++;
    } while (j >= 0);
  }
 
  return 0;
}
 
static int mime_partname(char *out,char *in,int len)
{
  int c;
  int j = 6, i = 1;
 
  do {
    c = *(in + len - i);
    if (issafe(c)) out[j--] = c;
    i++;
  } while (j >= 0);
 
  return 0;
}
 
char outbuf[LINELEN];
buffer bo;
 
char *mime_type(int type)
{
   switch(type) {
     case 1: case -1: return "7bit"; 
     case 2: case -2: return "8bit"; 
     case 3: case -3: return "base64"; 
     case 4: case -4: return "binary"; 
     case 5: case -5: return "quoted-printable"; 
     default: return "unkown";
   }
   return 0;
}
 
static int printpart(char *name,stralloc *in,int mimetype,stralloc *alias)
{
  int fd;
  int out = 0;
  char *type;
  char size[FMT_ULONG];
  int len;
 
  case_lowers(name);
  fd = open_trunc(name);
  if (fd == -1) die_write(name);
 
  type = mime_type(mimetype);
  len = in->len;
  size[fmt_ulong(size,(unsigned long) len)] = 0;
 
  buffer_init(&bo,buffer_unixwrite,fd,outbuf,sizeof(outbuf));
 
  do { 
    out = (in->len < LINELEN) ? in->len : LINELEN;
    buffer_put(&bo,in->s,out);
    in->len -= out;
    in->s += out;
  } while (in->len > 0); 
 
  if (buffer_flush(&bo)) die_write(name);
  if (close(fd) == -1) die_write(name);
 
  if (alias->len) {
    logmsg(WHO,0,INFO,B("Created: ",name," (",type,", ",size," byte) [",alias->s,"]."));
    if (slink) {
      if (symlink(name,alias->s) == -1) logmsg(WHO,111,ERROR,B("Can't symlink: ",name," to: ",alias->s));
    }
  } else
    logmsg(WHO,0,INFO,B("Created: ",name," (",type,", ",size," byte)."));
 
  return 0;
}
 
mess822_header msid = MESS822_HEADER;
mess822_action hm[] = {
  { "Message-ID", &flag, 0, &valuem, 0, 0, 0 } , { 0, 0, 0, 0, 0, 0, 0 }
} ;
mess822_header type = MESS822_HEADER;
mess822_action ht[] = {
  { "Content-Type", &flag, 0, &valuet, 0, 0, 0 } , { 0, 0, 0, 0, 0, 0, 0 }
} ;
mess822_header enco = MESS822_HEADER;
mess822_action hc[] = {
  { "Content-Transfer-Encoding", &flag, 0, &valuec, 0, 0, 0 } , { 0, 0, 0, 0, 0, 0, 0 }
} ;
 
void msg_bodyproc(int mimetype,int start,int end)
{
  int r = 0;
  char sizes[FMT_ULONG];
  char sizee[FMT_ULONG];
 
  if (!stralloc_copys(&partname,name)) nomem();
  if (!stralloc_cats(&partname,".body,0")) nomem();
  if (!stralloc_0(&partname)) nomem();
 
  stralloc decoded = {0};
  if (!stralloc_ready(&decoded,bodybuf.len)) nomem();
 
  if (mimetype == -1) {
    r = mess822_b64decode(&decoded,bodybuf.s,bodybuf.len,1);
    if (r < 0) logmsg(WHO,111,WARN,"malformed base64 mime part");
  } else if (mimetype == -2) {
    r = mess822_qpdecode(&decoded,bodybuf.s,bodybuf.len,0);
    if (r < 0) logmsg(WHO,111,WARN,"malformed quoted-printable part");
  }
 
  if (r > 0) {
    if (!printpart(partname.s,&decoded,mimetype,&alias)) {
      sizes[fmt_ulong(sizes,(unsigned long) start + 3)] = 0;
      sizee[fmt_ulong(sizee,(unsigned long) end + 2)] = 0;
      if (verbose) logmsg(WHO,0,INFO,B("Start of part: @line=",sizes," End of part: @line=",sizee));
    }
  }
}
 
void mime_partproc(stralloc *bound,int mimetype,int start,int end)
{
  int r = 0;
  char sizes[FMT_ULONG];
  char sizee[FMT_ULONG];
  static int num = 0;  // count of MIME parts
 
  if (partbuf.len < 3) return;
 
  num++;
  sizes[fmt_ulong(sizes,(unsigned long) num)] = 0;
  if (!stralloc_0(&partbuf)) nomem();
 
  mime_partname(pname,bound->s,bound->len);
  if (!stralloc_copys(&partname,name)) nomem();
  if (!stralloc_cats(&partname,".")) nomem();
  if (!stralloc_cats(&partname,pname)) nomem();
  if (!stralloc_cats(&partname,",")) nomem();
  if (!stralloc_cats(&partname,sizes)) nomem();
  if (!stralloc_0(&partname)) nomem();
 
  stralloc decoded = {0};
  if (!stralloc_ready(&decoded,partbuf.len)) nomem();
 
  if (mimetype == 3) {
    r = mess822_b64decode(&decoded,partbuf.s,partbuf.len,0);
    if (r < 0) logmsg(WHO,111,INFO,"malformed base64 mime part");
  } else if (mimetype == 5) {
    r = mess822_qpdecode(&decoded,partbuf.s,partbuf.len,0);
    if (r < 0) logmsg(WHO,111,INFO,"malformed quoted-printable part");
  }
 
  if (r > 0) {
    if (!printpart(partname.s,&decoded,mimetype,&alias)) {
      sizes[fmt_ulong(sizes,(unsigned long) start + 3)] = 0;
      sizee[fmt_ulong(sizee,(unsigned long) end + 2)] = 0;
      if (verbose) logmsg(WHO,0,INFO,B("Start of part: @line=",sizes," End of part: @line=",sizee));
    }
  }
 
  // Done; reset counters 
 
  if (!stralloc_copys(&partbuf,"")) nomem();
  partbuf.len = 0;
 
  return;
}
 
// =?iso-8859-1?B?TGVkIEZvbGllX01lZXNlbmJ1cmcgNWVyTEVEX0F132VuYXVmbmFo?=
 
int decode_name(stralloc *name)
{
   unsigned char ch; 
   int seenq = 0;
   int mimetype = 0;
   int done = 0;
 
   if (*(name->s) != '=' && *(name->s + 1) != '?') return 0;
 
   stralloc in = {0};        // token for decoding
   stralloc out = {0};       // output of entire name
   stralloc word = {0};      // result of decoding token
   if (!stralloc_copys(&in,"")) nomem();
   if (!stralloc_copys(&out,"")) nomem();
 
   for (int i = 0; i < name->len; i++) {
     ch = name->s[i];
 
     if (ch == '\0') break;
     if (ch == '?') seenq++;
     if (seenq == 2) {
       if (!stralloc_copys(&in,"")) nomem();
       mimetype = 0;
       if (ch == 'q' || ch == 'Q') {             // new QP word
          mimetype = 5;  
       } else if (ch == 'b' || ch == 'B') {      // new BASE64 word    
          mimetype = 3;
       }
       continue;
     }   
 
  // Get token
    
     if (mimetype) {
       if (seenq == 3 && ch != '?') if (!stralloc_append(&in,&ch)) nomem();
       if (seenq == 4) { done = 1; if (!stralloc_0(&in)) nomem(); } 
     } else
       if (!stralloc_append(&in,&ch)) nomem();
 
     if (i == name->len - 1) done = 1;        // nothing to follow
     if (!done) continue;
 
   // For each token -> decode 
 
     switch (mimetype) {
       case 3: if (!stralloc_copys(&word,"")) nomem(); 
               if ((done = mess822_b64decode(&word,in.s,in.len,4648)) > 0) {
                 if (!stralloc_catb(&out,word.s,done)) nomem();
               } else {
                 logmsg(WHO,0,WARN,B("error in decoding 'Name:' ",word.s));
                 if (!stralloc_catb(&out,in.s,in.len)) nomem();
               } done = 0; seenq = 0; break;
       case 5: if (!stralloc_copys(&word,"")) nomem();
               if ((done = mess822_qpdecode(&word,in.s,in.len,2047)) > 0) {
                 if (!stralloc_catb(&out,word.s,done)) nomem(); 
               } else {
                 if (!stralloc_catb(&out,in.s,in.len)) nomem();
                 logmsg(WHO,0,WARN,B("error in decoding 'Name:' ",word.s));
                 if (!stralloc_catb(&out,in.s,in.len)) nomem();
               } done = 0; seenq = 0; break;
       }
   }
 
   if (!stralloc_copy(name,&out)) nomem();
   if (!stralloc_0(name)) nomem();
 
  return out.len - 1;
}
 
int b64name(stralloc *name)
{
   int r;
   unsigned char ch;
   int seen = 0;
 
   if (*(name->s) != '=' && *(name->s + 1) != '?') return 0;
 
   stralloc in = {0};  
   stralloc out = {0};  
 
   if (!stralloc_copys(&in,"")) nomem();
 
   for (int i = 2; i < name->len; i++) {
     ch = name->s[i];
     if (ch == '?') { seen++; continue; }
     if (seen == 2) if (!stralloc_append(&in,&ch)) nomem();
   }
   if (!stralloc_0(&in)) nomem();
   r = mess822_b64decode(&out,in.s,in.len,4648);
 
   if (r <= 0) {
     logmsg(WHO,0,WARN,B("error in BASE64 decoding: ",in.s));
     if (!stralloc_copy(name,&in)) nomem();
   } else
     if (!stralloc_copy(name,&out)) nomem();
 
   return out.len - 1;
}
 
int attachment_name(stralloc *name,stralloc *in)
{
  static int seen = 0; // seen = 1: name; seen = 2: catching; seen = 3: caught all; 
  unsigned char ch;
  int seena = 0;
 
  ch = *in->s;
  if (seen == 2)
    if (ch == 'C' || ch == '\n') seen = 3;                 // next Content- or empty line
 
  if (seen == 0 && in->len > 10) {                         // 'Content' and 'name' required
    for (int i = 0; i < in->len - 5; i++) {
      if (!case_diffb(in->s + i,5,"name=")) {              // initial line
        if (!stralloc_copys(name,"")) nomem();
        seen = 1;
        i += 5;
 
        for (int j = i; j < in->len - 2; j++) {
          ch = in->s[j];
          if (ch == '"') { seena++; continue; }            // " => sometimes enclosed
          if (ch == ';') { seen = 3; goto DONE; }          // ; => end-of-token; done
          if (!stralloc_append(name,&ch)) nomem();
        }
        seen = 2;
        if (seena == 2) { seen = 3; goto DONE; }
        return 1;
      }
    }
  }
 
  if (seen && seen < 3) {
    if (ch  == ' ' || ch  == '\t') {
      for (int j = 1 ; j < in->len - 2; j++) {
        ch = in->s[j];
        if (ch == '"') { seena++; continue; }              // maybe
        if (ch == ';') { seen = 3; goto DONE; }            // done
        if (!stralloc_append(name,&ch)) nomem();
        seen = 3;
      } 
      if (seen == 3 || seena == 2) goto DONE;
      return 1;
    }
    if (ch == '\n') { seen == 3; goto DONE; }              // empty line follows    
    return 1;
  }
 
  DONE:
 
  if (seen == 3) {                                         // Got name
    if (!stralloc_0(name)) nomem();
    seen = 0;
    seena = 0;
    return 2; 
  }
  seen = 0;
 
  return 0;
}
      
int main(int argc,char **argv)
{
  int mimetype = 0;           // +/-3: base64, +/-5: quoted-printable + others; 10: PGP pub key
  int part[4] = {0, 0, 0, 0}; // part[0]=part#, part[1]=linestart# in body, part[2]=lineend# in body, part[3]=state
  unsigned char ch;
  int len = 0;
  int done = 0;
  int seen = 0;
  int skip = 0;
  int opt;
 
  while ((opt = getoptb(argc,argv,"hlv")) != opteof)
     switch (opt) {
       case 'h': logmsg(WHO,99,USAGE,"822mimeparts [-v|-l] < message."); break;
       case 'l': slink = 1; break;
       case 'v': verbose = 1; break;
       default : logmsg(WHO,99,USAGE,"822mimeparts [-v|-l] < message."); break;
  }
 
  // The headers we are looking for:
 
  if (!mess822_begin(&msid,hm)) nomem();
  if (!mess822_begin(&type,ht)) nomem();
  if (!mess822_begin(&enco,hc)) nomem();
 
  for (len = 0;;len++) {
    if (getln(buffer_0,&line,&match,'\n') == -1)
      logmsg(WHO,111,FATAL,"unable to read input: ");
    if (!mess822_ok(&line)) break;
    if (!mess822_line(&msid,&line)) nomem();
    if (!mess822_line(&type,&line)) nomem();
    if (!mess822_line(&enco,&line)) nomem(); 
  }
 
  if (match && line.len > 1)
    logmsg(WHO,111,ERROR,"malformed message (first non-header line not blank)");
 
  // Message Name
 
  if (!mess822_end(&msid)) nomem();
  if (!stralloc_copyb(&mname,valuem.s,valuem.len)) nomem();
  if (!stralloc_0(&mname)) nomem();
  msgname(name,mname.s);
 
  // Encoding entire message
 
  if (!mess822_end(&enco)) nomem();
  if (!case_diffb(valuec.s,16,"quoted-printable")) { mimetype = -2; part[3] = -1; } 
  else if (!case_diffb(valuec.s,6,"base64")) { mimetype = -1; part[3] = -1; }
  if (mimetype < 0) { if (!stralloc_cats(&bodybuf,"")) return -1; }
 
  // MIME part boundary from header
 
  if (!mess822_end(&type)) nomem();
 
  for (int i = 0; i < valuet.len - 12; i++) {
    if (*(valuet.s + i) == '\0') break;
    if (!case_diffb(valuet.s + i,9,"boundary=")) {    
      if (!stralloc_copys(&boundary,"--")) nomem();
      i += 9;
 
      for (int j = i; j < valuet.len - 2; j++) {
        ch = valuet.s[j];
        if (ch == ';' || ch == '"') continue;  // ; => next tokenr, " => sometimes enclosed
        if (!stralloc_append(&boundary,&ch)) nomem();
      }
 
      if (boundary.len > 3) if (!stralloc_0(&boundary)) nomem();
    } 
  }
 
  // Message body
 
  for (int l = len;;l++) {
    if (getln(buffer_0,&line,&match,'\n') == -1)
      logmsg(WHO,111,FATAL,"unable to read input: ");
 
    if (!match) break;
    if (!stralloc_0(&line)) nomem();    // => line end: \n\0
 
    // bodybuf is used to capture the entire body; partbuf for a MIME part
    // Unlike partbuf, bodybuf needs to be unaltered for processing
 
    if (mimetype < 0) {     
      if (!stralloc_catb(&bodybuf,line.s,line.len - 1)) nomem(); // \n\0
      if (!part[1]) part[1] = l; part[2] = l;
    } 
 
    // Get Encoding
 
    if (case_startb(line.s,26,"Content-Transfer-Encoding:")) {
      part[0] += 1; part[1] = l; part[3] = 1; 
      mimetype = 0;
       if (case_startb(line.s + 27,4,"7bit")) mimetype = 1; 
       else if (case_startb(line.s + 27,4,"8bit")) mimetype = 2; 
       else if (case_startb(line.s + 27,6,"base64")) mimetype = 3; 
       else if (case_startb(line.s + 27,6,"binary")) mimetype = 4; 
       else if (case_startb(line.s + 27,16,"quoted-printable")) mimetype = 5;
       if (!stralloc_copys(&partbuf,"")) nomem();          // mew MIME part
       continue;
    }
 
    // Get Content-Type - check for exceptions
 
    if (case_startb(line.s,13,"Content-Type:")) { 
      part[3] = 2; 
      if (*(line.s + line.len - 3) == ';') skip = 1;       // Apple-Mail
      if (case_startb(line.s + 14,27,"application/pgp-signature")) mimetype = 10;
    }
    if (case_startb(line.s,2,"X-")) continue;              // 'Exchange': X-Attachment-ID
 
    // Get current MIME boundary
 
    for (int i = 0; i < line.len - 12; i++) {
      done = 0;
      if (*(line.s + i) == '\n') break;
      if (!case_diffb(line.s + i,9,"boundary=")) {    
        if (!stralloc_copys(&boundary,"--")) nomem();
        i += 9;
 
        for (int j = i; j < line.len - 2; j++) {
          ch = line.s[j];
          if (ch == ';') break;                // ; => next token,
          if (ch == '"') continue;             // " => sometimes enclosed
          if (!stralloc_append(&boundary,&ch)) nomem();
        }
 
        if (boundary.len > 3) {
          if (!stralloc_0(&boundary)) nomem();
          part[3] = 2;
          done = 1;
          break;
        } 
      } 
    }
    if (done) continue;
 
    // Get type of attachment
 
    if (part[3]) {
      if (case_startb(line.s,12,"MIME-Version")) { part[3] = 3; continue; }
      if (case_startb(line.s,25,"Content-Type: application") ||
          case_startb(line.s,23,"Content-Type: text/html") ||
          case_startb(line.s,19,"Content-Type: image") ||
          case_startb(line.s,19,"Content-Type: audio") ||
          case_startb(line.s,19,"Content-Type: video") ||
          case_startb(line.s,19,"Content-Type: octet") ||
          case_startb(line.s,19,"Content-Disposition")) { part[3] = 4; }
    }
 
    // Look for attachment name
 
    if (part[3] == 4) {
      seen = attachment_name(&alias,&line);
      if (seen == 1) continue;
      if (seen == 2) decode_name(&alias);
    }
 
    // Got MIME part - discard all none content lines and save rest to 'partbuf'
 
    if (mimetype > 0) {
      if (*line.s == '\n') continue;
      if (case_startb(line.s,10,"Content-")) continue;
      if (skip == 1) { skip = 0; continue; }     // FIXME: Dirty hack
 
      if (case_startb(line.s,boundary.len - 1,boundary.s)) {
        mime_partproc(&boundary,mimetype,part[1],part[2]);
        part[3] = 2; // needs to be pushed back
        continue;
      } else {
        switch (mimetype) {
          case 3: if (*line.s == ' ' || *line.s == '-' || *line.s == '\t') break;
                  if (!stralloc_catb(&partbuf,line.s,line.len - 2)) nomem(); // \n\0 BASE64
                  part[2] = l; part[3] = 5;
                  break;
          case 5: if (!stralloc_catb(&partbuf,line.s,line.len - 1)) nomem(); // \n\0
                  part[2] = l; part[3] = 5;
                  break;
          default: continue;
        } 
 
        // Reading + safing MIME part finished - process it 
 
        if (mimetype != 5 && !str_diffn(line.s,"--",2)) {
          mime_partproc(&boundary,mimetype,part[1],part[2]);
          if (!stralloc_copys(&partbuf,"")) nomem();
          partbuf.len = 0;
          part[3] = 2;  // needs to be pushed back
        } 
      }
    }
  }  // end for loop
 
  if (mimetype < 0) {
    if (!stralloc_0(&bodybuf)) nomem();
    msg_bodyproc(mimetype,part[1],part[2]);
  }
 
  _exit(0);
}