开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
rfc822.c
资源名称：imap-4.7.tar.Z　[点击查看]
上传用户：ycwykj01
上传日期：2007-01-04
资源大小：1819k
文件大小：61k
源码类别：

网络编程

开发平台：

Unix_Linux

rfc822.c：源码内容
  1. /*
  2.  * Program: RFC-822 routines (originally from SMTP)
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 27 July 1988
  13.  * Last Edited: 13 July 1999
  14.  *
  15.  * Sponsorship: The original version of this work was developed in the
  16.  * Symbolic Systems Resources Group of the Knowledge Systems
  17.  * Laboratory at Stanford University in 1987-88, and was funded
  18.  * by the Biomedical Research Technology Program of the National
  19.  * Institutes of Health under grant number RR-00785.
  20.  *
  21.  * Original version Copyright 1988 by The Leland Stanford Junior University
  22.  * Copyright 1999 by the University of Washington
  23.  *
  24.  *  Permission to use, copy, modify, and distribute this software and its
  25.  * documentation for any purpose and without fee is hereby granted, provided
  26.  * that the above copyright notices appear in all copies and that both the
  27.  * above copyright notices and this permission notice appear in supporting
  28.  * documentation, and that the name of the University of Washington or The
  29.  * Leland Stanford Junior University not be used in advertising or publicity
  30.  * pertaining to distribution of the software without specific, written prior
  31.  * permission.  This software is made available "as is", and
  32.  * THE UNIVERSITY OF WASHINGTON AND THE LELAND STANFORD JUNIOR UNIVERSITY
  33.  * DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE,
  34.  * INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  35.  * FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF
  36.  * WASHINGTON OR THE LELAND STANFORD JUNIOR UNIVERSITY BE LIABLE FOR ANY
  37.  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  38.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  39.  * CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF
  40.  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  41.  *
  42.  */
  45. #include <ctype.h>
  46. #include <stdio.h>
  47. #include <time.h>
  48. #include "mail.h"
  49. #include "osdep.h"
  50. #include "rfc822.h"
  51. #include "misc.h"
  53. /* RFC-822 static data */
  56. char *errhst = ERRHOST; /* syntax error host string */
  59. /* Body formats constant strings, must match definitions in mail.h */
  61. char *body_types[TYPEMAX+1] = {
  62.   "TEXT", "MULTIPART", "MESSAGE", "APPLICATION", "AUDIO", "IMAGE", "VIDEO",
  63.   "MODEL", "X-UNKNOWN"
  64. };
  67. char *body_encodings[ENCMAX+1] = {
  68.   "7BIT", "8BIT", "BINARY", "BASE64", "QUOTED-PRINTABLE", "X-UNKNOWN"
  69. };
  72. /* Token delimiting special characters */
  74. /* full RFC-822 specials */
  75. const char *rspecials =  "()<>@,;:\"[].";
  76. /* body token specials */
  77. const char *tspecials = " ()<>@,;:\"[]./?=";
  80. /* Once upon a time, CSnet had a mailer which assigned special semantics to
  81.  * dot in e-mail addresses.  For the sake of that mailer, dot was added to
  82.  * the RFC-822 definition of `specials', even though it had numerous bad side
  83.  * effects:
  84.  *   1) It broke mailbox names on systems which had dots in user names, such as
  85.  * Multics and TOPS-20.  RFC-822's syntax rules require that `Admin . MRC'
  86.  * be considered equivalent to `Admin.MRC'.  Fortunately, few people ever
  87.  * tried this in practice.
  88.  *   2) It required that all personal names with an initial be quoted, a widely
  89.  * detested user interface misfeature.
  90.  *   3) It made the parsing of host names be non-atomic for no good reason.
  91.  * To work around these problems, the following alternate specials lists are
  92.  * defined.  hspecials and wspecials are used in lieu of rspecials, and
  93.  * ptspecials are used in lieu of tspecials.  These alternate specials lists
  94.  * make the parser work a lot better in the real world.  It ain't politically
  95.  * correct, but it lets the users get their job done!
  96.  */
  98. /* parse-word specials */
  99. const char *wspecials = " ()<>@,;:\"[]";
  100. /* parse-token specials for parsing */
  101. const char *ptspecials = " ()<>@,;:\"[]/?=";
  103. /* RFC822 writing routines */
  106. /* Write RFC822 header from message structure
  107.  * Accepts: scratch buffer to write into
  108.  *     message envelope
  109.  *     message body
  110.  */
  112. void rfc822_header (char *header,ENVELOPE *env,BODY *body)
  113. {
  114.   if (env->remail) { /* if remailing */
  115.     long i = strlen (env->remail);
  116.     strcpy (header,env->remail);/* start with remail header */
  117. /* flush extra blank line */
  118.     if (i > 4 && header[i-4] == '15') header[i-2] = '';
  119.   }
  120.   else *header = ''; /* else initialize header to null */
  121.   rfc822_header_line (&header,"Newsgroups",env,env->newsgroups);
  122.   rfc822_header_line (&header,"Date",env,env->date);
  123.   rfc822_address_line (&header,"From",env,env->from);
  124.   rfc822_address_line (&header,"Sender",env,env->sender);
  125.   rfc822_address_line (&header,"Reply-To",env,env->reply_to);
  126.   rfc822_header_line (&header,"Subject",env,env->subject);
  127.   if (env->bcc && !(env->to || env->cc))
  128.     strcat (header,"To: undisclosed recipients: ;1512");
  129.   rfc822_address_line (&header,"To",env,env->to);
  130.   rfc822_address_line (&header,"cc",env,env->cc);
  131. /* bcc's are never written...
  132.  * rfc822_address_line (&header,"bcc",env,env->bcc);
  133.  */
  134.   rfc822_header_line (&header,"In-Reply-To",env,env->in_reply_to);
  135.   rfc822_header_line (&header,"Message-ID",env,env->message_id);
  136.   rfc822_header_line (&header,"Followup-to",env,env->followup_to);
  137.   rfc822_header_line (&header,"References",env,env->references);
  138.   if (body && !env->remail) { /* not if remail or no body structure */
  139.     strcat (header,"MIME-Version: 1.01512");
  140.     rfc822_write_body_header (&header,body);
  141.   }
  142.   strcat (header,"1512"); /* write terminating blank line */
  143. }
  145. /* Write RFC822 address from header line
  146.  * Accepts: pointer to destination string pointer
  147.  *     pointer to header type
  148.  *     message to interpret
  149.  *     address to interpret
  150.  */
  152. void rfc822_address_line (char **header,char *type,ENVELOPE *env,ADDRESS *adr)
  153. {
  154.   char *s = (*header += strlen (*header));
  155.   if (adr) { /* do nothing if no addresses */
  156.     if (env && env->remail) strcat (s,"ReSent-");
  157.     strcat (s,type); /* write header name */
  158.     strcat (s,": ");
  159.     s = rfc822_write_address_full (s + strlen (s),adr,*header);
  160. /* tie off header line */
  161.     *s++ = '15'; *s++ = '12'; *s = '';
  162.     *header = s; /* set return value */
  163.   }
  164. }
  167. /* Write RFC822 text from header line
  168.  * Accepts: pointer to destination string pointer
  169.  *     pointer to header type
  170.  *     message to interpret
  171.  *     pointer to text
  172.  */
  174. void rfc822_header_line (char **header,char *type,ENVELOPE *env,char *text)
  175. {
  176.   if (text) sprintf ((*header += strlen (*header)),"%s%s: %s1512",
  177.      env->remail ? "ReSent-" : "",type,text);
  178. }
  180. /* Write RFC822 address list
  181.  * Accepts: pointer to destination string
  182.  *     address to interpret
  183.  *     header base if pretty-printing
  184.  * Returns: end of destination string
  185.  */
  187. /* RFC822 continuation, must start with CRLF */
  188. #define RFC822CONT "1512    "
  190. char *rfc822_write_address_full (char *dest,ADDRESS *adr,char *base)
  191. {
  192.   long i,n;
  193.   for (n = 0; adr; adr = adr->next) {
  194.     if (adr->host) { /* ordinary address? */
  195.       if (!(base && n)) { /* only write if exact form or not in group */
  196. /* simple case? */
  197. if (!(adr->personal || adr->adl)) rfc822_address (dest,adr);
  198. else { /* no, must use phrase <route-addr> form */
  199.   if (adr->personal) rfc822_cat (dest,adr->personal,rspecials);
  200.   strcat (dest," <"); /* write address delimiter */
  201.   rfc822_address (dest,adr);
  202.   strcat (dest,">"); /* closing delimiter */
  203. }
  204. if (adr->next && adr->next->mailbox) strcat (dest,", ");
  205.       }
  206.     }
  207.     else if (adr->mailbox) { /* start of group? */
  208. /* yes, write group name */
  209.       rfc822_cat (dest,adr->mailbox,rspecials);
  210.       strcat (dest,": "); /* write group identifier */
  211.       n++; /* in a group */
  212.     }
  213.     else if (n) { /* must be end of group (but be paranoid) */
  214.       strcat (dest,";");
  215. /* no longer in that group */
  216.       if (!--n && adr->next && adr->next->mailbox) strcat (dest,", ");
  217.     }
  218.     i = strlen (dest); /* length of what we just wrote */
  219. /* write continuation if doesn't fit */
  220.     if (base && (dest > (base + 4)) && ((dest + i) > (base + 78))) {
  221.       memmove (dest + sizeof (RFC822CONT) - 1,dest,i + 1);
  222.       memcpy (dest,RFC822CONT,sizeof (RFC822CONT) - 1);
  223.       base = dest + 2; /* new base */
  224.       dest += i + sizeof (RFC822CONT) - 1;
  225.     }
  226.     else dest += i; /* new end of string */
  227.   }
  228.   return dest; /* return end of string */
  229. }
  231. /* Write RFC822 route-address to string
  232.  * Accepts: pointer to destination string
  233.  *     address to interpret
  234.  */
  236. void rfc822_address (char *dest,ADDRESS *adr)
  237. {
  238.   if (adr && adr->host) { /* no-op if no address */
  239.     if (adr->adl) { /* have an A-D-L? */
  240.       strcat (dest,adr->adl);
  241.       strcat (dest,":");
  242.     }
  243. /* write mailbox name */
  244.     rfc822_cat (dest,adr->mailbox,wspecials);
  245.     if (*adr->host != '@') { /* unless null host (HIGHLY discouraged!) */
  246.       strcat (dest,"@"); /* host delimiter */
  247.       strcat (dest,adr->host); /* write host name */
  248.     }
  249.   }
  250. }
  253. /* Concatenate RFC822 string
  254.  * Accepts: pointer to destination string
  255.  *     pointer to string to concatenate
  256.  *     list of special characters
  257.  */
  259. void rfc822_cat (char *dest,char *src,const char *specials)
  260. {
  261.   char *s;
  262.   if (strpbrk (src,specials)) { /* any specials present? */
  263.     strcat (dest,"""); /* opening quote */
  264. /* truly bizarre characters in there? */
  265.     while (s = strpbrk (src,"\"")) {
  266.       strncat (dest,src,s-src); /* yes, output leader */
  267.       strcat (dest,"\"); /* quoting */
  268.       strncat (dest,s,1); /* output the bizarre character */
  269.       src = ++s; /* continue after the bizarre character */
  270.     }
  271.     if (*src) strcat (dest,src);/* output non-bizarre string */
  272.     strcat (dest,"""); /* closing quote */
  273.   }
  274.   else strcat (dest,src); /* otherwise it's the easy case */
  275. }
  277. /* Write body content header
  278.  * Accepts: pointer to destination string pointer
  279.  *     pointer to body to interpret
  280.  */
  282. void rfc822_write_body_header (char **dst,BODY *body)
  283. {
  284.   char *s;
  285.   STRINGLIST *stl;
  286.   PARAMETER *param = body->parameter;
  287.   sprintf (*dst += strlen (*dst),"Content-Type: %s",body_types[body->type]);
  288.   s = body->subtype ? body->subtype : rfc822_default_subtype (body->type);
  289.   sprintf (*dst += strlen (*dst),"/%s",s);
  290.   if (param) do {
  291.     sprintf (*dst += strlen (*dst),"; %s=",param->attribute);
  292.     rfc822_cat (*dst,param->value,tspecials);
  293.   } while (param = param->next);
  294.   else if (body->type == TYPETEXT) strcat (*dst,"; CHARSET=US-ASCII");
  295.   strcpy (*dst += strlen (*dst),"1512");
  296.   if (body->encoding) /* note: encoding 7BIT never output! */
  297.     sprintf (*dst += strlen (*dst),"Content-Transfer-Encoding: %s1512",
  298.      body_encodings[body->encoding]);
  299.   if (body->id) sprintf (*dst += strlen (*dst),"Content-ID: %s1512",
  300.  body->id);
  301.   if (body->description)
  302.     sprintf (*dst += strlen (*dst),"Content-Description: %s1512",
  303.      body->description);
  304.   if (body->md5)
  305.     sprintf (*dst += strlen (*dst),"Content-MD5: %s1512",body->md5);
  306.   if (stl = body->language) {
  307.     strcpy (*dst += strlen (*dst),"Content-Language: ");
  308.     do {
  309.       rfc822_cat (*dst,(char *) stl->text.data,tspecials);
  310.       if (stl = stl->next) strcat (*dst += strlen (*dst),", ");
  311.     }
  312.     while (stl);
  313.     strcpy (*dst += strlen (*dst),"1512");
  314.   }
  315.   if (body->disposition.type) {
  316.     sprintf (*dst += strlen (*dst),"Content-Disposition: %s",
  317.      body->disposition.type);
  318.     if (param = body->disposition.parameter) do {
  319.       sprintf (*dst += strlen (*dst),"; %s=",param->attribute);
  320.       rfc822_cat (*dst,param->value,tspecials);
  321.     } while (param = param->next);
  322.     strcpy (*dst += strlen (*dst),"1512");
  323.   }
  324. }
  327. /* Subtype defaulting (a no-no, but regretably necessary...)
  328.  * Accepts: type code
  329.  * Returns: default subtype name
  330.  */
  332. char *rfc822_default_subtype (unsigned short type)
  333. {
  334.   switch (type) {
  335.   case TYPETEXT: /* default is TEXT/PLAIN */
  336.     return "PLAIN";
  337.   case TYPEMULTIPART: /* default is MULTIPART/MIXED */
  338.     return "MIXED";
  339.   case TYPEMESSAGE: /* default is MESSAGE/RFC822 */
  340.     return "RFC822";
  341.   case TYPEAPPLICATION: /* default is APPLICATION/OCTET-STREAM */
  342.     return "OCTET-STREAM";
  343.   case TYPEAUDIO: /* default is AUDIO/BASIC */
  344.     return "BASIC";
  345.   default: /* others have no default subtype */
  346.     return "UNKNOWN";
  347.   }
  348. }
  350. /* RFC822 parsing routines */
  353. /* Parse an RFC822 message
  354.  * Accepts: pointer to return envelope
  355.  *     pointer to return body
  356.  *     pointer to header
  357.  *     header byte count
  358.  *     pointer to body stringstruct
  359.  *     pointer to local host name
  360.  *     recursion depth
  361.  *     source driver flags
  362.  */
  364. void rfc822_parse_msg_full (ENVELOPE **en,BODY **bdy,char *s,unsigned long i,
  365.     STRING *bs,char *host,unsigned long depth,
  366.     unsigned long flags)
  367. {
  368.   char c,*t,*d;
  369.   char *tmp = (char *) fs_get ((size_t) i + 100);
  370.   ENVELOPE *env = (*en = mail_newenvelope ());
  371.   BODY *body = bdy ? (*bdy = mail_newbody ()) : NIL;
  372.   long MIMEp = -1; /* flag that MIME semantics are in effect */
  373.   long PathP = NIL; /* flag that a Path: was seen */
  374.   parseline_t pl = (parseline_t) mail_parameters (NIL,GET_PARSELINE,NIL);
  375.   while (i && *s != 'n') { /* until end of header */
  376.     t = tmp; /* initialize buffer pointer */
  377.     c = ' '; /* and previous character */
  378.     while (i && c) { /* collect text until logical end of line */
  379.       switch (c = *s++) { /* slurp a character */
  380.       case '15': /* return, possible end of logical line */
  381. if (*s == 'n') break; /* ignore if LF follows */
  382.       case '12': /* LF, possible end of logical line */
  383. /* tie off unless next line starts with WS */
  384. if (*s != ' ' && *s != 't') *t++ = c = '';
  385. break;
  386.       case 't': /* tab */
  387. *t++ = ' '; /* coerce to space */
  388. break;
  389.       default: /* all other characters */
  390. *t++ = c; /* insert the character into the line */
  391. break;
  392.       }
  393.       if (!--i) *t++ = ''; /* see if end of header */
  394.     }
  396. /* find header item type */
  397.     if (t = d = strchr (tmp,':')) {
  398.       *d++ = ''; /* tie off header item, point at its data */
  399.       while (*d == ' ') d++; /* flush whitespace */
  400.       while ((tmp < t--) && (*t == ' ')) *t = '';
  401.       ucase (tmp); /* coerce to uppercase */
  402. /* external callback */
  403.       if (pl) (*pl) (env,tmp,d,host);
  404.       switch (*tmp) { /* dispatch based on first character */
  405.       case '>': /* possible >From: */
  406. if (!strcmp (tmp+1,"FROM")) rfc822_parse_adrlist (&env->from,d,host);
  407. break;
  408.       case 'B': /* possible bcc: */
  409. if (!strcmp (tmp+1,"CC")) rfc822_parse_adrlist (&env->bcc,d,host);
  410. break;
  411.       case 'C': /* possible cc: or Content-<mumble>*/
  412. if (!strcmp (tmp+1,"C")) rfc822_parse_adrlist (&env->cc,d,host);
  413. else if ((tmp[1] == 'O') && (tmp[2] == 'N') && (tmp[3] == 'T') &&
  414.  (tmp[4] == 'E') && (tmp[5] == 'N') && (tmp[6] == 'T') &&
  415.  (tmp[7] == '-') && body)
  416.   switch (MIMEp) {
  417.   case -1: /* unknown if MIME or not */
  418.     if (MIMEp = search ((unsigned char *) s-1,i,
  419. (unsigned char *)"12MIME-Version",
  420. (long) 13))
  421.   case T: /* definitely MIME */
  422.       rfc822_parse_content_header (body,tmp+8,d);
  423.   }
  424. break;
  425.       case 'D': /* possible Date: */
  426. if (!env->date && !strcmp (tmp+1,"ATE")) env->date = cpystr (d);
  427. break;
  428.       case 'F': /* possible From: */
  429. if (!strcmp (tmp+1,"ROM")) rfc822_parse_adrlist (&env->from,d,host);
  430. else if (!strcmp (tmp+1,"OLLOWUP-TO")) {
  431.   t = env->followup_to = (char *) fs_get (1 + strlen (d));
  432.   while (c = *d++) if (c != ' ') *t++ = c;
  433.   *t++ = '';
  434. }
  435. break;
  436.       case 'I': /* possible In-Reply-To: */
  437. if (!env->in_reply_to && !strcmp (tmp+1,"N-REPLY-TO"))
  438.   env->in_reply_to = cpystr (d);
  439. break;
  441.       case 'M': /* possible Message-ID: or MIME-Version: */
  442. if (!env->message_id && !strcmp (tmp+1,"ESSAGE-ID"))
  443.   env->message_id = cpystr (d);
  444. else if (!strcmp (tmp+1,"IME-VERSION")) {
  445. /* tie off at end of phrase */
  446.   if (t = rfc822_parse_phrase (d)) *t = '';
  447.   rfc822_skipws (&d); /* skip whitespace */
  448. /* known version? */
  449.   if (strcmp (d,"1.0") && strcmp (d,"RFC-XXXX"))
  450.     mm_log ("Warning: message has unknown MIME version",PARSE);
  451.   MIMEp = T; /* note that we are MIME */
  452. }
  453. break;
  454.       case 'N': /* possible Newsgroups: */
  455. if (!env->newsgroups && !strcmp (tmp+1,"EWSGROUPS")) {
  456.   t = env->newsgroups = (char *) fs_get (1 + strlen (d));
  457.   while (c = *d++) if (c != ' ') *t++ = c;
  458.   *t++ = '';
  459. }
  460. break;
  461.       case 'P': /* possible Path: */
  462. if (!strcmp (tmp+1,"ATH")) PathP = T;
  463. break;
  464.       case 'R': /* possible Reply-To: */
  465. if (!strcmp (tmp+1,"EPLY-TO"))
  466.   rfc822_parse_adrlist (&env->reply_to,d,host);
  467. else if (!env->references && !strcmp (tmp+1,"EFERENCES"))
  468.   env->references = cpystr (d);
  469. break;
  470.       case 'S': /* possible Subject: or Sender: */
  471. if (!env->subject && !strcmp (tmp+1,"UBJECT"))
  472.   env->subject = cpystr (d);
  473. else if (!strcmp (tmp+1,"ENDER"))
  474.   rfc822_parse_adrlist (&env->sender,d,host);
  475. break;
  476.       case 'T': /* possible To: */
  477. if (!strcmp (tmp+1,"O")) rfc822_parse_adrlist (&env->to,d,host);
  478. break;
  479.       default:
  480. break;
  481.       }
  482.     }
  483.   }
  485.   /* We require a Path: header and/or a Message-ID belonging to a known
  486.    * winning mail program, in order to believe Newsgroups:.  This is because
  487.    * of the unfortunate existance of certain cretins who believe that it
  488.    * is reasonable to transmit messages via SMTP with a "Newsgroups" header
  489.    * that were not actually posted to any of the named newsgroups.
  490.    * The authors of other high-quality email/news software are encouraged to
  491.    * use similar methods to indentify messages as coming from their software,
  492.    * and having done so, to tell us so they too can be blessed in this list.
  493.    *
  494.    * May 1998 update: as was predicted back in March 1995 when this kludge was
  495.    * first added, mail/news unifying programs are now the norm.  However, the
  496.    * encouragement in the previous paragraph didn't take, and there's no good
  497.    * way to determine bogons accurately.  Consequently, we no longer remove the
  498.    * newsgroup information from the envelope on the bogon test; we just light
  499.    * a bogon bit and let the main program worry about what to do.
  500.    */
  501.   if (env->newsgroups && !PathP && env->message_id &&
  502.       strncmp (env->message_id,"<Pine.",6) &&
  503.       strncmp (env->message_id,"<MS-C.",6) &&
  504.       strncmp (env->message_id,"<MailManager.",13) &&
  505.       strncmp (env->message_id,"<EasyMail.",11) &&
  506.       strncmp (env->message_id,"<ML-",4)) env->ngbogus = T;
  507.   fs_give ((void **) &tmp); /* done with scratch buffer */
  508. /* default Sender: and Reply-To: to From: */
  509.   if (!env->sender) env->sender = rfc822_cpy_adr (env->from);
  510.   if (!env->reply_to) env->reply_to = rfc822_cpy_adr (env->from);
  511. /* now parse the body */
  512.   if (body) rfc822_parse_content (body,bs,host,depth,flags);
  513. }
  515. /* Parse a message body content
  516.  * Accepts: pointer to body structure
  517.  *     body string
  518.  *     pointer to local host name
  519.  *     recursion depth
  520.  *     source driver flags
  521.  */
  523. void rfc822_parse_content (BODY *body,STRING *bs,char *h,unsigned long depth,
  524.    unsigned long flags)
  525. {
  526.   char c,c1,*s,*s1;
  527.   int f;
  528.   unsigned long i,j,k,m;
  529.   PARAMETER *param;
  530.   PART *part = NIL;
  531.   if (depth > MAXMIMEDEPTH) { /* excessively deep recursion? */
  532.     body->type = TYPETEXT; /* yes, probably a malicious MIMEgram */
  533.     mm_log ("Ignoring excessively deep MIME recursion",PARSE);
  534.   }
  535.   if (!body->subtype) /* default subtype if still unknown */
  536.     body->subtype = cpystr (rfc822_default_subtype (body->type));
  537. /* note offset and sizes */
  538.   body->contents.offset = GETPOS (bs);
  539. /* note internal body size in all cases */
  540.   body->size.bytes = body->contents.text.size = i = SIZE (bs);
  541.   if (!(flags & DR_CRLF)) body->size.bytes = strcrlflen (bs);
  542.   switch (body->type) { /* see if anything else special to do */
  543.   case TYPETEXT: /* text content */
  544.     if (!body->parameter) { /* default parameters */
  545.       body->parameter = mail_newbody_parameter ();
  546.       body->parameter->attribute = cpystr ("CHARSET");
  547.       body->parameter->value = cpystr ("US-ASCII");
  548.     }
  549. /* count number of lines */
  550.     while (i--) if ((SNX (bs)) == 'n') body->size.lines++;
  551.     break;
  553.   case TYPEMESSAGE: /* encapsulated message */
  554.     body->nested.msg = mail_newmsg ();
  555. /* encapsulated RFC-822 message? */
  556.     if (!strcmp (body->subtype,"RFC822")) {
  557.       switch (body->encoding) { /* make sure valid encoding */
  558.       case ENC7BIT: /* these are valid nested encodings */
  559.       case ENC8BIT:
  560.       case ENCBINARY:
  561. break;
  562.       default:
  563. mm_log ("Ignoring nested encoding of message contents",PARSE);
  564.       }
  565. /* hunt for blank line */
  566.       for (c = '12',j = 0; (i > j) && ((c != '12') || (CHR(bs) != '12'));
  567.    j++) if ((c1 = SNX (bs)) != '15') c = c1;
  568.       if (i > j) { /* unless no more text */
  569. c1 = SNX (bs); /* body starts here */
  570. j++; /* advance count */
  571.       }
  572. /* note body text offset and header size */
  573.       body->nested.msg->header.text.size = j;
  574.       body->nested.msg->text.text.size = body->contents.text.size - j;
  575.       body->nested.msg->text.offset = GETPOS (bs);
  576.       body->nested.msg->full.offset = body->nested.msg->header.offset =
  577. body->contents.offset;
  578.       body->nested.msg->full.text.size = body->contents.text.size;
  579. /* copy header string */
  580.       SETPOS (bs,body->contents.offset);
  581.       s = (char *) fs_get ((size_t) j + 1);
  582.       for (s1 = s,k = j; k--; *s1++ = SNX (bs));
  583.       s[j] = ''; /* tie off string (not really necessary) */
  584. /* now parse the body */
  585.       rfc822_parse_msg_full (&body->nested.msg->env,&body->nested.msg->body,s,
  586.      j,bs,h,depth+1,flags);
  587.       fs_give ((void **) &s); /* free header string */
  588. /* restore position */
  589.       SETPOS (bs,body->contents.offset);
  590.     }
  591. /* count number of lines */
  592.     while (i--) if (SNX (bs) == 'n') body->size.lines++;
  593.     break;
  594.   case TYPEMULTIPART: /* multiple parts */
  595.     switch (body->encoding) { /* make sure valid encoding */
  596.     case ENC7BIT: /* these are valid nested encodings */
  597.     case ENC8BIT:
  598.     case ENCBINARY:
  599.       break;
  600.     default:
  601.       mm_log ("Ignoring nested encoding of multipart contents",PARSE);
  602.     }
  603. /* remember if digest */
  604.     f = !strcmp (body->subtype,"DIGEST");
  605. /* find cookie */
  606.     for (s1 = NIL,param = body->parameter; param && !s1; param = param->next)
  607.       if (!strcmp (param->attribute,"BOUNDARY")) s1 = param->value;
  608.     if (!(s1 && *s1)) s1 = "-"; /* yucky default */
  609.     j = strlen (s1); /* length of cookie and header */
  610.     c = '12'; /* initially at beginning of line */
  612.     while (i > j) { /* examine data */
  613.       if (m = GETPOS (bs)) m--; /* get position in front of character */
  614.       switch (c) { /* examine each line */
  615.       case '15': /* handle CRLF form */
  616. if (CHR (bs) == '12'){/* following LF? */
  617.   c = SNX (bs); i--; /* yes, slurp it */
  618. }
  619.       case '12': /* at start of a line, start with -- ? */
  620. if (i-- && ((c = SNX (bs)) == '-') && i-- && ((c = SNX (bs)) == '-')) {
  621. /* see if cookie matches */
  622.   for (k = j,s = s1; i-- && *s++ == (c = SNX (bs)) && --k;);
  623.   if (k) break; /* strings didn't match if non-zero */
  624. /* look at what follows cookie */
  625.   if (i && i--) switch (c = SNX (bs)) {
  626.   case '-': /* at end if two dashes */
  627.     if ((i && i--) && ((c = SNX (bs)) == '-') &&
  628. ((i && i--) ? (((c = SNX (bs)) == '15') || (c=='12')):T)) {
  629. /* if have a final part calculate its size */
  630.       if (part) part->body.mime.text.size =
  631. (m > part->body.mime.offset) ? (m - part->body.mime.offset) :0;
  632.       part = NIL; i = 1; /* terminate scan */
  633.     }
  634.     break;
  635.   case '15': /* handle CRLF form */
  636.     if (i && CHR (bs) == '12') {
  637.       c = SNX (bs); i--;/* yes, slurp it */
  638.     }
  639.   case '12': /* new line */
  640.     if (part) { /* calculate size of previous */
  641.       part->body.mime.text.size =
  642. (m > part->body.mime.offset) ? (m-part->body.mime.offset) : 0;
  643. /* instantiate next */
  644.       part = part->next = mail_newbody_part ();
  645.     } /* otherwise start new list */
  646.     else part = body->nested.part = mail_newbody_part ();
  647. /* digest has a different default */
  648.     if (f) part->body.type = TYPEMESSAGE;
  649. /* note offset from main body */
  650.     part->body.mime.offset = GETPOS (bs);
  651.     break;
  652.   default: /* whatever it was it wasn't valid */
  653.     break;
  654.   }
  655. }
  656. break;
  657.       default: /* not at a line */
  658. c = SNX (bs); i--; /* get next character */
  659. break;
  660.       }
  661.     }
  663. /* calculate size of any final part */
  664.     if (part) part->body.mime.text.size = i +
  665.       ((GETPOS(bs) > part->body.mime.offset) ?
  666.        (GETPOS(bs) - part->body.mime.offset) : 0);
  667. /* make a scratch buffer */
  668.     s1 = (char *) fs_get ((size_t) (k = MAILTMPLEN));
  669. /* parse non-empty body parts */
  670.     for (part = body->nested.part; part; part = part->next) {
  671.       if (i = part->body.mime.text.size) {
  672. /* move to that part of the body */
  673. SETPOS (bs,part->body.mime.offset);
  674. /* until end of header */
  675. while (i && ((c = CHR (bs)) != '15') && (c != '12')) {
  676. /* collect text until logical end of line */
  677.   for (j = 0,c = ' '; c; ) {
  678. /* make sure buffer big enough */
  679.     if (j > (k - 10)) fs_resize ((void *) &s1,k += MAILTMPLEN);
  680.     switch (c1 = SNX (bs)) {
  681.     case '15': /* return */
  682.       if (i && (CHR (bs) == '12')) {
  683. c1 = SNX (bs); /* eat any LF following */
  684. i--;
  685.       }
  686.     case '12': /* newline, possible end of logical line */
  687. /* tie off unless continuation */
  688.       if (!i || ((CHR (bs) != ' ') && (CHR (bs) != 't')))
  689. s1[j] = c = '';
  690.       break;
  691.     case 't': /* tab */
  692.     case ' ': /* insert whitespace if not already there */
  693.       if (c != ' ') s1[j++] = c = ' ';
  694.       break;
  695.     default: /* all other characters */
  696.       s1[j++] = c = c1; /* insert the character into the line */
  697.       break;
  698.     }
  699. /* end of data ties off the header */
  700.     if (!--i) s1[j++] = c = '';
  701.   }
  703. /* find header item type */
  704.   if (((s1[0] == 'C') || (s1[0] == 'c')) &&
  705.       ((s1[1] == 'O') || (s1[1] == 'o')) &&
  706.       ((s1[2] == 'N') || (s1[2] == 'n')) &&
  707.       ((s1[3] == 'T') || (s1[3] == 't')) &&
  708.       ((s1[4] == 'E') || (s1[4] == 'e')) &&
  709.       ((s1[5] == 'N') || (s1[5] == 'n')) &&
  710.       ((s1[6] == 'T') || (s1[6] == 't')) &&
  711.       (s1[7] == '-') && (s = strchr (s1+8,':'))) {
  712. /* tie off and flush whitespace */
  713.     for (*s++ = ''; *s == ' '; s++);
  714. /* parse the header */
  715.     rfc822_parse_content_header (&part->body,ucase (s1+8),s);
  716.   }
  717. }
  718. /* skip header trailing (CR)LF */
  719. if (i && (CHR (bs) =='15')) {i--; c1 = SNX (bs);}
  720. if (i && (CHR (bs) =='12')) {i--; c1 = SNX (bs);}
  721. j = bs->size; /* save upper level size */
  722. /* set offset for next level, fake size to i */
  723. bs->size = GETPOS (bs) + i;
  724. part->body.mime.text.size -= i;
  725. /* now parse it */
  726. rfc822_parse_content (&part->body,bs,h,depth+1,flags);
  727. bs->size = j; /* restore current level size */
  728.       }
  729.       else part->body.subtype = /* default subtype if necessary */
  730. cpystr (rfc822_default_subtype (part->body.type));
  731.     }
  732.     fs_give ((void **) &s1); /* finished with scratch buffer */
  733.     break;
  734.   default: /* nothing special to do in any other case */
  735.     break;
  736.   }
  737. }
  739. /* Parse RFC822 body content header
  740.  * Accepts: body to write to
  741.  *     possible content name
  742.  *     remainder of header
  743.  */
  745. void rfc822_parse_content_header (BODY *body,char *name,char *s)
  746. {
  747.   char c,*t;
  748.   long i;
  749.   STRINGLIST *stl;
  750. /* flush whitespace */
  751.   if (t = strchr (name,' ')) *t = '';
  752.   switch (*name) { /* see what kind of content */
  753.   case 'I': /* possible Content-ID */
  754.     if (!(strcmp (name+1,"D") || body->id)) body->id = cpystr (s);
  755.     break;
  756.   case 'D': /* possible Content-Description */
  757.     if (!(strcmp (name+1,"ESCRIPTION") || body->description))
  758.       body->description = cpystr (s);
  759.     if (!(strcmp (name+1,"ISPOSITION") || body->disposition.type)) {
  760. /* get type word */
  761.       if (!(name = rfc822_parse_word (s,ptspecials))) break;
  762.       c = *name; /* remember delimiter */
  763.       *name = ''; /* tie off type */
  764.       body->disposition.type = ucase (cpystr (s));
  765.       *name = c; /* restore delimiter */
  766.       rfc822_skipws (&name); /* skip whitespace */
  767.       rfc822_parse_parameter (&body->disposition.parameter,name);
  768.     }
  769.     break;
  770.   case 'L': /* possible Content-Language */
  771.     if (!(strcmp (name+1,"ANGUAGE") || body->language)) {
  772.       stl = NIL; /* process languages */
  773.       while (s && (name = rfc822_parse_word (s,ptspecials))) {
  774. c = *name; /* save delimiter */
  775. *name = ''; /* tie off subtype */
  776. if (stl) stl = stl->next = mail_newstringlist ();
  777. else stl = body->language = mail_newstringlist ();
  778. stl->text.data = (unsigned char *) ucase (cpystr (s));
  779. stl->text.size = strlen ((char *) stl->text.data);
  780. *name = c; /* restore delimiter */
  781. rfc822_skipws (&name); /* skip whitespace */
  782. if (*name == ',') { /* any more languages? */
  783.   s = ++name; /* advance to it them */
  784.   rfc822_skipws (&s);
  785. }
  786. else s = NIL; /* bogus or end of list */
  787.       }
  788.     }
  789.     break;
  790.   case 'M': /* possible Content-MD5 */
  791.     if (!(strcmp (name+1,"D5") || body->md5)) body->md5 = cpystr (s);
  792.     break;
  794.   case 'T': /* possible Content-Type/Transfer-Encoding */
  795.     if (!(strcmp (name+1,"YPE") || body->subtype || body->parameter)) {
  796. /* get type word */
  797.       if (!(name = rfc822_parse_word (s,ptspecials))) break;
  798.       c = *name; /* remember delimiter */
  799.       *name = ''; /* tie off type */
  800.       ucase (s); /* search for body type */
  801.       for (i=0; (i<=TYPEMAX) && body_types[i] && strcmp(s,body_types[i]); i++);
  802.       if (i > TYPEMAX) body->type = TYPEOTHER;
  803.       else { /* if empty slot, assign it to this type */
  804. if (!body_types[i]) body_types[i] = cpystr (s);
  805. body->type = (unsigned short) i;
  806.       }
  807.       *name = c; /* restore delimiter */
  808.       rfc822_skipws (&name); /* skip whitespace */
  809.       if ((*name == '/') && /* subtype? */
  810.   (name = rfc822_parse_word ((s = ++name),ptspecials))) {
  811. c = *name; /* save delimiter */
  812. *name = ''; /* tie off subtype */
  813. rfc822_skipws (&s); /* copy subtype */
  814. if (s) body->subtype = ucase (cpystr (s));
  815. *name = c; /* restore delimiter */
  816. rfc822_skipws (&name); /* skip whitespace */
  817.       }
  818.       else { /* no subtype */
  819. if (!name) { /* did the fool have a subtype delimiter? */
  820.   name = s; /* barf, restore pointer */
  821.   rfc822_skipws (&name);/* skip leading whitespace */
  822. }
  823.       }
  824.       rfc822_parse_parameter (&body->parameter,name);
  825.     }
  826.     else if (!strcmp (name+1,"RANSFER-ENCODING")) {
  827. /* flush out any confusing whitespace */
  828.       if (t = strchr (ucase (s),' ')) *t = '';
  829. /* search for body encoding */
  830.       for (i = 0; (i <= ENCMAX) && body_encodings[i] &&
  831.    strcmp (s,body_encodings[i]); i++);
  832.       if (i > ENCMAX) body->type = ENCOTHER;
  833.       else { /* if empty slot, assign it to this type */
  834. if (!body_encodings[i]) body_encodings[i] = cpystr (s);
  835. body->encoding = (unsigned short) i;
  836.       }
  837.     }
  838.     break;
  839.   default: /* otherwise unknown */
  840.     break;
  841.   }
  842. }
  844. /* Parse RFC822 body parameter list
  845.  * Accepts: parameter list to write to
  846.  *     text of list
  847.  */
  849. void rfc822_parse_parameter (PARAMETER **par,char *text)
  850. {
  851.   char c,*s,tmp[MAILTMPLEN];
  852.   PARAMETER *param = NIL;
  853. /* parameter list? */
  854.   while (text && (*text == ';') &&
  855.  (text = rfc822_parse_word ((s = ++text),ptspecials))) {
  856.     c = *text; /* remember delimiter */
  857.     *text = ''; /* tie off attribute name */
  858.     rfc822_skipws (&s); /* skip leading attribute whitespace */
  859.     if (!*s) *text = c; /* must have an attribute name */
  860.     else { /* instantiate a new parameter */
  861.       if (*par) param = param->next = mail_newbody_parameter ();
  862.       else param = *par = mail_newbody_parameter ();
  863.       param->attribute = ucase (cpystr (s));
  864.       *text = c; /* restore delimiter */
  865.       rfc822_skipws (&text); /* skip whitespace before equal sign */
  866.       if ((*text != '=') || /* missing value is a no-no too */
  867.   !(text = rfc822_parse_word ((s = ++text),ptspecials)))
  868. param->value = cpystr ("UNKNOWN_PARAMETER_VALUE");
  869.       else { /* good, have equals sign */
  870. c = *text; /* remember delimiter */
  871. *text = ''; /* tie off value */
  872. rfc822_skipws (&s); /* skip leading value whitespace */
  873. if (*s) param->value = rfc822_cpy (s);
  874. *text = c; /* restore delimiter */
  875. rfc822_skipws (&text);
  876.       }
  877.     }
  878.   }
  879.   if (!text) { /* must be end of poop */
  880.     if (param && param->attribute)
  881.       sprintf (tmp,"Missing parameter value: %.80s",param->attribute);
  882.     else strcpy (tmp,"Missing parameter");
  883.     mm_log (tmp,PARSE);
  884.   }
  885.   else if (*text) { /* must be end of poop */
  886.     sprintf (tmp,"Unexpected characters at end of parameters: %.80s",text);
  887.     mm_log (tmp,PARSE);
  888.   }
  889. }
  891. /* Parse RFC822 address list
  892.  * Accepts: address list to write to
  893.  *     input string
  894.  *     default host name
  895.  */
  897. void rfc822_parse_adrlist (ADDRESS **lst,char *string,char *host)
  898. {
  899.   char c,*s,tmp[MAILTMPLEN];
  900.   ADDRESS *last = *lst;
  901.   ADDRESS *adr;
  902.   if (!string) return; /* no string */
  903.   rfc822_skipws (&string); /* skip leading WS */
  904.   if (!*string) return; /* empty string */
  905. /* run to tail of list */
  906.   if (last) while (last->next) last = last->next;
  907.   while (string) { /* loop until string exhausted */
  908. /* got an address? */
  909.     if (adr = rfc822_parse_address (lst,last,&string,host,0)) {
  910.       last = adr; /* new tail address */
  911.       if (string) { /* analyze what follows */
  912. rfc822_skipws (&string);
  913. switch (c = *string) {
  914. case ',': /* comma? */
  915.   ++string; /* then another address follows */
  916.   break;
  917. default:
  918.   s = isalnum (c) ? "Must use comma to separate addresses: %.80s" :
  919.     "Unexpected characters at end of address: %.80s";
  920.   sprintf (tmp,s,string);
  921.   mm_log (tmp,PARSE);
  922.   last = last->next = mail_newaddr ();
  923.   last->mailbox = cpystr ("UNEXPECTED_DATA_AFTER_ADDRESS");
  924.   last->host = cpystr (errhst);
  925. /* falls through */
  926. case '': /* null-specified address? */
  927.   string = NIL; /* punt remainder of parse */
  928.   break;
  929. }
  930.       }
  931.     }
  932.     else if (string) { /* bad mailbox */
  933.       rfc822_skipws (&string); /* skip WS */
  934.       if (!*string) strcpy (tmp,"Missing address after comma");
  935.       else sprintf (tmp,"Invalid mailbox list: %.80s",string);
  936.       mm_log (tmp,PARSE);
  937.       string = NIL;
  938.       (adr = mail_newaddr ())->mailbox = cpystr ("INVALID_ADDRESS");
  939.       adr->host = cpystr (errhst);
  940.       if (last) last = last->next = adr;
  941.       else *lst = last = adr;
  942.       break;
  943.     }
  944.   }
  945. }
  947. /* Parse RFC822 address
  948.  * Accepts: address list to write to
  949.  *     tail of address list
  950.  *     pointer to input string
  951.  *     default host name
  952.  *     group nesting depth
  953.  * Returns: new list tail
  954.  */
  956. ADDRESS *rfc822_parse_address (ADDRESS **lst,ADDRESS *last,char **string,
  957.        char *defaulthost,unsigned long depth)
  958. {
  959.   ADDRESS *adr;
  960.   if (!*string) return NIL; /* no string */
  961.   rfc822_skipws (string); /* skip leading WS */
  962.   if (!**string) return NIL; /* empty string */
  963.   if (adr = rfc822_parse_group (lst,last,string,defaulthost,depth)) last = adr;
  964. /* got an address? */
  965.   else if (adr = rfc822_parse_mailbox (string,defaulthost)) {
  966.     if (!*lst) *lst = adr; /* yes, first time through? */
  967.     else last->next = adr; /* no, append to the list */
  968. /* set for subsequent linking */
  969.     for (last = adr; last->next; last = last->next);
  970.   }
  971.   else if (*string) return NIL;
  972.   return last;
  973. }
  975. /* Parse RFC822 group
  976.  * Accepts: address list to write to
  977.  *     pointer to tail of address list
  978.  *     pointer to input string
  979.  *     default host name
  980.  *     group nesting depth
  981.  */
  983. ADDRESS *rfc822_parse_group (ADDRESS **lst,ADDRESS *last,char **string,
  984.      char *defaulthost,unsigned long depth)
  985. {
  986.   char tmp[MAILTMPLEN];
  987.   char *p,*s;
  988.   ADDRESS *adr;
  989.   if (depth > MAXGROUPDEPTH) { /* excessively deep recursion? */
  990.     mm_log ("Ignoring excessively deep group recursion",PARSE);
  991.     return NIL; /* probably abusive */
  992.   }
  993.   if (!*string) return NIL; /* no string */
  994.   rfc822_skipws (string); /* skip leading WS */
  995.   if (!**string || /* trailing whitespace or not group */
  996.       ((*(p = *string) != ':') && !(p = rfc822_parse_phrase (*string))))
  997.     return NIL;
  998.   s = p; /* end of candidate phrase */
  999.   rfc822_skipws (&s); /* find delimiter */
  1000.   if (*s != ':') return NIL; /* not really a group */
  1001.   *p = ''; /* tie off group name */
  1002.   p = ++s; /* continue after the delimiter */
  1003.   rfc822_skipws (&p); /* skip subsequent whitespace */
  1004. /* write as address */
  1005.   (adr = mail_newaddr ())->mailbox = rfc822_cpy (*string);
  1006.   if (!*lst) *lst = adr; /* first time through? */
  1007.   else last->next = adr; /* no, append to the list */
  1008.   last = adr; /* set for subsequent linking */
  1009.   *string = p; /* continue after this point */
  1010.   while (*string && **string && (**string != ';')) {
  1011.     if (adr = rfc822_parse_address (lst,last,string,defaulthost,depth+1)) {
  1012.       last = adr; /* new tail address */
  1013.       if (*string) { /* anything more? */
  1014. rfc822_skipws (string); /* skip whitespace */
  1015. switch (**string) { /* see what follows */
  1016. case ',': /* another address? */
  1017.   ++*string; /* yes, skip past the comma */
  1018. case ';': /* end of group? */
  1019. case '': /* end of string */
  1020.   break;
  1021. default:
  1022.   sprintf (tmp,"Unexpected characters after address in group: %.80s",
  1023.    *string);
  1024.   mm_log (tmp,PARSE);
  1025.   *string = NIL; /* cancel remainder of parse */
  1026.   last = last->next = mail_newaddr ();
  1027.   last->mailbox = cpystr ("UNEXPECTED_DATA_AFTER_ADDRESS_IN_GROUP");
  1028.   last->host = cpystr (errhst);
  1029. }
  1030.       }
  1031.     }
  1032.     else { /* bogon */
  1033.       sprintf (tmp,"Invalid group mailbox list: %.80s",*string);
  1034.       mm_log (tmp,PARSE);
  1035.       *string = NIL; /* cancel remainder of parse */
  1036.       (adr = mail_newaddr ())->mailbox = cpystr ("INVALID_ADDRESS_IN_GROUP");
  1037.       adr->host = cpystr (errhst);
  1038.       last = last->next = adr;
  1039.     }
  1040.   }
  1041.   if (*string) { /* skip close delimiter */
  1042.     if (**string == ';') ++*string;
  1043.     rfc822_skipws (string);
  1044.   }
  1045. /* append end of address mark to the list */
  1046.   last->next = (adr = mail_newaddr ());
  1047.   last = adr; /* set for subsequent linking */
  1048.   return last; /* return the tail */
  1049. }
  1051. /* Parse RFC822 mailbox
  1052.  * Accepts: pointer to string pointer
  1053.  *     default host
  1054.  * Returns: address list
  1055.  *
  1056.  * Updates string pointer
  1057.  */
  1059. ADDRESS *rfc822_parse_mailbox (char **string,char *defaulthost)
  1060. {
  1061.   ADDRESS *adr = NIL;
  1062.   char *s,*end;
  1063.   parsephrase_t pp = (parsephrase_t) mail_parameters (NIL,GET_PARSEPHRASE,NIL);
  1064.   if (!*string) return NIL; /* no string */
  1065.   rfc822_skipws (string); /* flush leading whitespace */
  1066.   if (!**string) return NIL; /* empty string */
  1067.   if (*(s = *string) == '<')  /* note start, handle case of phraseless RA */
  1068.     adr = rfc822_parse_routeaddr (s,string,defaulthost);
  1069. /* otherwise, expect at least one word */
  1070.   else if (end = rfc822_parse_phrase (s)) {
  1071.     if ((adr = rfc822_parse_routeaddr (end,string,defaulthost))) {
  1072. /* phrase is a personal name */
  1073.       if (adr->personal) fs_give ((void **) &adr->personal);
  1074.       *end = ''; /* tie off phrase */
  1075.       adr->personal = rfc822_cpy (s);
  1076.     }
  1077. /* call external phraseparser if phrase only */
  1078.     else if (pp && rfc822_phraseonly (end) &&
  1079.      (adr = (*pp) (s,end,defaulthost))) {
  1080.       *string = end; /* update parse pointer */
  1081.       rfc822_skipws (string); /* skip WS in the normal way */
  1082.     }
  1083.     else adr = rfc822_parse_addrspec (s,string,defaulthost);
  1084.   }
  1085.   return adr; /* return the address */
  1086. }
  1089. /* Check if address is a phrase only
  1090.  * Accepts: pointer to end of phrase
  1091.  * Returns: T if phrase only, else NIL;
  1092.  */
  1094. long rfc822_phraseonly (char *end)
  1095. {
  1096.   while (*end == ' ') ++end; /* call rfc822_skipws() instead?? */
  1097.   switch (*end) {
  1098.   case '': case ',': case ';':
  1099.     return LONGT; /* is a phrase only */
  1100.   }
  1101.   return NIL; /* something other than phase is here */
  1102. }
  1104. /* Parse RFC822 route-address
  1105.  * Accepts: string pointer
  1106.  *     pointer to string pointer to update
  1107.  * Returns: address
  1108.  *
  1109.  * Updates string pointer
  1110.  */
  1112. ADDRESS *rfc822_parse_routeaddr (char *string,char **ret,char *defaulthost)
  1113. {
  1114.   char tmp[MAILTMPLEN];
  1115.   ADDRESS *adr;
  1116.   char *adl = NIL;
  1117.   char *routeend = NIL;
  1118.   if (!string) return NIL;
  1119.   rfc822_skipws (&string); /* flush leading whitespace */
  1120. /* must start with open broket */
  1121.   if (*string != '<') return NIL;
  1122.   if (string[1] == '@') { /* have an A-D-L? */
  1123.     adl = ++string; /* yes, remember that fact */
  1124.     while (*string != ':') { /* search for end of A-D-L */
  1125. /* punt if never found */
  1126.       if (!*string) return NIL;
  1127.       ++string; /* try next character */
  1128.     }
  1129.     *string = ''; /* tie off A-D-L */
  1130.     routeend = string; /* remember in case need to put back */
  1131.   }
  1132. /* parse address spec */
  1133.   if (!(adr = rfc822_parse_addrspec (++string,ret,defaulthost))) {
  1134.     if (adl) *routeend = ':'; /* put colon back since parse barfed */
  1135.     return NIL;
  1136.   }
  1137. /* have an A-D-L? */
  1138.   if (adl) adr->adl = cpystr (adl);
  1139.   if (*ret) if (**ret == '>') { /* make sure terminated OK */
  1140.     ++*ret; /* skip past the broket */
  1141.     rfc822_skipws (ret); /* flush trailing WS */
  1142.     if (!**ret) *ret = NIL; /* wipe pointer if at end of string */
  1143.     return adr; /* return the address */
  1144.   }
  1145.   sprintf (tmp,"Unterminated mailbox: %.80s@%.80s",adr->mailbox,
  1146.    *adr->host == '@' ? "<null>" : adr->host);
  1147.   mm_log (tmp,PARSE);
  1148.   adr->next = mail_newaddr ();
  1149.   adr->next->mailbox = cpystr ("MISSING_MAILBOX_TERMINATOR");
  1150.   adr->next->host = cpystr (errhst);
  1151.   return adr; /* return the address */
  1152. }
  1154. /* Parse RFC822 address-spec
  1155.  * Accepts: string pointer
  1156.  *     pointer to string pointer to update
  1157.  *     default host
  1158.  * Returns: address
  1159.  *
  1160.  * Updates string pointer
  1161.  */
  1163. ADDRESS *rfc822_parse_addrspec (char *string,char **ret,char *defaulthost)
  1164. {
  1165.   ADDRESS *adr;
  1166.   char *end;
  1167.   char c,*s,*t;
  1168.   if (!string) return NIL; /* no string */
  1169.   rfc822_skipws (&string); /* flush leading whitespace */
  1170.   if (!*string) return NIL; /* empty string */
  1171. /* find end of mailbox */
  1172.   if (!(end = rfc822_parse_word (string,NIL))) return NIL;
  1173.   adr = mail_newaddr (); /* create address block */
  1174.   c = *end; /* remember delimiter */
  1175.   *end = ''; /* tie off mailbox */
  1176. /* copy mailbox */
  1177.   adr->mailbox = rfc822_cpy (string);
  1178.   *end = c; /* restore delimiter */
  1179.   t = end; /* remember end of mailbox for no host case */
  1180.   rfc822_skipws (&end); /* skip whitespace */
  1181.   if (*end == '@') { /* have host name? */
  1182.     ++end; /* skip delimiter */
  1183.     rfc822_skipws (&end); /* skip whitespace */
  1184.     if (*end == '[') { /* domain literal? */
  1185.       string = end; /* start of domain literal */
  1186.       if (end = rfc822_parse_word (string + 1,"]\")) {
  1187. size_t len = ++end - string;
  1188. strncpy (adr->host = (char *) fs_get (len + 1),string,len);
  1189. adr->host[len] = ''; /* tie off literal */
  1190.       }
  1191.       else {
  1192. mm_log ("Invalid domain literal after @",PARSE);
  1193. adr->host = cpystr (errhst);
  1194.       }
  1195.     }
  1196.      /* search for end of host */
  1197.     else if (end = rfc822_parse_word ((string = end),wspecials)) {
  1198.       c = *end; /* remember delimiter */
  1199.       *end = ''; /* tie off host */
  1200. /* copy host */
  1201.       adr->host = rfc822_cpy (string);
  1202.       *end = c; /* restore delimiter */
  1203.     }
  1204.     else {
  1205.       mm_log ("Missing or invalid host name after @",PARSE);
  1206.       adr->host = cpystr (errhst);
  1207.     }
  1208.   }
  1209.   else end = t; /* make person name default start after mbx */
  1210. /* default host if missing */
  1211.   if (!adr->host) adr->host = cpystr (defaulthost);
  1212.   if (end && !adr->personal) { /* try person name in comments if missing */
  1213.     while (*end == ' ') ++end; /* see if we can find a person name here */
  1214.     if ((*end == '(') && (s = rfc822_skip_comment (&end,LONGT)) && strlen (s))
  1215.       adr->personal = rfc822_cpy (s);
  1216.     rfc822_skipws (&end); /* skip any other WS in the normal way */
  1217.   }
  1218. /* set return to end pointer */
  1219.   *ret = (end && *end) ? end : NIL;
  1220.   return adr; /* return the address we got */
  1221. }
  1223. /* Parse RFC822 phrase
  1224.  * Accepts: string pointer
  1225.  * Returns: pointer to end of phrase
  1226.  */
  1228. char *rfc822_parse_phrase (char *s)
  1229. {
  1230.   char *curpos;
  1231.   if (!s) return NIL; /* no-op if no string */
  1232. /* find first word of phrase */
  1233.   curpos = rfc822_parse_word (s,NIL);
  1234.   if (!curpos) return NIL; /* no words means no phrase */
  1235.   if (!*curpos) return curpos; /* check if string ends with word */
  1236.   s = curpos; /* sniff past the end of this word and WS */
  1237.   rfc822_skipws (&s); /* skip whitespace */
  1238. /* recurse to see if any more */
  1239.   return (s = rfc822_parse_phrase (s)) ? s : curpos;
  1240. }
  1242. /* Parse RFC822 word
  1243.  * Accepts: string pointer
  1244.  * Returns: pointer to end of word
  1245.  */
  1247. char *rfc822_parse_word (char *s,const char *delimiters)
  1248. {
  1249.   char *st,*str;
  1250.   if (!s) return NIL; /* no string */
  1251.   rfc822_skipws (&s); /* flush leading whitespace */
  1252.   if (!*s) return NIL; /* empty string */
  1253. /* default delimiters to standard */
  1254.   if (!delimiters) delimiters = wspecials;
  1255.   str = s; /* hunt pointer for strpbrk */
  1256.   while (T) { /* look for delimiter */
  1257.     if (!(st = strpbrk (str,delimiters))) {
  1258.       while (*s) ++s; /* no delimiter, hunt for end */
  1259.       return s; /* return it */
  1260.     }
  1261.     switch (*st) { /* dispatch based on delimiter */
  1262.     case '"': /* quoted string */
  1263. /* look for close quote */
  1264.       while (*++st != '"') switch (*st) {
  1265.       case '': /* unbalanced quoted string */
  1266. return NIL; /* sick sick sick */
  1267.       case '\': /* quoted character */
  1268. if (!*++st) return NIL; /* skip the next character */
  1269.       default: /* ordinary character */
  1270. break; /* no special action */
  1271.       }
  1272.       str = ++st; /* continue parse */
  1273.       break;
  1274.     case '\': /* quoted character */
  1275.       /* This is wrong; a quoted-pair can not be part of a word.  However,
  1276.        * domain-literal is parsed as a word and quoted-pairs can be used
  1277.        * *there*.  Either way, it's pretty pathological.
  1278.        */
  1279.       if (st[1]) { /* not on NUL though... */
  1280. str = st + 2; /* skip quoted character and go on */
  1281. break;
  1282.       }
  1283.     default: /* found a word delimiter */
  1284.       return (st == s) ? NIL : st;
  1285.     }
  1286.   }
  1287. }
  1289. /* Copy an RFC822 format string
  1290.  * Accepts: string
  1291.  * Returns: copy of string
  1292.  */
  1294. char *rfc822_cpy (char *src)
  1295. {
  1296. /* copy and unquote */
  1297.   return rfc822_quote (cpystr (src));
  1298. }
  1301. /* Unquote an RFC822 format string
  1302.  * Accepts: string
  1303.  * Returns: string
  1304.  */
  1306. char *rfc822_quote (char *src)
  1307. {
  1308.   char *ret = src;
  1309.   if (strpbrk (src,"\"")) { /* any quoting in string? */
  1310.     char *dst = ret;
  1311.     while (*src) { /* copy string */
  1312.       if (*src == '"') src++; /* skip double quote entirely */
  1313.       else {
  1314. if (*src == '\') src++;/* skip over single quote, copy next always */
  1315. *dst++ = *src++; /* copy character */
  1316.       }
  1317.     }
  1318.     *dst = ''; /* tie off string */
  1319.   }
  1320.   return ret; /* return our string */
  1321. }
  1324. /* Copy address list
  1325.  * Accepts: address list
  1326.  * Returns: address list
  1327.  */
  1329. ADDRESS *rfc822_cpy_adr (ADDRESS *adr)
  1330. {
  1331.   ADDRESS *dadr;
  1332.   ADDRESS *ret = NIL;
  1333.   ADDRESS *prev = NIL;
  1334.   while (adr) { /* loop while there's still an MAP adr */
  1335.     dadr = mail_newaddr (); /* instantiate a new address */
  1336.     if (!ret) ret = dadr; /* note return */
  1337.     if (prev) prev->next = dadr;/* tie on to the end of any previous */
  1338.     dadr->personal = cpystr (adr->personal);
  1339.     dadr->adl = cpystr (adr->adl);
  1340.     dadr->mailbox = cpystr (adr->mailbox);
  1341.     dadr->host = cpystr (adr->host);
  1342.     prev = dadr; /* this is now the previous */
  1343.     adr = adr->next; /* go to next address in list */
  1344.   }
  1345.   return (ret); /* return the MTP address list */
  1346. }
  1348. /* Skips RFC822 whitespace
  1349.  * Accepts: pointer to string pointer
  1350.  */
  1352. void rfc822_skipws (char **s)
  1353. {
  1354.   while (T) {
  1355.     if (**s == ' ') ++*s; /* skip space */
  1356.     else if ((**s != '(') || !rfc822_skip_comment (s,(long) NIL)) return;
  1357.   }
  1358. }
  1361. /* Skips RFC822 comment
  1362.  * Accepts: pointer to string pointer
  1363.  *     trim flag
  1364.  * Returns: pointer to first non-blank character of comment
  1365.  */
  1367. char *rfc822_skip_comment (char **s,long trim)
  1368. {
  1369.   char *ret,tmp[MAILTMPLEN];
  1370.   char *s1 = *s;
  1371.   char *t = NIL;
  1372. /* skip past whitespace */
  1373.   for (ret = ++s1; *ret == ' '; ret++);
  1374.   do switch (*s1) { /* get character of comment */
  1375.   case '(': /* nested comment? */
  1376.     if (!rfc822_skip_comment (&s1,(long) NIL)) return NIL;
  1377.     t = --s1; /* last significant char at end of comment */
  1378.     break;
  1379.   case ')': /* end of comment? */
  1380.     *s = ++s1; /* skip past end of comment */
  1381.     if (trim) { /* if level 0, must trim */
  1382.       if (t) t[1] = ''; /* tie off comment string */
  1383.       else *ret = ''; /* empty comment */
  1384.     }
  1385.     return ret;
  1386.   case '\': /* quote next character? */
  1387.     if (*++s1) { /* next character non-null? */
  1388.       t = s1; /* update last significant character pointer */
  1389.       break; /* all OK */
  1390.     }
  1391.   case '': /* end of string */
  1392.     sprintf (tmp,"Unterminated comment: %.80s",*s);
  1393.     mm_log (tmp,PARSE);
  1394.     **s = ''; /* nuke duplicate messages in case reparse */
  1395.     return NIL; /* this is wierd if it happens */
  1396.   case ' ': /* whitespace isn't significant */
  1397.     break;
  1398.   default: /* random character */
  1399.     t = s1; /* update last significant character pointer */
  1400.     break;
  1401.   } while (s1++);
  1402.   return NIL; /* impossible, but pacify lint et al */
  1403. }
  1405. /* Body contents utility and encoding/decoding routines */
  1408. /* Output RFC 822 message
  1409.  * Accepts: temporary buffer
  1410.  *     envelope
  1411.  *     body
  1412.  *     I/O routine
  1413.  *     stream for I/O routine
  1414.  *     non-zero if 8-bit output desired
  1415.  * Returns: T if successful, NIL if failure
  1416.  */
  1418. long rfc822_output (char *t,ENVELOPE *env,BODY *body,soutr_t f,void *s,
  1419.     long ok8bit)
  1420. {
  1421.   rfc822out_t r822o = (rfc822out_t) mail_parameters (NIL,GET_RFC822OUTPUT,NIL);
  1422. /* call external RFC822 output generator */
  1423.   if (r822o) return (*r822o) (t,env,body,f,s,ok8bit);
  1424. /* encode body as necessary */
  1425.   if (ok8bit) rfc822_encode_body_8bit (env,body);
  1426.   else rfc822_encode_body_7bit (env,body);
  1427.   rfc822_header (t,env,body); /* build RFC822 header */
  1428. /* output header and body */
  1429.   return (*f) (s,t) && (body ? rfc822_output_body (body,f,s) : T);
  1430. }
  1432. /* Encode a body for 7BIT transmittal
  1433.  * Accepts: envelope
  1434.  *     body
  1435.  */
  1437. void rfc822_encode_body_7bit (ENVELOPE *env,BODY *body)
  1438. {
  1439.   void *f;
  1440.   PART *part;
  1441.   PARAMETER **param;
  1442.   if (body) switch (body->type) {
  1443.   case TYPEMULTIPART: /* multi-part */
  1444.     for (param = &body->parameter;
  1445.  *param && strcmp ((*param)->attribute,"BOUNDARY");
  1446.  param = &(*param)->next);
  1447.     if (!*param) { /* cookie not set up yet? */
  1448.       char tmp[MAILTMPLEN]; /* make cookie not in BASE64 or QUOTEPRINT*/
  1449.       sprintf (tmp,"%ld-%ld-%ld=:%ld",(long) gethostid (),random (),time (0),
  1450.        (long) getpid ());
  1451.       (*param) = mail_newbody_parameter ();
  1452.       (*param)->attribute = cpystr ("BOUNDARY");
  1453.       (*param)->value = cpystr (tmp);
  1454.     }
  1455.     part = body->nested.part; /* encode body parts */
  1456.     do rfc822_encode_body_7bit (env,&part->body);
  1457.     while (part = part->next); /* until done */
  1458.     break;
  1459.   case TYPEMESSAGE: /* encapsulated message */
  1460.     switch (body->encoding) {
  1461.     case ENC7BIT:
  1462.       break;
  1463.     case ENC8BIT:
  1464.       mm_log ("8-bit included message in 7-bit message body",WARN);
  1465.       break;
  1466.     case ENCBINARY:
  1467.       mm_log ("Binary included message in 7-bit message body",WARN);
  1468.       break;
  1469.     default:
  1470.       fatal ("Invalid rfc822_encode_body_7bit message encoding");
  1471.     }
  1472.     break; /* can't change encoding */
  1473.   default: /* all else has some encoding */
  1474.     switch (body->encoding) {
  1475.     case ENC8BIT: /* encode 8BIT into QUOTED-PRINTABLE */
  1476. /* remember old 8-bit contents */
  1477.       f = (void *) body->contents.text.data;
  1478.       body->contents.text.data =
  1479. rfc822_8bit (body->contents.text.data,
  1480.      body->contents.text.size,&body->contents.text.size);
  1481.       body->encoding = ENCQUOTEDPRINTABLE;
  1482.       fs_give (&f); /* flush old binary contents */
  1483.       break;
  1484.     case ENCBINARY: /* encode binary into BASE64 */
  1485. /* remember old binary contents */
  1486.       f = (void *) body->contents.text.data;
  1487.       body->contents.text.data =
  1488. rfc822_binary ((void *) body->contents.text.data,
  1489.        body->contents.text.size,&body->contents.text.size);
  1490.       body->encoding = ENCBASE64;
  1491.       fs_give (&f); /* flush old binary contents */
  1492.     default: /* otherwise OK */
  1493.       break;
  1494.     }
  1495.     break;
  1496.   }
  1497. }
  1499. /* Encode a body for 8BIT transmittal
  1500.  * Accepts: envelope
  1501.  *     body
  1502.  */
  1504. void rfc822_encode_body_8bit (ENVELOPE *env,BODY *body)
  1505. {
  1506.   void *f;
  1507.   PART *part;
  1508.   PARAMETER **param;
  1509.   if (body) switch (body->type) {
  1510.   case TYPEMULTIPART: /* multi-part */
  1511.     for (param = &body->parameter;
  1512.  *param && strcmp ((*param)->attribute,"BOUNDARY");
  1513.  param = &(*param)->next);
  1514.     if (!*param) { /* cookie not set up yet? */
  1515.       char tmp[MAILTMPLEN]; /* make cookie not in BASE64 or QUOTEPRINT*/
  1516.       sprintf (tmp,"%ld-%ld-%ld=:%ld",(long) gethostid (),random (),time (0),
  1517.        (long) getpid ());
  1518.       (*param) = mail_newbody_parameter ();
  1519.       (*param)->attribute = cpystr ("BOUNDARY");
  1520.       (*param)->value = cpystr (tmp);
  1521.     }
  1522.     part = body->nested.part; /* encode body parts */
  1523.     do rfc822_encode_body_8bit (env,&part->body);
  1524.     while (part = part->next); /* until done */
  1525.     break;
  1526.   case TYPEMESSAGE: /* encapsulated message */
  1527.     switch (body->encoding) {
  1528.     case ENC7BIT:
  1529.     case ENC8BIT:
  1530.       break;
  1531.     case ENCBINARY:
  1532.       mm_log ("Binary included message in 8-bit message body",WARN);
  1533.       break;
  1534.     default:
  1535.       fatal ("Invalid rfc822_encode_body_7bit message encoding");
  1536.     }
  1537.     break; /* can't change encoding */
  1538.   default: /* other type, encode binary into BASE64 */
  1539.     if (body->encoding == ENCBINARY) {
  1540. /* remember old binary contents */
  1541.       f = (void *) body->contents.text.data;
  1542.       body->contents.text.data =
  1543. rfc822_binary ((void *) body->contents.text.data,
  1544.        body->contents.text.size,&body->contents.text.size);
  1545.       body->encoding = ENCBASE64;
  1546.       fs_give (&f); /* flush old binary contents */
  1547.     }
  1548.     break;
  1549.   }
  1550. }
  1552. /* Output RFC 822 body
  1553.  * Accepts: body
  1554.  *     I/O routine
  1555.  *     stream for I/O routine
  1556.  * Returns: T if successful, NIL if failure
  1557.  */
  1559. long rfc822_output_body (BODY *body,soutr_t f,void *s)
  1560. {
  1561.   PART *part;
  1562.   PARAMETER *param;
  1563.   char *cookie = NIL;
  1564.   char tmp[MAILTMPLEN];
  1565.   char *t;
  1566.   switch (body->type) {
  1567.   case TYPEMULTIPART: /* multipart gets special handling */
  1568.     part = body->nested.part; /* first body part */
  1569. /* find cookie */
  1570.     for (param = body->parameter; param && !cookie; param = param->next)
  1571.       if (!strcmp (param->attribute,"BOUNDARY")) cookie = param->value;
  1572.     if (!cookie) cookie = "-"; /* yucky default */
  1573.     do { /* for each part */
  1574. /* build cookie */
  1575.       sprintf (t = tmp,"--%s1512",cookie);
  1576. /* append mini-header */
  1577.       rfc822_write_body_header (&t,&part->body);
  1578.       strcat (t,"1512"); /* write terminating blank line */
  1579. /* output cookie, mini-header, and contents */
  1580.       if (!((*f) (s,tmp) && rfc822_output_body (&part->body,f,s))) return NIL;
  1581.     } while (part = part->next);/* until done */
  1582. /* output trailing cookie */
  1583.     sprintf (t = tmp,"--%s--",cookie);
  1584.     break;
  1585.   default: /* all else is text now */
  1586.     t = (char *) body->contents.text.data;
  1587.     break;
  1588.   }
  1589. /* output final stuff */
  1590.   if (t && *t && !((*f) (s,t) && (*f) (s,"1512"))) return NIL;
  1591.   return LONGT;
  1592. }
  1594. /* Convert BASE64 contents to binary
  1595.  * Accepts: source
  1596.  *     length of source
  1597.  *     pointer to return destination length
  1598.  * Returns: destination as binary or NIL if error
  1599.  */
  1601. void *rfc822_base64 (unsigned char *src,unsigned long srcl,unsigned long *len)
  1602. {
  1603.   char c;
  1604.   void *ret = fs_get ((size_t) (*len = 4 + ((srcl * 3) / 4)));
  1605.   char *d = (char *) ret;
  1606.   int e = 0;
  1607.   memset (ret,0,(size_t) *len); /* initialize block */
  1608.   *len = 0; /* in case we return an error */
  1609.   while (srcl--) { /* until run out of characters */
  1610.     c = *src++; /* simple-minded decode */
  1611.     if (isupper (c)) c -= 'A';
  1612.     else if (islower (c)) c -= 'a' - 26;
  1613.     else if (isdigit (c)) c -= '0' - 52;
  1614.     else if (c == '+') c = 62;
  1615.     else if (c == '/') c = 63;
  1616.     else if (c == '=') { /* padding */
  1617.       switch (e++) { /* check quantum position */
  1618.       case 3:
  1619. e = 0; /* restart quantum */
  1620. break;
  1621.       case 2:
  1622. if (*src == '=') break;
  1623.       default: /* impossible quantum position */
  1624. fs_give (&ret);
  1625. return NIL;
  1626.       }
  1627.       continue;
  1628.     }
  1629.     else continue; /* junk character */
  1630.     switch (e++) { /* install based on quantum position */
  1631.     case 0:
  1632.       *d = c << 2; /* byte 1: high 6 bits */
  1633.       break;
  1634.     case 1:
  1635.       *d++ |= c >> 4; /* byte 1: low 2 bits */
  1636.       *d = c << 4; /* byte 2: high 4 bits */
  1637.       break;
  1638.     case 2:
  1639.       *d++ |= c >> 2; /* byte 2: low 4 bits */
  1640.       *d = c << 6; /* byte 3: high 2 bits */
  1641.       break;
  1642.     case 3:
  1643.       *d++ |= c; /* byte 3: low 6 bits */
  1644.       e = 0; /* reinitialize mechanism */
  1645.       break;
  1646.     }
  1647.   }
  1648.   *len = d - (char *) ret; /* calculate data length */
  1649.   return ret; /* return the string */
  1650. }
  1652. /* Convert binary contents to BASE64
  1653.  * Accepts: source
  1654.  *     length of source
  1655.  *     pointer to return destination length
  1656.  * Returns: destination as BASE64
  1657.  */
  1659. unsigned char *rfc822_binary (void *src,unsigned long srcl,unsigned long *len)
  1660. {
  1661.   unsigned char *ret,*d;
  1662.   unsigned char *s = (unsigned char *) src;
  1663.   char *v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  1664.   unsigned long i = ((srcl + 2) / 3) * 4;
  1665.   *len = i += 2 * ((i / 60) + 1);
  1666.   d = ret = (unsigned char *) fs_get ((size_t) ++i);
  1667.   for (i = 0; srcl; s += 3) { /* process tuplets */
  1668.     *d++ = v[s[0] >> 2]; /* byte 1: high 6 bits (1) */
  1669. /* byte 2: low 2 bits (1), high 4 bits (2) */
  1670.     *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f];
  1671. /* byte 3: low 4 bits (2), high 2 bits (3) */
  1672.     *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) : 0)) & 0x3f] : '=';
  1673. /* byte 4: low 6 bits (3) */
  1674.     *d++ = srcl ? v[s[2] & 0x3f] : '=';
  1675.     if (srcl) srcl--; /* count third character if processed */
  1676.     if ((++i) == 15) { /* output 60 characters? */
  1677.       i = 0; /* restart line break count, insert CRLF */
  1678.       *d++ = '15'; *d++ = '12';
  1679.     }
  1680.   }
  1681.   *d++ = '15'; *d++ = '12'; /* insert final CRLF */
  1682.   *d = ''; /* tie off string */
  1683.   if (((unsigned long) (d - ret)) != *len) fatal ("rfc822_binary logic flaw");
  1684.   return ret; /* return the resulting string */
  1685. }
  1687. /* Convert QUOTED-PRINTABLE contents to 8BIT
  1688.  * Accepts: source
  1689.  *     length of source
  1690.  *      pointer to return destination length
  1691.  * Returns: destination as 8-bit text or NIL if error
  1692.  */
  1694. unsigned char *rfc822_qprint (unsigned char *src,unsigned long srcl,
  1695.       unsigned long *len)
  1696. {
  1697.   unsigned char *ret = (unsigned char *) fs_get ((size_t) srcl + 1);
  1698.   unsigned char *d = ret;
  1699.   unsigned char *t = d;
  1700.   unsigned char *s = src;
  1701.   unsigned char c,e;
  1702.   *len = 0; /* in case we return an error */
  1703. /* until run out of characters */
  1704.   while (((unsigned long) (s - src)) < srcl) {
  1705.     switch (c = *s++) { /* what type of character is it? */
  1706.     case '=': /* quoting character */
  1707.       if (((unsigned long) (s - src)) < srcl) switch (c = *s++) {
  1708.       case '': /* end of data */
  1709. s--; /* back up pointer */
  1710. break;
  1711.       case '15': /* non-significant line break */
  1712. t = d; /* accept any leading spaces */
  1713. if ((((unsigned long) (s - src)) < srcl) && (*s == '12')) s++;
  1714. break;
  1715.       default: /* two hex digits then */
  1716. if (!(isxdigit (c) && (((unsigned long) (s - src)) < srcl) &&
  1717.       (e = *s++) && isxdigit (e))) {
  1718.   fs_give ((void **) &ret);
  1719.   return NIL;
  1720. }
  1721. if (isdigit (c)) c -= '0';
  1722. else c -= (isupper (c) ? 'A' - 10 : 'a' - 10);
  1723. if (isdigit (e)) e -= '0';
  1724. else e -= (isupper (e) ? 'A' - 10 : 'a' - 10);
  1725. *d++ = e + (c << 4); /* merge the two hex digits */
  1726. t = d; /* note point of non-space */
  1727. break;
  1728.       }
  1729.       break;
  1730.     case ' ': /* space, possibly bogus */
  1731.       *d++ = c; /* stash the space but don't update s */
  1732.       break;
  1733.     case '15': /* end of line */
  1734.       d = t; /* slide back to last non-space, drop in */
  1735.     default:
  1736.       *d++ = c; /* stash the character */
  1737.       t = d; /* note point of non-space */
  1738.     }      
  1739.   }
  1740.   *d = ''; /* tie off results */
  1741.   *len = d - ret; /* calculate length */
  1742.   return ret; /* return the string */
  1743. }
  1745. /* Convert 8BIT contents to QUOTED-PRINTABLE
  1746.  * Accepts: source
  1747.  *     length of source
  1748.  *      pointer to return destination length
  1749.  * Returns: destination as quoted-printable text
  1750.  */
  1752. #define MAXL (size_t) 75 /* 76th position only used by continuation = */
  1754. unsigned char *rfc822_8bit (unsigned char *src,unsigned long srcl,
  1755.     unsigned long *len)
  1756. {
  1757.   unsigned long lp = 0;
  1758.   unsigned char *ret = (unsigned char *)
  1759.     fs_get ((size_t) (3*srcl + (6*srcl)/MAXL + 3));
  1760.   unsigned char *d = ret;
  1761.   char *hex = "0123456789ABCDEF";
  1762.   unsigned char c;
  1763.   while (srcl--) { /* for each character */
  1764. /* true line break? */
  1765.     if (((c = *src++) == '15') && (*src == '12') && srcl) {
  1766.       *d++ = '15'; *d++ = *src++; srcl--;
  1767.       lp = 0; /* reset line count */
  1768.     }
  1769.     else { /* not a line break */
  1770. /* quoting required? */
  1771.       if (iscntrl (c) || (c == 0x7f) || (c & 0x80) || (c == '=') ||
  1772.   ((c == ' ') && (*src == '15'))) {
  1773. if ((lp += 3) > MAXL) { /* yes, would line overflow? */
  1774.   *d++ = '='; *d++ = '15'; *d++ = '12';
  1775.   lp = 3; /* set line count */
  1776. }
  1777. *d++ = '='; /* quote character */
  1778. *d++ = hex[c >> 4]; /* high order 4 bits */
  1779. *d++ = hex[c & 0xf]; /* low order 4 bits */
  1780.       }
  1781.       else { /* ordinary character */
  1782. if ((++lp) > MAXL) { /* would line overflow? */
  1783.   *d++ = '='; *d++ = '15'; *d++ = '12';
  1784.   lp = 1; /* set line count */
  1785. }
  1786. *d++ = c; /* ordinary character */
  1787.       }
  1788.     }
  1789.   }
  1790.   *d = ''; /* tie off destination */
  1791.   *len = d - ret; /* calculate true size */
  1792. /* try to give some space back */
  1793.   fs_resize ((void **) &ret,(size_t) *len + 1);
  1794.   return ret;
  1795. }