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

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

网络编程

开发平台：

Unix_Linux

mail.c：源码内容
  1. }
  4. /* Mail message n is expunged
  5.  * Accepts: mail stream
  6.  *     message #
  7.  */
  9. void mail_expunged (MAILSTREAM *stream,unsigned long msgno)
  10. {
  11.   MESSAGECACHE *elt = (MESSAGECACHE *) (*mailcache) (stream,msgno,CH_ELT);
  12. /* notify main program of change */
  13.   if (!stream->silent) mm_expunged (stream,msgno);
  14.   if (elt) { /* if an element is there */
  15.     elt->msgno = 0; /* invalidate its message number and free */
  16.     (*mailcache) (stream,msgno,CH_FREE);
  17.     (*mailcache) (stream,msgno,CH_FREESORTCACHE);
  18.   }
  19. /* expunge the slot */
  20.   (*mailcache) (stream,msgno,CH_EXPUNGE);
  21.   --stream->nmsgs; /* update stream status */
  22.   if (stream->msgno) { /* have stream pointers? */
  23. /* make sure the short cache is nuked */
  24.     if (stream->scache) mail_gc (stream,GC_ENV | GC_TEXTS);
  25.     else stream->msgno = 0; /* make sure invalidated in any case */
  26.   }
  27. }
  29. /* Mail stream status routines */
  32. /* Mail lock stream
  33.  * Accepts: mail stream
  34.  */
  36. void mail_lock (MAILSTREAM *stream)
  37. {
  38.   if (stream->lock) fatal ("Lock when already locked");
  39.   else stream->lock = T; /* lock stream */
  40. }
  43. /* Mail unlock stream
  44.  * Accepts: mail stream
  45.  */
  46.  
  47. void mail_unlock (MAILSTREAM *stream)
  48. {
  49.   if (!stream->lock) fatal ("Unlock when not locked");
  50.   else stream->lock = NIL; /* unlock stream */
  51. }
  54. /* Mail turn on debugging telemetry
  55.  * Accepts: mail stream
  56.  */
  58. void mail_debug (MAILSTREAM *stream)
  59. {
  60.   stream->debug = T; /* turn on debugging telemetry */
  61. }
  64. /* Mail turn off debugging telemetry
  65.  * Accepts: mail stream
  66.  */
  68. void mail_nodebug (MAILSTREAM *stream)
  69. {
  70.   stream->debug = NIL; /* turn off debugging telemetry */
  71. }
  73. /* Mail parse UID sequence
  74.  * Accepts: mail stream
  75.  *     sequence to parse
  76.  * Returns: T if parse successful, else NIL
  77.  */
  79. long mail_uid_sequence (MAILSTREAM *stream,char *sequence)
  80. {
  81.   unsigned long i,j,k,x,y;
  82.   for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL;
  83.   while (sequence && *sequence){/* while there is something to parse */
  84.     if (*sequence == '*') { /* maximum message */
  85.       i = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last;
  86.       sequence++; /* skip past * */
  87.     }
  88. /* parse and validate message number */
  89.     else if (!(i = strtoul ((const char *) sequence,&sequence,10))) {
  90.       mm_log ("UID sequence invalid",ERROR);
  91.       return NIL;
  92.     }
  93.     switch (*sequence) { /* see what the delimiter is */
  94.     case ':': /* sequence range */
  95.       if (*++sequence == '*') { /* maximum message */
  96. j = stream->nmsgs ? mail_uid (stream,stream->nmsgs) : stream->uid_last;
  97. sequence++; /* skip past * */
  98.       }
  99. /* parse end of range */
  100.       else if (!(j = strtoul ((const char *) sequence,&sequence,10))) {
  101. mm_log ("UID sequence range invalid",ERROR);
  102. return NIL;
  103.       }
  104.       if (*sequence && *sequence++ != ',') {
  105. mm_log ("UID sequence range syntax error",ERROR);
  106. return NIL;
  107.       }
  108.       if (i > j) { /* swap the range if backwards */
  109. x = i; i = j; j = x;
  110.       }
  111.       x = mail_msgno (stream,i);/* get msgnos */
  112.       y = mail_msgno (stream,j);/* for both UIDS (don't && it) */
  113. /* easy if both UIDs valid */
  114.       if (x && y) while (x <= y) mail_elt (stream,x++)->sequence = T;
  115. /* start UID valid, end is not */
  116.       else if (x) while ((x <= stream->nmsgs) && (mail_uid (stream,x) <= j))
  117. mail_elt (stream,x++)->sequence = T;
  118. /* end UID valid, start is not */
  119.       else if (y) for (x = 1; x <= y; x++) {
  120. if (mail_uid (stream,x) >= i) mail_elt (stream,x)->sequence = T;
  121.       }
  122. /* neither is valid, ugh */
  123.       else for (x = 1; x <= stream->nmsgs; x++)
  124. if (((k = mail_uid (stream,x)) >= i) && (k <= j))
  125.   mail_elt (stream,x)->sequence = T;
  126.       break;
  127.     case ',': /* single message */
  128.       ++sequence; /* skip the delimiter, fall into end case */
  129.     case '': /* end of sequence, mark this message */
  130.       if (x = mail_msgno (stream,i)) mail_elt (stream,x)->sequence = T;
  131.       break;
  132.     default: /* anything else is a syntax error! */
  133.       mm_log ("UID sequence syntax error",ERROR);
  134.       return NIL;
  135.     }
  136.   }
  137.   return T; /* successfully parsed sequence */
  138. }
  140. /* Mail see if line list matches that in cache
  141.  * Accepts: candidate line list
  142.  *     cached line list
  143.  *     matching flags
  144.  * Returns: T if match, NIL if no match
  145.  */
  147. long mail_match_lines (STRINGLIST *lines,STRINGLIST *msglines,long flags)
  148. {
  149.   unsigned long i;
  150.   unsigned char *s,*t;
  151.   STRINGLIST *m;
  152.   if (!msglines) return T; /* full header is in cache */
  153. /* need full header but filtered in cache */
  154.   if ((flags & FT_NOT) || !lines) return NIL;
  155.   do { /* make sure all present & accounted for */
  156.     for (m = msglines; m; m = m->next) if (lines->text.size == m->text.size) {
  157.       for (s = lines->text.data,t = m->text.data,i = lines->text.size;
  158.    i && ((islower (*s) ? (*s-('a'-'A')) : *s) ==
  159.  (islower (*t) ? (*t-('a'-'A')) : *t)); s++,t++,i--);
  160.       if (!i) break; /* this line matches */
  161.     }
  162.     if (!m) return NIL; /* didn't find in the list */
  163.   }
  164.   while (lines = lines->next);
  165.   return T; /* all lines found */
  166. }
  168. /* Mail filter text by header lines
  169.  * Accepts: text to filter
  170.  *     length of text
  171.  *     list of lines
  172.  *     fetch flags
  173.  * Returns: new text size
  174.  */
  176. unsigned long mail_filter (char *text,unsigned long len,STRINGLIST *lines,
  177.    long flags)
  178. {
  179.   STRINGLIST *hdrs;
  180.   int notfound;
  181.   unsigned long i;
  182.   char c,*s,*e,*t,tmp[MAILTMPLEN],tst[MAILTMPLEN];
  183.   char *src = text;
  184.   char *dst = src;
  185.   char *end = text + len;
  186.   while (src < end) { /* process header */
  187. /* slurp header line name */
  188.     for (s = src,e = s + MAILTMPLEN - 1,e = (e < end ? e : end),t = tmp;
  189.  (s < e) && ((c = *s) != ':') &&
  190.  ((c > ' ') ||
  191.   ((c != ' ') && (c != 't') && (c != '15') && (c != '12')));
  192.  *t++ = *s++);
  193.     *t = ''; /* tie off */
  194.     notfound = T; /* not found yet */
  195.     if (i = t - ucase (tmp)) /* see if found in header */
  196.       for (hdrs = lines,tst[i] = ''; hdrs && notfound; hdrs = hdrs->next)
  197. if ((hdrs->text.size == i) &&
  198.     !strncmp (tmp,ucase (strncpy (tst,(char *) hdrs->text.data,
  199.   (size_t) i)),(size_t) i))
  200.   notfound = NIL;
  201. /* skip header line if not wanted */
  202.     if (i && ((flags & FT_NOT) ? !notfound : notfound))
  203.       while (((*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  204.       (*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  205.       (*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  206.       (*src++ != '12')) || ((*src == ' ') || (*src == 't')));
  207.     else if (src == dst) { /* copy to self */
  208.       while (((*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  209.       (*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  210.       (*src++ != '12') && (*src++ != '12') && (*src++ != '12') &&
  211.       (*src++ != '12')) || ((*src == ' ') || (*src == 't')));
  212.       dst = src; /* update destination */
  213.     }
  214.     else /* copy line and any continuation line */
  215.       while ((((*dst++ = *src++) != '12') && ((*dst++ = *src++) != '12') &&
  216.       ((*dst++ = *src++) != '12') && ((*dst++ = *src++) != '12') &&
  217.       ((*dst++ = *src++) != '12') && ((*dst++ = *src++) != '12') &&
  218.       ((*dst++ = *src++) != '12') && ((*dst++ = *src++) != '12') &&
  219.       ((*dst++ = *src++) != '12') && ((*dst++ = *src++) != '12'))||
  220.      ((*src == ' ') || (*src == 't')));
  221.   }
  222.   *dst = ''; /* tie off destination */
  223.   return dst - text;
  224. }
  226. /* Local mail search message
  227.  * Accepts: MAIL stream
  228.  *     message number
  229.  *     optional section specification
  230.  *     search program
  231.  * Returns: T if found, NIL otherwise
  232.  */
  234. long mail_search_msg (MAILSTREAM *stream,unsigned long msgno,char *section,
  235.       SEARCHPGM *pgm)
  236. {
  237.   unsigned short d;
  238.   char tmp[MAILTMPLEN];
  239.   MESSAGECACHE *elt = mail_elt (stream,msgno);
  240.   SEARCHHEADER *hdr;
  241.   SEARCHOR *or;
  242.   SEARCHPGMLIST *not;
  243.   if (pgm->msgno || pgm->uid) { /* message set searches */
  244.     SEARCHSET *set;
  245. /* message sequences */
  246.     if (set = pgm->msgno) { /* must be inside this sequence */
  247.       while (set) { /* run down until find matching range */
  248. if (set->last ? ((msgno < set->first) || (msgno > set->last)) :
  249.     msgno != set->first) set = set->next;
  250. else break;
  251.       }
  252.       if (!set) return NIL; /* not found within sequence */
  253.     }
  254.     if (set = pgm->uid) { /* must be inside this sequence */
  255.       unsigned long uid = mail_uid (stream,msgno);
  256.       while (set) { /* run down until find matching range */
  257. if (set->last ? ((uid < set->first) || (uid > set->last)) :
  258.     uid != set->first) set = set->next;
  259. else break;
  260.       }
  261.       if (!set) return NIL; /* not found within sequence */
  262.     }
  263.   }
  265.   /* Fast data searches */
  266. /* need to fetch fast data? */
  267.   if ((!elt->rfc822_size && (pgm->larger || pgm->smaller)) ||
  268.       (!elt->year && (pgm->before || pgm->on || pgm->since)) ||
  269.       (!elt->valid && (pgm->answered || pgm->unanswered ||
  270.        pgm->deleted || pgm->undeleted ||
  271.        pgm->draft || pgm->undraft ||
  272.        pgm->flagged || pgm->unflagged ||
  273.        pgm->recent || pgm->old ||
  274.        pgm->seen || pgm->unseen ||
  275.        pgm->keyword || pgm->unkeyword))) {
  276.     sprintf (tmp,"%lu",elt->msgno);
  277.     mail_fetch_fast (stream,tmp,NIL);
  278.   }
  279. /* size ranges */
  280.   if ((pgm->larger && (elt->rfc822_size <= pgm->larger)) ||
  281.       (pgm->smaller && (elt->rfc822_size >= pgm->smaller))) return NIL;
  282. /* message flags */
  283.   if ((pgm->answered && !elt->answered) ||
  284.       (pgm->unanswered && elt->answered) ||
  285.       (pgm->deleted && !elt->deleted) ||
  286.       (pgm->undeleted && elt->deleted) ||
  287.       (pgm->draft && !elt->draft) ||
  288.       (pgm->undraft && elt->draft) ||
  289.       (pgm->flagged && !elt->flagged) ||
  290.       (pgm->unflagged && elt->flagged) ||
  291.       (pgm->recent && !elt->recent) ||
  292.       (pgm->old && elt->recent) ||
  293.       (pgm->seen && !elt->seen) ||
  294.       (pgm->unseen && elt->seen)) return NIL;
  295. /* keywords */
  296.   if ((pgm->keyword && !mail_search_keyword (stream,elt,pgm->keyword)) ||
  297.       (pgm->unkeyword && mail_search_keyword (stream,elt,pgm->unkeyword)))
  298.     return NIL;
  299. /* internal date ranges */
  300.   if (pgm->before || pgm->on || pgm->since) {
  301.     d = (elt->year << 9) + (elt->month << 5) + elt->day;
  302.     if (pgm->before && (d >= pgm->before)) return NIL;
  303.     if (pgm->on && (d != pgm->on)) return NIL;
  304.     if (pgm->since && (d < pgm->since)) return NIL;
  305.   }
  307. /* envelope searches */
  308.   if (pgm->sentbefore || pgm->senton || pgm->sentsince ||
  309.       pgm->bcc || pgm->cc || pgm->from || pgm->to || pgm->subject ||
  310.       pgm->return_path || pgm->sender || pgm->reply_to || pgm->in_reply_to ||
  311.       pgm->message_id || pgm->newsgroups || pgm->followup_to ||
  312.       pgm->references) {
  313.     ENVELOPE *env;
  314.     MESSAGECACHE delt;
  315.     if (section) { /* use body part envelope */
  316.       BODY *body = mail_body (stream,msgno,section);
  317.       env = (body && (body->type == TYPEMESSAGE) && body->subtype &&
  318.      !strcmp (body->subtype,"RFC822")) ? body->nested.msg->env : NIL;
  319.     }
  320. /* use top level envelope if no section */
  321.     else env = mail_fetchenvelope (stream,msgno);
  322.     if (!env) return NIL; /* no envelope obtained */
  323. /* sent date ranges */
  324.     if ((pgm->sentbefore || pgm->senton || pgm->sentsince) &&
  325. (!mail_parse_date (&delt,env->date) ||
  326.  !(d = (delt.year << 9) + (delt.month << 5) + delt.day) ||
  327.  (pgm->sentbefore && (d >= pgm->sentbefore)) ||
  328.  (pgm->senton && (d != pgm->senton)) ||
  329.  (pgm->sentsince && (d < pgm->sentsince)))) return NIL;
  330. /* search headers */
  331.     if ((pgm->bcc && !mail_search_addr (env->bcc,pgm->bcc)) ||
  332. (pgm->cc && !mail_search_addr (env->cc,pgm->cc)) ||
  333. (pgm->from && !mail_search_addr (env->from,pgm->from)) ||
  334. (pgm->to && !mail_search_addr (env->to,pgm->to)) ||
  335. (pgm->subject && !mail_search_header_text (env->subject,pgm->subject)))
  336.       return NIL;
  337.     /* These criteria are not supported by IMAP and have to be emulated */
  338.     if ((pgm->return_path &&
  339.  !mail_search_addr (env->return_path,pgm->return_path)) ||
  340. (pgm->sender && !mail_search_addr (env->sender,pgm->sender)) ||
  341. (pgm->reply_to && !mail_search_addr (env->reply_to,pgm->reply_to)) ||
  342. (pgm->in_reply_to &&
  343.  !mail_search_header_text (env->in_reply_to,pgm->in_reply_to)) ||
  344. (pgm->message_id &&
  345. !mail_search_header_text (env->message_id,pgm->message_id)) ||
  346. (pgm->newsgroups &&
  347.  !mail_search_header_text (env->newsgroups,pgm->newsgroups)) ||
  348. (pgm->followup_to &&
  349.  !mail_search_header_text (env->followup_to,pgm->followup_to)) ||
  350. (pgm->references &&
  351.  !mail_search_header_text (env->references,pgm->references)))
  352.       return NIL;
  353.   }
  355. /* search header lines */
  356.   for (hdr = pgm->header; hdr; hdr = hdr->next) {
  357.     char *t,*e,*v;
  358.     SIZEDTEXT s;
  359.     STRINGLIST sth,stc;
  360.     sth.next = stc.next = NIL; /* only one at a time */
  361.     sth.text.data = hdr->line.data;
  362.     sth.text.size = hdr->line.size;
  363. /* get the header text */
  364.     if ((t = mail_fetch_header (stream,msgno,NIL,&sth,&s.size,
  365. FT_INTERNAL | FT_PEEK)) && strchr (t,':')) {
  366.       if (hdr->text.size) { /* anything matches empty search string */
  367. /* non-empty, copy field data */
  368. s.data = (unsigned char *) fs_get (s.size + 1);
  369. /* for each line */
  370. for (v = (char *) s.data, e = t + s.size; t < e;) switch (*t) {
  371. default: /* non-continuation, skip leading field name */
  372.   while ((t < e) && (*t++ != ':'));
  373.   if ((t < e) && (*t == ':')) t++;
  374. case 't': case ' ': /* copy field data  */
  375.   while ((t < e) && (*t != '15') && (*t != '12')) *v++ = *t++;
  376.   *v++ = 'n'; /* tie off line */
  377.   while (((*t == '15') || (*t == '12')) && (t < e)) t++;
  378. }
  379. /* calculate true size */
  380. s.size = v - (char *) s.data;
  381. *v = ''; /* tie off results */
  382. stc.text.data = hdr->text.data;
  383. stc.text.size = hdr->text.size;
  384. /* search header */
  385. if (mail_search_header (&s,&stc)) fs_give ((void **) &s.data);
  386. else { /* search failed */
  387.   fs_give ((void **) &s.data);
  388.   return NIL;
  389. }
  390.       }
  391.     }
  392.     else return NIL; /* no matching header text */
  393.   }
  394. /* search strings */
  395.   if ((pgm->text && !mail_search_text (stream,msgno,section,pgm->text,LONGT))||
  396.       (pgm->body && !mail_search_text (stream,msgno,section,pgm->body,NIL)))
  397.     return NIL;
  398. /* logical conditions */
  399.   for (or = pgm->or; or; or = or->next)
  400.     if (!(mail_search_msg (stream,msgno,section,or->first) ||
  401.   mail_search_msg (stream,msgno,section,or->second))) return NIL;
  402.   for (not = pgm->not; not; not = not->next)
  403.     if (mail_search_msg (stream,msgno,section,not->pgm)) return NIL;
  404.   return T;
  405. }
  407. /* Mail search message header null-terminated text
  408.  * Accepts: header text
  409.  *     strings to search
  410.  * Returns: T if search found a match
  411.  */
  413. long mail_search_header_text (char *s,STRINGLIST *st)
  414. {
  415.   SIZEDTEXT h;
  416. /* have any text? */
  417.   if (h.data = (unsigned char *) s) {
  418.     h.size = strlen (s); /* yes, get its size */
  419.     return mail_search_header (&h,st);
  420.   }
  421.   return NIL;
  422. }
  425. /* Mail search message header
  426.  * Accepts: header as sized text
  427.  *     strings to search
  428.  * Returns: T if search found a match
  429.  */
  431. long mail_search_header (SIZEDTEXT *hdr,STRINGLIST *st)
  432. {
  433.   SIZEDTEXT h;
  434.   long ret = LONGT;
  435.   utf8_mime2text (hdr,&h); /* make UTF-8 version of header */
  436.   while (h.size && ((h.data[h.size-1]=='15') || (h.data[h.size-1]=='12')))
  437.     --h.size; /* slice off trailing newlines */
  438.   do if (h.size ? /* search non-empty string */
  439.  !search (h.data,h.size,st->text.data,st->text.size) : st->text.size)
  440.     ret = NIL;
  441.   while (ret && (st = st->next));
  442.   if (h.data != hdr->data) fs_give ((void **) &h.data);
  443.   return ret;
  444. }
  446. /* Mail search message body
  447.  * Accepts: MAIL stream
  448.  *     message number
  449.  *     optional section specification
  450.  *     string list
  451.  *     flags
  452.  * Returns: T if search found a match
  453.  */
  455. long mail_search_text (MAILSTREAM *stream,unsigned long msgno,char *section,
  456.        STRINGLIST *st,long flags)
  457. {
  458.   BODY *body;
  459.   long ret = NIL;
  460.   STRINGLIST *s = mail_newstringlist ();
  461.   mailgets_t omg = mailgets;
  462.   if (stream->dtb->flags & DR_LOWMEM) mailgets = mail_search_gets;
  463. /* strings to search */
  464.   for (stream->private.search.string = s; st;) {
  465.     s->text.data = st->text.data;
  466.     s->text.size = st->text.size;
  467.     if (st = st->next) s = s->next = mail_newstringlist ();
  468.   }
  469.   stream->private.search.text = NIL;
  470.   if (flags) { /* want header? */
  471.     SIZEDTEXT s,t;
  472.     s.data = (unsigned char *)
  473.       mail_fetch_header (stream,msgno,section,NIL,&s.size,FT_INTERNAL|FT_PEEK);
  474.     utf8_mime2text (&s,&t);
  475.     ret = mail_search_string (&t,"UTF-8",&stream->private.search.string);
  476.     if (t.data != s.data) fs_give ((void **) &t.data);
  477.   }
  478.   if (!ret) { /* still looking for match? */
  479. /* no section, get top-level body */
  480.     if (!section) mail_fetchstructure (stream,msgno,&body);
  481. /* get body of nested message */
  482.     else if ((body = mail_body (stream,msgno,section)) &&
  483.      (body->type == TYPEMULTIPART) && body->subtype &&
  484.      !strcmp (body->subtype,"RFC822")) body = body->nested.msg->body;
  485.     if (body) ret = mail_search_body (stream,msgno,body,NIL,1,flags);
  486.   }
  487.   mailgets = omg; /* restore former gets routine */
  488. /* clear searching */
  489.   for (s = stream->private.search.string; s; s = s->next) s->text.data = NIL;
  490.   mail_free_stringlist (&stream->private.search.string);
  491.   stream->private.search.text = NIL;
  492.   return ret;
  493. }
  495. /* Mail search message body text parts
  496.  * Accepts: MAIL stream
  497.  *     message number
  498.  *     current body pointer
  499.  *     hierarchical level prefix
  500.  *     position at current hierarchical level
  501.  *     string list
  502.  *     flags
  503.  * Returns: T if search found a match
  504.  */
  506. long mail_search_body (MAILSTREAM *stream,unsigned long msgno,BODY *body,
  507.        char *prefix,unsigned long section,long flags)
  508. {
  509.   long ret = NIL;
  510.   unsigned long i;
  511.   char *s,*t,sect[MAILTMPLEN];
  512.   SIZEDTEXT st,h;
  513.   PART *part;
  514.   PARAMETER *param;
  515.   if (prefix && (strlen (prefix) > (MAILTMPLEN - 20))) return NIL;
  516.   sprintf (sect,"%s%lu",prefix ? prefix : "",section++);
  517.   if (flags && prefix) { /* want to search MIME header too? */
  518.     st.data = (unsigned char *) mail_fetch_mime (stream,msgno,sect,&st.size,
  519.  FT_INTERNAL | FT_PEEK);
  520.     if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result;
  521.     else {
  522.       utf8_mime2text (&st,&h); /* make UTF-8 version of header */
  523.       ret = mail_search_string (&h,"UTF-8",&stream->private.search.string);
  524.       if (h.data != st.data) fs_give ((void **) &h.data);
  525.     }
  526.   }
  527.   if (!ret) switch (body->type) {
  528.   case TYPEMULTIPART:
  529. /* extend prefix if not first time */
  530.     s = prefix ? strcat (sect,".") : "";
  531.     for (i = 1,part = body->nested.part; part && !ret; i++,part = part->next)
  532.       ret = mail_search_body (stream,msgno,&part->body,s,i,flags);
  533.     break;
  534.   case TYPEMESSAGE:
  535.     if (flags) { /* want to search nested message header? */
  536.       st.data = (unsigned char *)
  537. mail_fetch_header (stream,msgno,sect,NIL,&st.size,
  538.    FT_INTERNAL | FT_PEEK);
  539.       if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result;
  540.       else {
  541. utf8_mime2text (&st,&h);/* make UTF-8 version of header */
  542. ret = mail_search_string (&h,"UTF-8",&stream->private.search.string);
  543. if (h.data != st.data) fs_give ((void **) &h.data);
  544.       }
  545.     }
  546.     if (body = body->nested.msg->body)
  547.       ret = (body->type == TYPEMULTIPART) ?
  548. mail_search_body (stream,msgno,body,(prefix ? prefix : ""),section - 1,
  549.   flags) :
  550.   mail_search_body (stream,msgno,body,strcat (sect,"."),1,flags);
  551.     break;
  553.   case TYPETEXT:
  554.     s = mail_fetch_body (stream,msgno,sect,&i,FT_INTERNAL | FT_PEEK);
  555.     if (stream->dtb->flags & DR_LOWMEM) ret = stream->private.search.result;
  556.     else {
  557.       for (t = NIL,param = body->parameter; param && !t; param = param->next)
  558. if (!strcmp (param->attribute,"CHARSET")) t = param->value;
  559.       switch (body->encoding) { /* what encoding? */
  560.       case ENCBASE64:
  561. if (st.data = (unsigned char *)
  562.     rfc822_base64 ((unsigned char *) s,i,&st.size)) {
  563.   ret = mail_search_string (&st,t,&stream->private.search.string);
  564.   fs_give ((void **) &st.data);
  565. }
  566. break;
  567.       case ENCQUOTEDPRINTABLE:
  568. if (st.data = rfc822_qprint ((unsigned char *) s,i,&st.size)) {
  569.   ret = mail_search_string (&st,t,&stream->private.search.string);
  570.   fs_give ((void **) &st.data);
  571. }
  572. break;
  573.       default:
  574. st.data = (unsigned char *) s;
  575. st.size = i;
  576. ret = mail_search_string (&st,t,&stream->private.search.string);
  577. break;
  578.       }
  579.     }
  580.     break;
  581.   }
  582.   return ret;
  583. }
  585. /* Mail search text
  586.  * Accepts: sized text to search
  587.  *     character set of sized text
  588.  *     string list of search keys
  589.  * Returns: T if search found a match
  590.  */
  592. long mail_search_string (SIZEDTEXT *s,char *charset,STRINGLIST **st)
  593. {
  594.   void *t;
  595.   SIZEDTEXT u;
  596.   STRINGLIST **sc = st;
  597.   if (utf8_text (s,charset,&u,NIL)) {
  598.     while (*sc) { /* run down criteria list */
  599.       if (search (u.data,u.size,(*sc)->text.data,(*sc)->text.size)) {
  600. t = (void *) (*sc); /* found one, need to flush this */
  601. *sc = (*sc)->next; /* remove it from the list */
  602. fs_give (&t); /* flush the buffer */
  603.       }
  604.       else sc = &(*sc)->next; /* move to next in list */
  605.     }
  606.     if (u.data != s->data) fs_give ((void **) &u.data);
  607.   }
  608.   return *st ? NIL : LONGT;
  609. }
  612. /* Mail search keyword
  613.  * Accepts: MAIL stream
  614.  *     elt to get flags from
  615.  *     keyword list
  616.  * Returns: T if search found a match
  617.  */
  619. long mail_search_keyword (MAILSTREAM *stream,MESSAGECACHE *elt,STRINGLIST *st)
  620. {
  621.   int i;
  622.   char tmp[MAILTMPLEN],tmp2[MAILTMPLEN];
  623.   do { /* get uppercase form of flag */
  624.     sprintf (tmp,"%.900s",(char *) st->text.data);
  625.     ucase (tmp);
  626.     for (i = 0;; ++i) { /* check each possible keyword */
  627.       if (i >= NUSERFLAGS || !stream->user_flags[i]) return NIL;
  628.       if (elt->user_flags & (1 << i)) {
  629. sprintf (tmp2,"%.901s",stream->user_flags[i]);
  630. if (!strcmp (tmp,ucase (tmp2))) break;
  631.       }
  632.     }
  633.   }
  634.   while (st = st->next); /* try next keyword */
  635.   return T;
  636. }
  638. /* Mail search an address list
  639.  * Accepts: address list
  640.  *     string list
  641.  * Returns: T if search found a match
  642.  */
  644. #define SEARCHBUFLEN (size_t) 2000
  645. #define SEARCHBUFSLOP (size_t) 5
  647. long mail_search_addr (ADDRESS *adr,STRINGLIST *st)
  648. {
  649.   ADDRESS *a,tadr;
  650.   SIZEDTEXT txt;
  651.   char tmp[MAILTMPLEN];
  652.   size_t i = SEARCHBUFLEN;
  653.   size_t k;
  654.   long ret = NIL;
  655.   if (adr) {
  656.     txt.data = (unsigned char *) fs_get (i + SEARCHBUFSLOP);
  657. /* never an error or next */
  658.     tadr.error = NIL,tadr.next = NIL;
  659. /* write address list */
  660.     for (txt.size = 0,a = adr; a; a = a->next) {
  661.       k = (tadr.mailbox = a->mailbox) ? 2*strlen (a->mailbox) : 3;
  662.       if (tadr.personal = a->personal) k += 3 + 2*strlen (a->personal);
  663.       if (tadr.adl = a->adl) k += 1 + 2*strlen (a->adl);
  664.       if (tadr.host = a->host) k += 1 + 2*strlen (a->host);
  665.       if (k < MAILTMPLEN) { /* ignore ridiculous addresses */
  666. tmp[0] = '';
  667. rfc822_write_address (tmp,&tadr);
  668. /* resize buffer if necessary */
  669. if (((k = strlen (tmp)) + txt.size) > i)
  670.   fs_resize ((void **) &txt.data,SEARCHBUFSLOP + (i += SEARCHBUFLEN));
  671. /* add new address */
  672. memcpy (txt.data + txt.size,tmp,k);
  673. txt.size += k;
  674. /* another address follows */
  675. if (a->next) txt.data[txt.size++] = ',';
  676.       }
  677.     }
  678.     txt.data[txt.size] = ''; /* tie off string */
  679.     ret = mail_search_header (&txt,st);
  680.     fs_give ((void **) &txt.data);
  681.   }
  682.   return ret;
  683. }
  685. /* Get string for low-memory searching
  686.  * Accepts: readin function pointer
  687.  *     stream to use
  688.  *     number of bytes
  689.  *     gets data packet
  691.  *     mail stream
  692.  *     message number
  693.  *     descriptor string
  694.  *     option flags
  695.  * Returns: NIL, always
  696.  */
  698. #define SEARCHSLOP 128
  700. char *mail_search_gets (readfn_t f,void *stream,unsigned long size,
  701. GETS_DATA *md)
  702. {
  703.   unsigned long i;
  704.   char tmp[MAILTMPLEN+SEARCHSLOP+1];
  705.   SIZEDTEXT st;
  706. /* better not be called unless searching */
  707.   if (!md->stream->private.search.string) {
  708.     sprintf (tmp,"Search botch, mbx = %.80s, %s = %lu[%.80s]",
  709.      md->stream->mailbox,
  710.      (md->flags & FT_UID) ? "UID" : "msg",md->msgno,md->what);
  711.     fatal (tmp);
  712.   }
  713. /* initially no match for search */
  714.   md->stream->private.search.result = NIL;
  715. /* make sure buffer clear */
  716.   memset (st.data = (unsigned char *) tmp,'',
  717.   (size_t) MAILTMPLEN+SEARCHSLOP+1);
  718. /* read first buffer */
  719.   (*f) (stream,st.size = i = min (size,(long) MAILTMPLEN),tmp);
  720. /* search for text */
  721.   if (mail_search_string (&st,NIL,&md->stream->private.search.string))
  722.     md->stream->private.search.result = T;
  723.   else if (size -= i) { /* more to do, blat slop down */
  724.     memmove (tmp,tmp+MAILTMPLEN-SEARCHSLOP,(size_t) SEARCHSLOP);
  725.     do { /* read subsequent buffers one at a time */
  726.       (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp+SEARCHSLOP);
  727.       st.size = i + SEARCHSLOP;
  728.       if (mail_search_string (&st,NIL,&md->stream->private.search.string))
  729. md->stream->private.search.result = T;
  730.       else memmove (tmp,tmp+MAILTMPLEN,(size_t) SEARCHSLOP);
  731.     }
  732.     while ((size -= i) && !md->stream->private.search.result);
  733.   }
  734.   if (size) { /* toss out everything after that */
  735.     do (*f) (stream,i = min (size,(long) MAILTMPLEN),tmp);
  736.     while (size -= i);
  737.   }
  738.   return NIL;
  739. }
  741. /* Mail parse search criteria
  742.  * Accepts: criteria
  743.  * Returns: search program if parse successful, else NIL
  744.  */
  746. SEARCHPGM *mail_criteria (char *criteria)
  747. {
  748.   SEARCHPGM *pgm;
  749.   char tmp[MAILTMPLEN];
  750.   int f = NIL;
  751.   if (!criteria) return NIL; /* return if no criteria */
  752.   pgm = mail_newsearchpgm (); /* make a basic search program */
  753. /* for each criterion */
  754.   for (criteria = strtok (criteria," "); criteria;
  755.        (criteria = strtok (NIL," "))) {
  756.     f = NIL; /* init then scan the criterion */
  757.     switch (*ucase (criteria)) {
  758.     case 'A': /* possible ALL, ANSWERED */
  759.       if (!strcmp (criteria+1,"LL")) f = T;
  760.       else if (!strcmp (criteria+1,"NSWERED")) f = pgm->answered = T;
  761.       break;
  762.     case 'B': /* possible BCC, BEFORE, BODY */
  763.       if (!strcmp (criteria+1,"CC")) f = mail_criteria_string (&pgm->bcc);
  764.       else if (!strcmp (criteria+1,"EFORE"))
  765. f = mail_criteria_date (&pgm->before);
  766.       else if (!strcmp (criteria+1,"ODY")) f=mail_criteria_string (&pgm->body);
  767.       break;
  768.     case 'C': /* possible CC */
  769.       if (!strcmp (criteria+1,"C")) f = mail_criteria_string (&pgm->cc);
  770.       break;
  771.     case 'D': /* possible DELETED */
  772.       if (!strcmp (criteria+1,"ELETED")) f = pgm->deleted = T;
  773.       break;
  774.     case 'F': /* possible FLAGGED, FROM */
  775.       if (!strcmp (criteria+1,"LAGGED")) f = pgm->flagged = T;
  776.       else if (!strcmp (criteria+1,"ROM")) f=mail_criteria_string (&pgm->from);
  777.       break;
  778.     case 'K': /* possible KEYWORD */
  779.       if (!strcmp (criteria+1,"EYWORD"))
  780. f = mail_criteria_string (&pgm->keyword);
  781.       break;
  783.     case 'N': /* possible NEW */
  784.       if (!strcmp (criteria+1,"EW")) f = pgm->recent = pgm->unseen = T;
  785.       break;
  786.     case 'O': /* possible OLD, ON */
  787.       if (!strcmp (criteria+1,"LD")) f = pgm->old = T;
  788.       else if (!strcmp (criteria+1,"N")) f = mail_criteria_date (&pgm->on);
  789.       break;
  790.     case 'R': /* possible RECENT */
  791.       if (!strcmp (criteria+1,"ECENT")) f = pgm->recent = T;
  792.       break;
  793.     case 'S': /* possible SEEN, SINCE, SUBJECT */
  794.       if (!strcmp (criteria+1,"EEN")) f = pgm->seen = T;
  795.       else if (!strcmp (criteria+1,"INCE")) f=mail_criteria_date (&pgm->since);
  796.       else if (!strcmp (criteria+1,"UBJECT"))
  797. f = mail_criteria_string (&pgm->subject);
  798.       break;
  799.     case 'T': /* possible TEXT, TO */
  800.       if (!strcmp (criteria+1,"EXT")) f = mail_criteria_string (&pgm->text);
  801.       else if (!strcmp (criteria+1,"O")) f = mail_criteria_string (&pgm->to);
  802.       break;
  803.     case 'U': /* possible UN* */
  804.       if (criteria[1] == 'N') {
  805. if (!strcmp (criteria+2,"ANSWERED")) f = pgm->unanswered = T;
  806. else if (!strcmp (criteria+2,"DELETED")) f = pgm->undeleted = T;
  807. else if (!strcmp (criteria+2,"FLAGGED")) f = pgm->unflagged = T;
  808. else if (!strcmp (criteria+2,"KEYWORD"))
  809.   f = mail_criteria_string (&pgm->unkeyword);
  810. else if (!strcmp (criteria+2,"SEEN")) f = pgm->unseen = T;
  811.       }
  812.       break;
  813.     default: /* we will barf below */
  814.       break;
  815.     }
  816.     if (!f) { /* if can't determine any criteria */
  817.       sprintf (tmp,"Unknown search criterion: %.30s",criteria);
  818.       mm_log (tmp,ERROR);
  819.       mail_free_searchpgm (&pgm);
  820.       break;
  821.     }
  822.   }
  823.   return pgm;
  824. }
  826. /* Parse a date
  827.  * Accepts: pointer to date integer to return
  828.  * Returns: T if successful, else NIL
  829.  */
  831. int mail_criteria_date (unsigned short *date)
  832. {
  833.   STRINGLIST *s = NIL;
  834.   MESSAGECACHE elt;
  835. /* parse the date and return fn if OK */
  836.   int ret = (mail_criteria_string (&s) &&
  837.      mail_parse_date (&elt,(char *) s->text.data) &&
  838.      (*date = (elt.year << 9) + (elt.month << 5) + elt.day)) ?
  839.        T : NIL;
  840.   if (s) mail_free_stringlist (&s);
  841.   return ret;
  842. }
  845. /* Parse a string
  846.  * Accepts: pointer to stringlist
  847.  * Returns: T if successful, else NIL
  848.  */
  850. int mail_criteria_string (STRINGLIST **s)
  851. {
  852.   unsigned long n;
  853.   char e,*d,*end = " ",*c = strtok (NIL,"");
  854.   if (!c) return NIL; /* missing argument */
  855.   switch (*c) { /* see what the argument is */
  856.   case '{': /* literal string */
  857.     n = strtoul (c+1,&d,10); /* get its length */
  858.     if ((*d++ == '}') && (*d++ == '15') && (*d++ == '12') &&
  859. (!(*(c = d + n)) || (*c == ' '))) {
  860.       e = *--c; /* store old delimiter */
  861.       *c = DELIM; /* make sure not a space */
  862.       strtok (c," "); /* reset the strtok mechanism */
  863.       *c = e; /* put character back */
  864.       break;
  865.     }
  866.   case '': /* catch bogons */
  867.   case ' ':
  868.     return NIL;
  869.   case '"': /* quoted string */
  870.     if (strchr (c+1,'"')) end = """;
  871.     else return NIL; /* falls through */
  872.   default: /* atomic string */
  873.     if (d = strtok (c,end)) n = strlen (d);
  874.     else return NIL;
  875.     break;
  876.   }
  877.   while (*s) s = &(*s)->next; /* find tail of list */
  878.   *s = mail_newstringlist (); /* make new entry */
  879. /* return the data */
  880.   (*s)->text.data = (unsigned char *) cpystr (d);
  881.   (*s)->text.size = n;
  882.   return T;
  883. }
  885. /* Mail sort messages
  886.  * Accepts: mail stream
  887.  *     character set
  888.  *     search program
  889.  *     sort program
  890.  *     option flags
  891.  * Returns: vector of sorted message sequences or NIL if error
  892.  */
  894. unsigned long *mail_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
  895.   SORTPGM *pgm,long flags)
  896. {
  897.   unsigned long *ret = NIL;
  898.   if (stream->dtb) /* do the driver's action */
  899.     ret = (*(stream->dtb->sort ? stream->dtb->sort : mail_sort_msgs))
  900.       (stream,charset,spg,pgm,flags);
  901. /* flush search/sort programs if requested */
  902.   if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg);
  903.   if (flags & SO_FREE) mail_free_sortpgm (&pgm);
  904.   return ret;
  905. }
  907. /* Mail sort messages work routine
  908.  * Accepts: mail stream
  909.  *     character set
  910.  *     search program
  911.  *     sort program
  912.  *     option flags
  913.  * Returns: vector of sorted message sequences or NIL if error
  914.  */
  916. unsigned long *mail_sort_msgs (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
  917.        SORTPGM *pgm,long flags)
  918. {
  919.   unsigned long i;
  920.   SORTCACHE **sc;
  921.   unsigned long *ret = NIL;
  922.   if (spg) { /* only if a search needs to be done */
  923.     int silent = stream->silent;
  924.     stream->silent = T; /* don't pass up mm_searched() events */
  925. /* search for messages */
  926.     mail_search_full (stream,charset,spg,NIL);
  927.     stream->silent = silent; /* restore silence state */
  928.   }
  929. /* initialize progress counters */
  930.   pgm->nmsgs = pgm->progress.cached = 0;
  931. /* pass 1: count messages to sort */
  932.   for (i = 1; i <= stream->nmsgs; ++i)
  933.     if (mail_elt (stream,i)->searched) pgm->nmsgs++;
  934.   if (pgm->nmsgs) { /* pass 2: sort cache */
  935.     sc = mail_sort_loadcache (stream,pgm);
  936. /* pass 3: sort messages */
  937.     if (!pgm->abort) ret = mail_sort_cache (stream,pgm,sc,flags);
  938.     fs_give ((void **) &sc); /* don't need sort vector any more */
  939.   }
  940. /* empty sort results */
  941.   else ret = (unsigned long *) memset (fs_get (sizeof (unsigned long)),0,
  942.        sizeof (unsigned long));
  943. /* also return via callback if requested */
  944.   if (mailsortresults) (*mailsortresults) (stream,ret,pgm->nmsgs);
  945.   return ret; /* return sort results */
  946. }
  948. /* Mail sort sortcache vector
  949.  * Accepts: mail stream
  950.  *     sort program
  951.  *     sortcache vector
  952.  *     option flags
  953.  * Returns: vector of sorted message sequences or NIL if error
  954.  */
  956. unsigned long *mail_sort_cache (MAILSTREAM *stream,SORTPGM *pgm,SORTCACHE **sc,
  957. long flags)
  958. {
  959.   unsigned long i,*ret;
  960. /* pass 3: sort messages */
  961.   qsort ((void *) sc,pgm->nmsgs,sizeof (SORTCACHE *),mail_sort_compare);
  962. /* optional post sorting */
  963.   if (pgm->postsort) (*pgm->postsort) ((void *) sc);
  964. /* pass 4: return results */
  965.   ret = (unsigned long *) fs_get ((pgm->nmsgs+1) * sizeof (unsigned long));
  966.   if (flags & SE_UID) /* UID or msgno? */
  967.     for (i = 0; i < pgm->nmsgs; i++) ret[i] = mail_uid (stream,sc[i]->num);
  968.   else for (i = 0; i < pgm->nmsgs; i++) ret[i] = sc[i]->num;
  969.   ret[pgm->nmsgs] = 0; /* tie off message list */
  970.   return ret;
  971. }
  973. /* Mail load sortcache
  974.  * Accepts: mail stream, already searched
  975.  *     sort program
  976.  * Returns: vector of sortcache pointers matching search
  977.  */
  979. static STRINGLIST maildateline = {{(unsigned char *) "date",4},NIL};
  980. static STRINGLIST mailrnfromline = {{(unsigned char *) ">from",5},NIL};
  981. static STRINGLIST mailfromline = {{(unsigned char *) "from",4},
  982.     &mailrnfromline};
  983. static STRINGLIST mailtonline = {{(unsigned char *) "to",2},NIL};
  984. static STRINGLIST mailccline = {{(unsigned char *) "cc",2},NIL};
  985. static STRINGLIST mailsubline = {{(unsigned char *) "subject",7},NIL};
  987. SORTCACHE **mail_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm)
  988. {
  989.   char *t,*v,*x,tmp[MAILTMPLEN];
  990.   SORTPGM *pg;
  991.   SORTCACHE *s,**sc;
  992.   MESSAGECACHE *elt,telt;
  993.   ENVELOPE *env;
  994.   ADDRESS *adr = NIL;
  995.   unsigned long i = (pgm->nmsgs) * sizeof (SORTCACHE *);
  996.   sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i);
  997. /* see what needs to be loaded */
  998.   for (i = 1; !pgm->abort && (i <= stream->nmsgs); i++)
  999.     if ((elt = mail_elt (stream,i))->searched) {
  1000.       sc[pgm->progress.cached++] =
  1001. s = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE);
  1002.       s->pgm = pgm; /* note sort program */
  1003.       s->num = i;
  1004. /* get envelope if cached */
  1005.       if (stream->scache) env = (i == stream->msgno) ? stream->env : NIL;
  1006.       else env = elt->private.msg.env;
  1007.       for (pg = pgm; pg; pg = pg->next) switch (pg->function) {
  1008.       case SORTARRIVAL: /* sort by arrival date */
  1009. if (!s->arrival) {
  1010.   if (!elt->day) { /* if date unknown */
  1011.     sprintf (tmp,"%lu",i);
  1012.     mail_fetch_fast (stream,tmp,NIL);
  1013.   }
  1014. /* wrong thing before 3-Jan-1970 */
  1015.   s->arrival = elt->day ? mail_longdate (elt) : 1;
  1016. }
  1017. break;
  1018.       case SORTSIZE: /* sort by message size */
  1019. if (!s->size) {
  1020.   if (!elt->rfc822_size) {
  1021.     sprintf (tmp,"%lu",i);
  1022.     mail_fetch_fast (stream,tmp,NIL);
  1023.   }
  1024.   s->size = elt->rfc822_size ? elt->rfc822_size : 1;
  1025. }
  1026. break;
  1028.       case SORTDATE: /* sort by date */
  1029. if (!s->date) {
  1030.   if (env) t = env->date;
  1031.   else if ((t = mail_fetch_header (stream,i,NIL,&maildateline,NIL,
  1032.    FT_INTERNAL | FT_PEEK)) &&
  1033.    (t = strchr (t,':')))
  1034.     for (x = ++t; x = strpbrk (x,"1215"); x++)
  1035.       switch (*(v = ((*x == '15') && (x[1] == '12')) ? x+2 : x+1)){
  1036.       case ' ': /* erase continuation newlines */
  1037.       case 't':
  1038. memmove (x,v,strlen (v));
  1039. break;
  1040.       default: /* tie off extraneous text */
  1041. *x = x[1] = '';
  1042.       }
  1043. /* skip leading whitespace */
  1044.   if (t) while ((*t == ' ') || (*t == 't')) t++;
  1045. /* wrong thing before 3-Jan-1970 */
  1046.   if (!(t && mail_parse_date (&telt,t) &&
  1047. (s->date = mail_longdate (&telt)))) s->date = 1;
  1048. }
  1049. break;
  1050.       case SORTFROM: /* sort by first from */
  1051. if (!s->from) {
  1052.   if (env) s->from = env->from && env->from->mailbox ?
  1053.     cpystr (env->from->mailbox) : NIL;
  1054.   else if ((t = mail_fetch_header (stream,i,NIL,&mailfromline,NIL,
  1055.    FT_INTERNAL | FT_PEEK)) &&
  1056.    (t = strchr (t,':'))) {
  1057.     for (x = ++t; x = strpbrk (x,"1215"); x++)
  1058.       switch (*(v = ((*x == '15') && (x[1] == '12')) ? x+2 : x+1)){
  1059.       case ' ': /* erase continuation newlines */
  1060.       case 't':
  1061. memmove (x,v,strlen (v));
  1062. break;
  1063.       case 'f': /* continuation but with extra "From:" */
  1064.       case 'F':
  1065. if (v = strchr (v,':')) {
  1066.   memmove (x,v+1,strlen (v+1));
  1067.   break;
  1068. }
  1069.       default: /* tie off extraneous text */
  1070. *x = x[1] = '';
  1071.       }
  1072.     if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
  1073.       s->from = adr->mailbox;
  1074.       adr->mailbox = NIL;
  1075.       mail_free_address (&adr);
  1076.     }
  1077.   }
  1078.   if (!s->from) s->from = cpystr ("");
  1079. }
  1080. break;
  1082.       case SORTTO: /* sort by first to */
  1083. if (!s->to) {
  1084.   if (env) s->to = env->to && env->to->mailbox ?
  1085.     cpystr (env->to->mailbox) : NIL;
  1086.   else if ((t = mail_fetch_header (stream,i,NIL,&mailtonline,NIL,
  1087.    FT_INTERNAL | FT_PEEK)) &&
  1088.    (t = strchr (t,':'))) {
  1089.     for (x = ++t; x = strpbrk (x,"1215"); x++)
  1090.       switch (*(v = ((*x == '15') && (x[1] == '12')) ? x+2 : x+1)){
  1091.       case ' ': /* erase continuation newlines */
  1092.       case 't':
  1093. memmove (x,v,strlen (v));
  1094. break;
  1095.       case 't': /* continuation but with extra "To:" */
  1096.       case 'T':
  1097. if (v = strchr (v,':')) {
  1098.   memmove (x,v+1,strlen (v+1));
  1099.   break;
  1100. }
  1101.       default: /* tie off extraneous text */
  1102. *x = x[1] = '';
  1103.       }
  1104.     if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
  1105.       s->to = adr->mailbox;
  1106.       adr->mailbox = NIL;
  1107.       mail_free_address (&adr);
  1108.     }
  1109.   }
  1110.   if (!s->to) s->to = cpystr ("");
  1111. }
  1112. break;
  1114.       case SORTCC: /* sort by first cc */
  1115. if (!s->cc) {
  1116.   if (env) s->cc = env->cc && env->cc->mailbox ?
  1117.     cpystr (env->cc->mailbox) : NIL;
  1118.   else if ((t = mail_fetch_header (stream,i,NIL,&mailccline,NIL,
  1119.    FT_INTERNAL | FT_PEEK)) &&
  1120.    (t = strchr (t,':'))) {
  1121.     for (x = ++t; x = strpbrk (x,"1215"); x++)
  1122.       switch (*(v = ((*x == '15') && (x[1] == '12')) ? x+2 : x+1)){
  1123.       case ' ': /* erase continuation newlines */
  1124.       case 't':
  1125. memmove (x,v,strlen (v));
  1126. break;
  1127.       case 't': /* continuation but with extra "To:" */
  1128.       case 'T':
  1129. if (v = strchr (v,':')) {
  1130.   memmove (x,v+1,strlen (v+1));
  1131.   break;
  1132. }
  1133.       default: /* tie off extraneous text */
  1134. *x = x[1] = '';
  1135.       }
  1136.     if (adr = rfc822_parse_address (&adr,adr,&t,BADHOST,0)) {
  1137.       s->cc = adr->mailbox;
  1138.       adr->mailbox = NIL;
  1139.       mail_free_address (&adr);
  1140.     }
  1141.   }
  1142.   if (!s->cc) s->cc = cpystr ("");
  1143. }
  1144. break;
  1146.       case SORTSUBJECT: /* sort by subject */
  1147. if (!s->subject) {
  1148. /* get subject from envelope if have one */
  1149.   if (env) t = env->subject ? env->subject : "";
  1150. /* otherwise snarf from header text */
  1151.   else if ((t = mail_fetch_header (stream,i,NIL,&mailsubline,
  1152.    NIL,FT_INTERNAL | FT_PEEK)) &&
  1153.    (t = strchr (t,':')))
  1154.     for (x = ++t; x = strpbrk (x,"1215"); x++)
  1155.       switch (*(v = ((*x == '15') && (x[1] == '12')) ? x+2 : x+1)){
  1156.       case ' ': /* erase continuation newlines */
  1157.       case 't':
  1158. memmove (x,v,strlen (v));
  1159. break;
  1160.       default: /* tie off extraneous text */
  1161. *x = x[1] = '';
  1162.       }
  1163.   else t = ""; /* empty subject */
  1164. /* strip and cache subject */
  1165.   s->subject = mail_strip_subject (t);
  1166. }
  1167. break;
  1168.       default:
  1169. fatal ("Unknown sort function");
  1170.       }
  1171.     }
  1172.   return sc;
  1173. }
  1175. /* Strip subjects of extra spaces and leading and trailing cruft for sorting
  1176.  * Accepts: unstripped subject
  1177.  * Returns: stripped subject, in cpystr form
  1178.  */
  1180. char *mail_strip_subject (char *t)
  1181. {
  1182.   char c,*s,*x;
  1183.   SIZEDTEXT src,dst;
  1184. /* flush leading whitespace, [, and "re" */
  1185.   for (x = t; x; ) switch (*t) {
  1186.   case ' ': case 't':
  1187.     t++; /* leading whitespace */
  1188.     break;
  1189.   case '[': /* leading [ */
  1190.     for (x = ++t; x;) switch (*x) {
  1191.     case ']': /* closing ] */
  1192.       while (x) switch (*++x) {
  1193.       case '(': /* possible trailing (fwd) */
  1194. if (((x[1] == 'F') || (x[1] == 'f')) &&
  1195.     ((x[2] == 'W') || (x[2] == 'w')) &&
  1196.     ((x[3] == 'D') || (x[3] == 'd')) && x[4] == ')') {
  1197.   x += 4; /* yes, skip past it */
  1198.   break; /* continue scan */
  1199. }
  1200. /* else fall through */
  1201.       default:
  1202. t = x; /* found usable text */
  1203.       case '': /* end of string */
  1204. x = NIL; /* terminate search here */
  1205.       case ' ': case 't': /* skip whitespace */
  1206. break;
  1207.       }
  1208.       break;
  1209.     case '': case '[': /* end of string or nesting */
  1210.       x = NIL; /* just punt */
  1211.       break;
  1212.     default: /* any other character */
  1213.       x++; /* sniff at next */
  1214.       break;
  1215.     }
  1216.     x = t; /* finished handling [...] */
  1217.     break;
  1219.   case 'R': case 'r': /* possible "re" */
  1220.     if ((t[1] != 'E') && (t[1] != 'e')) x = NIL;
  1221.     else { /* found re, skip leading whitespace */
  1222.       for (x = t + 2; (*x == ' ') || (*x == 't'); x++);
  1223.       switch (*x++) { /* what comes after? */
  1224.       case ':': /* "re:" */
  1225. t = x;
  1226. break;
  1227.       case '[': /* possible "re[babble]:" */
  1228. if (x = strchr (x,']')) {
  1229.   for (x++; ((*x == ' ') || (*x == 't')); x++);
  1230.   if (*x == ':') t = ++x;
  1231.   else x = NIL;
  1232. }
  1233. break;
  1234.       default: /* something significant starting with "re" */
  1235. x = NIL; /* terminate the loop */
  1236. break;
  1237.       }
  1238.     }
  1239.     break;
  1240.   case 'F': case 'f': /* possible "fw" or "fwd" */
  1241.     if ((t[1] != 'W') && (t[1] != 'w')) x = NIL;
  1242.     else { /* found fw, skip "D" and leading whitespace */
  1243.       for (x = ((t[2] == 'D') || (t[2] == 'd')) ? t + 3 : t + 2;
  1244.    (*x == ' ') || (*x == 't'); x++);
  1245.       switch (*x++) { /* what comes after? */
  1246.       case ':': /* "fwd:" */
  1247. t = x;
  1248. break;
  1249.       case '[': /* possible "fwd[babble]:" */
  1250. if (x = strchr (x,']')) {
  1251.   for (x++; ((*x == ' ') || (*x == 't')); x++);
  1252.   if (*x == ':') t = ++x;
  1253.   else x = NIL;
  1254. }
  1255. break;
  1256.       default: /* something significant starting with "fwd" */
  1257. x = NIL; /* terminate the loop */
  1258. break;
  1259.       }
  1260.     }
  1261.     break;
  1262.   default: /* something significant */
  1263.     x = NIL; /* terminate the loop */
  1264.     break;
  1265.   }
  1267. /* have an empty subject? */
  1268.   if (!(src.size = strlen (t))) return cpystr ("");
  1269.   src.data = (unsigned char *) t;
  1270. /* make copy, convert MIME2 if needed */
  1271.   if (utf8_mime2text (&src,&dst) && (src.data != dst.data))
  1272.     t = (x = (char *) dst.data) + dst.size;
  1273.   else t = (x = cpystr ((char *) src.data)) + src.size;
  1274.   while (t > x) { /* flush trailing "(fwd)", ], and whitespace */
  1275.     while ((t[-1] == ' ') || (t[-1] == 't') || (t[-1] == ']')) t--;
  1276.     if ((t >= (x + 5)) && (t[-5] == '(') &&
  1277. ((t[-4] == 'F') || (t[-4] == 'f')) &&
  1278. ((t[-3] == 'W') || (t[-3] == 'w')) &&
  1279. ((t[-2] == 'D') || (t[-2] == 'd')) && (t[-1] == ')')) t -= 5;
  1280.     else break;
  1281.   }
  1282.   *t = ''; /* tie off subject string */
  1283. /* convert spaces to tab, strip extra spaces */
  1284.   for (s = t = x, c = 'x'; *t; t++) {
  1285.     if (c != ' ') c = *s++ = ((*t == 't') ? ' ' : *t);
  1286.     else if ((*t != 't') && (*t != ' ')) c = *s++ = *t;
  1287.   }
  1288.   *s = ''; /* tie off string again */
  1289.   return x; /* return stripped subject */
  1290. }
  1292. /* Sort compare messages
  1293.  * Accept: first message sort cache element
  1294.  *    second message sort cache element
  1295.  * Returns: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2
  1296.  */
  1298. int mail_sort_compare (const void *a1,const void *a2)
  1299. {
  1300.   int i = 0;
  1301.   SORTCACHE *s1 = *(SORTCACHE **) a1;
  1302.   SORTCACHE *s2 = *(SORTCACHE **) a2;
  1303.   SORTPGM *pgm = s1->pgm;
  1304.   if (!s1->sorted) { /* this one sorted yet? */
  1305.     s1->sorted = T;
  1306.     pgm->progress.sorted++; /* another sorted message */
  1307.   }
  1308.   if (!s2->sorted) { /* this one sorted yet? */
  1309.     s2->sorted = T;
  1310.     pgm->progress.sorted++; /* another sorted message */
  1311.   }
  1312.   do {
  1313.     switch (pgm->function) { /* execute search program */
  1314.     case SORTDATE: /* sort by date */
  1315.       i = mail_compare_ulong (s1->date,s2->date);
  1316.       break;
  1317.     case SORTARRIVAL: /* sort by arrival date */
  1318.       i = mail_compare_ulong (s1->arrival,s2->arrival);
  1319.       break;
  1320.     case SORTSIZE: /* sort by message size */
  1321.       i = mail_compare_ulong (s1->size,s2->size);
  1322.       break;
  1323.     case SORTFROM: /* sort by first from */
  1324.       i = mail_compare_cstring (s1->from,s2->from);
  1325.       break;
  1326.     case SORTTO: /* sort by first to */
  1327.       i = mail_compare_cstring (s1->to,s2->to);
  1328.       break;
  1329.     case SORTCC: /* sort by first cc */
  1330.       i = mail_compare_cstring (s1->cc,s2->cc);
  1331.       break;
  1332.     case SORTSUBJECT: /* sort by subject */
  1333.       i = mail_compare_cstring (s1->subject,s2->subject);
  1334.       break;
  1335.     }
  1336.     if (pgm->reverse) i = -i; /* flip results if necessary */
  1337.   }
  1338.   while (pgm = i ? NIL : pgm->next);
  1339.   return i ? i : (s1->num - s2->num);
  1340. }
  1342. /* Compare two unsigned longs
  1343.  * Accepts: first value
  1344.  *     second value
  1345.  * Returns: -1 if l1 < l2, 0 if l1 == l2, 1 if l1 > l2
  1346.  */
  1348. int mail_compare_ulong (unsigned long l1,unsigned long l2)
  1349. {
  1350.   if (l1 < l2) return -1;
  1351.   if (l1 > l2) return 1;
  1352.   return 0;
  1353. }
  1356. /* Compare two case-independent strings
  1357.  * Accepts: first string
  1358.  *     second string
  1359.  * Returns: -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2
  1360.  */
  1362. int mail_compare_cstring (char *s1,char *s2)
  1363. {
  1364.   int i;
  1365.   if (!s1) return s2 ? -1 : 0; /* empty string cases */
  1366.   else if (!s2) return 1;
  1367.   for (; *s1 && *s2; s1++, s2++)
  1368.     if (i = (mail_compare_ulong (isupper (*s1) ? tolower (*s1) : *s1,
  1369.  isupper (*s2) ? tolower (*s2) : *s2)))
  1370.       return i; /* found a difference */
  1371.   if (*s1) return 1; /* first string is longer */
  1372.   return *s2 ? -1 : 0; /* second string longer : strings identical */
  1373. }
  1376. /* Return message date as an unsigned long seconds since time began
  1377.  * Accepts: message cache pointer
  1378.  * Returns: unsigned long of date
  1379.  */
  1381. unsigned long mail_longdate (MESSAGECACHE *elt)
  1382. {
  1383.   unsigned long yr = elt->year + BASEYEAR;
  1384. /* number of days since time began */
  1385. #ifndef USEORTHODOXCALENDAR /* Gregorian calendar */
  1386.   unsigned long ret = (elt->day - 1) + 30 * (elt->month - 1) +
  1387.     ((unsigned long) ((elt->month + (elt->month > 8))) / 2) +
  1388.       elt->year * 365 + (((unsigned long) (elt->year + (BASEYEAR % 4))) / 4) +
  1389. ((yr / 400) - (BASEYEAR / 400)) - ((yr / 100) - (BASEYEAR / 100)) -
  1390. #ifdef Y4KBUGFIX
  1391.   ((yr / 4000) - (BASEYEAR / 4000)) -
  1392. #endif
  1393.     ((elt->month < 3) ? !(yr % 4) && ((yr % 100) || !(yr % 400)) : 2);
  1394. #else /* Orthodox calendar */
  1395.   unsigned long ret = (elt->day - 1) + 30 * (elt->month - 1) +
  1396.     ((unsigned long) ((elt->month + (elt->month > 8))) / 2) +
  1397.       elt->year * 365 + (((unsigned long) (elt->year + (BASEYEAR % 4))) / 4) +
  1398. ((2*(yr / 900)) - (2*(BASEYEAR / 900))) +
  1399.   (((yr % 900) >= 200) - ((BASEYEAR % 900) >= 200)) +
  1400.     (((yr % 900) >= 600) - ((BASEYEAR % 900) >= 600)) -
  1401.       ((yr / 100) - (BASEYEAR / 100)) -
  1402. ((elt->month < 3) ? !(yr % 4) && 
  1403.  ((yr % 100) || ((yr % 900) == 200) || ((yr % 900) == 600)) :
  1404.    2);
  1405. #endif
  1406.   ret *= 24; ret += elt->hours; /* date value in hours */
  1407.   ret *= 60; ret +=elt->minutes;/* date value in minutes */
  1408.   yr = (elt->zhours * 60) + elt->zminutes;
  1409.   if (elt->zoccident) ret += yr;/* cretinous TinyFlaccid C compiler! */
  1410.   else ret -= yr;
  1411.   ret *= 60; ret += elt->seconds;
  1412.   return ret;
  1413. }
  1415. /* Mail thread messages
  1416.  * Accepts: mail stream
  1417.  *     thread type
  1418.  *     character set
  1419.  *     search program
  1420.  *     option flags
  1421.  * Returns: thread node tree
  1422.  */
  1424. THREADNODE *mail_thread (MAILSTREAM *stream,char *type,char *charset,
  1425.  SEARCHPGM *spg,long flags)
  1426. {
  1427.   THREADNODE *ret = NIL;
  1428.   if (stream->dtb) /* must have a live driver */
  1429.     ret = stream->dtb->thread ? /* do driver's action if available */
  1430.       (*stream->dtb->thread) (stream,type,charset,spg,flags) :
  1431. mail_thread_msgs (stream,type,charset,spg,flags,mail_sort_msgs);
  1432. /* flush search/sort programs if requested */
  1433.   if (spg && (flags & SE_FREE)) mail_free_searchpgm (&spg);
  1434.   return ret;
  1435. }
  1438. /* Mail thread messages
  1439.  * Accepts: mail stream
  1440.  *     thread type
  1441.  *     character set
  1442.  *     search program
  1443.  *     option flags
  1444.  *     sorter routine
  1445.  * Returns: thread node tree
  1446.  */
  1448. THREADNODE *mail_thread_msgs (MAILSTREAM *stream,char *type,char *charset,
  1449.       SEARCHPGM *spg,long flags,sorter_t sorter)
  1450. {
  1451.   THREADER *t;
  1452.   for (t = &mailthreadlist; t; t = t->next) if (!strcmp (type,t->name)) {
  1453.     THREADNODE *ret = (*t->dispatch) (stream,charset,spg,flags,sorter);
  1454.     if (mailthreadresults) (*mailthreadresults) (stream,ret);
  1455.     return ret;
  1456.   }
  1457.   mm_log ("No such thread type",ERROR);
  1458.   return NIL;
  1459. }
  1461. /* Mail thread ordered subject
  1462.  * Accepts: mail stream
  1463.  *     character set
  1464.  *     search program
  1465.  *     option flags
  1466.  *     sorter routine
  1467.  * Returns: thread node tree
  1468.  */
  1470. THREADNODE *mail_thread_orderedsubject (MAILSTREAM *stream,char *charset,
  1471. SEARCHPGM *spg,long flags,
  1472. sorter_t sorter)
  1473. {
  1474.   THREADNODE *thr = NIL;
  1475.   THREADNODE *cur,*top,**tc;
  1476.   SORTPGM pgm,pgm2;
  1477.   SORTCACHE *s;
  1478.   unsigned long i,j,*lst,*ls;
  1479. /* sort by subject+date */
  1480.   memset (&pgm,0,sizeof (SORTPGM));
  1481.   memset (&pgm2,0,sizeof (SORTPGM));
  1482.   pgm.function = SORTSUBJECT;
  1483.   pgm.next = &pgm2;
  1484.   pgm2.function = SORTDATE;
  1485.   if (lst = (*sorter) (stream,charset,spg,&pgm,flags & ~(SE_FREE | SE_UID))){
  1486.     if (*(ls = lst)) { /* create thread */
  1487. /* note first subject */
  1488.       cur = top = thr = mail_newthreadnode
  1489. ((SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE));
  1490. /* note its number */
  1491.       cur->num = (flags & SE_UID) ? mail_uid (stream,*lst) : *lst;
  1492.       i = 1; /* number of threads */
  1493.       while (*ls) { /* build tree */
  1494. /* subjects match? */
  1495. s = (SORTCACHE *) (*mailcache) (stream,*ls++,CH_SORTCACHE);
  1496. if (mail_compare_cstring (top->sc->subject,s->subject)) {
  1497.   i++; /* have a new thread */
  1498.   top = top->branch = cur = mail_newthreadnode (s);
  1499. }
  1500. /* another node on this branch */
  1501. else cur = cur->next = mail_newthreadnode (s);
  1502. /* set to msgno or UID as needed */
  1503. cur->num = (flags & SE_UID) ? mail_uid (stream,s->num) : s->num;
  1504.       }
  1505. /* size of threadnode cache */
  1506.       j = (i + 1) * sizeof (THREADNODE *);
  1507. /* load threadnode cache */
  1508.       tc = (THREADNODE **) memset (fs_get ((size_t) j),0,(size_t) j);
  1509.       for (j = 0, cur = thr; cur; cur = cur->branch) tc[j++] = cur;
  1510.       if (i != j) fatal ("Threadnode cache confusion");
  1511.       qsort ((void *) tc,i,sizeof (THREADNODE *),mail_thread_compare_date);
  1512.       for (j = 0; j < i; j++) tc[j]->branch = tc[j+1];
  1513.       thr = tc[0]; /* head of data */
  1514.       fs_give ((void **) &tc);
  1515.     }
  1516.     fs_give ((void **) &lst);
  1517.   }
  1518.   return thr;
  1519. }
  1522. /* Thread compare date
  1523.  * Accept: first message sort cache element
  1524.  *    second message sort cache element
  1525.  * Returns: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2
  1526.  */
  1528. int mail_thread_compare_date (const void *a1,const void *a2)
  1529. {
  1530.   return mail_compare_ulong ((*(THREADNODE **) a1)->sc->date,
  1531.      (*(THREADNODE **) a2)->sc->date);
  1532. }
  1534. /* Mail parse sequence
  1535.  * Accepts: mail stream
  1536.  *     sequence to parse
  1537.  * Returns: T if parse successful, else NIL
  1538.  */
  1540. long mail_sequence (MAILSTREAM *stream,char *sequence)
  1541. {
  1542.   unsigned long i,j,x;
  1543.   for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->sequence = NIL;
  1544.   while (sequence && *sequence){/* while there is something to parse */
  1545.     if (*sequence == '*') { /* maximum message */
  1546.       if (stream->nmsgs) i = stream->nmsgs;
  1547.       else {
  1548. mm_log ("No messages, so no maximum message number",ERROR);
  1549. return NIL;
  1550.       }
  1551.       sequence++; /* skip past * */
  1552.     }
  1553. /* parse and validate message number */
  1554.     else if (!(i = strtoul ((const char *) sequence,&sequence,10)) ||
  1555.      (i > stream->nmsgs)) {
  1556.       mm_log ("Sequence invalid",ERROR);
  1557.       return NIL;
  1558.     }
  1559.     switch (*sequence) { /* see what the delimiter is */
  1560.     case ':': /* sequence range */
  1561.       if (*++sequence == '*') { /* maximum message */
  1562. if (stream->nmsgs) j = stream->nmsgs;
  1563. else {
  1564.   mm_log ("No messages, so no maximum message number",ERROR);
  1565.   return NIL;
  1566. }
  1567. sequence++; /* skip past * */
  1568.       }
  1569. /* parse end of range */
  1570.       else if (!(j = strtoul ((const char *) sequence,&sequence,10)) ||
  1571.        (j > stream->nmsgs)) {
  1572. mm_log ("Sequence range invalid",ERROR);
  1573. return NIL;
  1574.       }
  1575.       if (*sequence && *sequence++ != ',') {
  1576. mm_log ("Sequence range syntax error",ERROR);
  1577. return NIL;
  1578.       }
  1579.       if (i > j) { /* swap the range if backwards */
  1580. x = i; i = j; j = x;
  1581.       }
  1582. /* mark each item in the sequence */
  1583.       while (i <= j) mail_elt (stream,j--)->sequence = T;
  1584.       break;
  1585.     case ',': /* single message */
  1586.       ++sequence; /* skip the delimiter, fall into end case */
  1587.     case '': /* end of sequence, mark this message */
  1588.       mail_elt (stream,i)->sequence = T;
  1589.       break;
  1590.     default: /* anything else is a syntax error! */
  1591.       mm_log ("Sequence syntax error",ERROR);
  1592.       return NIL;
  1593.     }
  1594.   }
  1595.   return T; /* successfully parsed sequence */
  1596. }
  1598. /* Parse flag list
  1599.  * Accepts: MAIL stream
  1600.  *     flag list as a character string
  1601.  *     pointer to user flags to return
  1602.  * Returns: system flags
  1603.  */
  1605. long mail_parse_flags (MAILSTREAM *stream,char *flag,unsigned long *uf)
  1606. {
  1607.   char *t,*n,*s,tmp[MAILTMPLEN],flg[MAILTMPLEN],key[MAILTMPLEN];
  1608.   short f = 0;
  1609.   long i;
  1610.   short j;
  1611.   *uf = 0; /* initially no user flags */
  1612.   if (flag && *flag) { /* no-op if no flag string */
  1613. /* check if a list and make sure valid */
  1614.     if (((i = (*flag == '(')) ^ (flag[strlen (flag)-1] == ')')) ||
  1615. (strlen (flag) >= MAILTMPLEN)) {
  1616.       mm_log ("Bad flag list",ERROR);
  1617.       return NIL;
  1618.     }
  1619. /* copy the flag string w/o list construct */
  1620.     strncpy (n = tmp,flag+i,(j = strlen (flag) - (2*i)));
  1621.     tmp[j] = '';
  1622.     while ((t = n) && *t) { /* parse the flags */
  1623.       i = 0; /* flag not known yet */
  1624. /* find end of flag */
  1625.       if (n = strchr (t,' ')) *n++ = '';
  1626.       ucase (strcpy (flg,t));
  1627.       if (flg[0] == '\') { /* system flag? */
  1628. switch (flg[1]) { /* dispatch based on first character */
  1629. case 'S': /* possible Seen flag */
  1630.   if (flg[2] == 'E' && flg[3] == 'E' && flg[4] == 'N' && !flg[5])
  1631.     i = fSEEN;
  1632.   break;
  1633. case 'D': /* possible Deleted or Draft flag */
  1634.   if (flg[2] == 'E' && flg[3] == 'L' && flg[4] == 'E' &&
  1635.       flg[5] == 'T' && flg[6] == 'E' && flg[7] == 'D' && !flg[8])
  1636.     i = fDELETED;
  1637.   else if (flg[2] == 'R' && flg[3] == 'A' && flg[4] == 'F' &&
  1638.    flg[5] == 'T' && !flg[6]) i = fDRAFT;
  1639.   break;
  1640. case 'F': /* possible Flagged flag */
  1641.   if (flg[2] == 'L' && flg[3] == 'A' && flg[4] == 'G' &&
  1642.       flg[5] == 'G' && flg[6] == 'E' && flg[7] == 'D' && !flg[8])
  1643.     i = fFLAGGED;
  1644.   break;
  1645. case 'A': /* possible Answered flag */
  1646.   if (flg[2] == 'N' && flg[3] == 'S' && flg[4] == 'W' &&
  1647.       flg[5] == 'E' && flg[6] == 'R' && flg[7] == 'E' &&
  1648.       flg[8] == 'D' && !flg[9]) i = fANSWERED;
  1649.   break;
  1650. default: /* unknown */
  1651.   break;
  1652. }
  1653. if (i) f |= i; /* add flag to flags list */
  1654.       }
  1655. /* user flag, search through table */
  1656.       else for (j = 0; !i && j < NUSERFLAGS && (s=stream->user_flags[j]); ++j){
  1657. sprintf (key,"%.900s",s);
  1658. if (!strcmp (flg,ucase (key))) *uf |= i = 1 << j;
  1659.       }
  1660.       if (!i) { /* didn't find a matching flag? */
  1661. /* can we create it? */
  1662. if (stream->kwd_create && (j < NUSERFLAGS)) {
  1663.   *uf |= 1 << j; /* set the bit */
  1664.   stream->user_flags[j] = cpystr (t);
  1665. /* if out of user flags */
  1666.   if (j == NUSERFLAGS - 1) stream->kwd_create = NIL;
  1667. }
  1668. else {
  1669.   sprintf (key,"Unknown flag: %.80s",t);
  1670.   mm_log (key,ERROR);
  1671. }
  1672.       }
  1673.     }
  1674.   }
  1675.   return f;
  1676. }
  1678. /* Mail check network stream for usability with new name
  1679.  * Accepts: MAIL stream
  1680.  *     candidate new name
  1681.  * Returns: T if stream can be used, NIL otherwise
  1682.  */
  1684. long mail_usable_network_stream (MAILSTREAM *stream,char *name)
  1685. {
  1686.   NETMBX smb,nmb;
  1687.   return (stream && stream->dtb && !(stream->dtb->flags & DR_LOCAL) &&
  1688.   mail_valid_net_parse (name,&nmb) &&
  1689.   mail_valid_net_parse (stream->mailbox,&smb) &&
  1690.   !strcmp (lcase (smb.host),lcase (tcp_canonical (nmb.host))) &&
  1691.   !strcmp (smb.service,nmb.service) &&
  1692.   (!nmb.port || (smb.port == nmb.port)) &&
  1693.   (nmb.anoflag == stream->anonymous) &&
  1694.   (!nmb.user[0] || !strcmp (smb.user,nmb.user))) ? LONGT : NIL;
  1695. }
  1697. /* Mail data structure instantiation routines */
  1700. /* Mail instantiate cache elt
  1701.  * Accepts: initial message number
  1702.  * Returns: new cache elt
  1703.  */
  1705. MESSAGECACHE *mail_new_cache_elt (unsigned long msgno)
  1706. {
  1707.   MESSAGECACHE *elt = (MESSAGECACHE *) memset (fs_get (sizeof (MESSAGECACHE)),
  1708.        0,sizeof (MESSAGECACHE));
  1709.   elt->lockcount = 1; /* initially only cache references it */
  1710.   elt->msgno = msgno; /* message number */
  1711.   return elt;
  1712. }
  1715. /* Mail instantiate envelope
  1716.  * Returns: new envelope
  1717.  */
  1719. ENVELOPE *mail_newenvelope (void)
  1720. {
  1721.   return (ENVELOPE *) memset (fs_get (sizeof (ENVELOPE)),0,sizeof (ENVELOPE));
  1722. }
  1725. /* Mail instantiate address
  1726.  * Returns: new address
  1727.  */
  1729. ADDRESS *mail_newaddr (void)
  1730. {
  1731.   return (ADDRESS *) memset (fs_get (sizeof (ADDRESS)),0,sizeof (ADDRESS));
  1732. }
  1734. /* Mail instantiate body
  1735.  * Returns: new body
  1736.  */
  1738. BODY *mail_newbody (void)
  1739. {
  1740.   return mail_initbody ((BODY *) fs_get (sizeof (BODY)));
  1741. }
  1744. /* Mail initialize body
  1745.  * Accepts: body
  1746.  * Returns: body
  1747.  */
  1749. BODY *mail_initbody (BODY *body)
  1750. {
  1751.   memset ((void *) body,0,sizeof (BODY));
  1752.   body->type = TYPETEXT; /* content type */
  1753.   body->encoding = ENC7BIT; /* content encoding */
  1754.   return body;
  1755. }
  1758. /* Mail instantiate body parameter
  1759.  * Returns: new body part
  1760.  */
  1762. PARAMETER *mail_newbody_parameter (void)
  1763. {
  1764.   return (PARAMETER *) memset (fs_get (sizeof(PARAMETER)),0,sizeof(PARAMETER));
  1765. }
  1768. /* Mail instantiate body part
  1769.  * Returns: new body part
  1770.  */
  1772. PART *mail_newbody_part (void)
  1773. {
  1774.   PART *part = (PART *) memset (fs_get (sizeof (PART)),0,sizeof (PART));
  1775.   mail_initbody (&part->body); /* initialize the body */
  1776.   return part;
  1777. }
  1780. /* Mail instantiate body message part
  1781.  * Returns: new body message part
  1782.  */
  1784. MESSAGE *mail_newmsg (void)
  1785. {
  1786.   return (MESSAGE *) memset (fs_get (sizeof (MESSAGE)),0,sizeof (MESSAGE));
  1787. }
  1789. /* Mail instantiate string list
  1790.  * Returns: new string list
  1791.  */
  1793. STRINGLIST *mail_newstringlist (void)
  1794. {
  1795.   return (STRINGLIST *) memset (fs_get (sizeof (STRINGLIST)),0,
  1796. sizeof (STRINGLIST));
  1797. }
  1800. /* Mail instantiate new search program
  1801.  * Returns: new search program
  1802.  */
  1804. SEARCHPGM *mail_newsearchpgm (void)
  1805. {
  1806.   return (SEARCHPGM *) memset (fs_get (sizeof(SEARCHPGM)),0,sizeof(SEARCHPGM));
  1807. }
  1810. /* Mail instantiate new search program
  1811.  * Accepts: header line name   
  1812.  * Returns: new search program
  1813.  */
  1815. SEARCHHEADER *mail_newsearchheader (char *line,char *text)
  1816. {
  1817.   SEARCHHEADER *hdr = (SEARCHHEADER *) memset (fs_get (sizeof (SEARCHHEADER)),
  1818.        0,sizeof (SEARCHHEADER));
  1819.   hdr->line.size = strlen ((char *) (hdr->line.data =
  1820.      (unsigned char *) cpystr (line)));
  1821.   hdr->text.size = strlen ((char *) (hdr->text.data =
  1822.      (unsigned char *) cpystr (text)));
  1823.   return hdr;
  1824. }
  1827. /* Mail instantiate new search set
  1828.  * Returns: new search set
  1829.  */
  1831. SEARCHSET *mail_newsearchset (void)
  1832. {
  1833.   return (SEARCHSET *) memset (fs_get (sizeof(SEARCHSET)),0,sizeof(SEARCHSET));
  1834. }
  1837. /* Mail instantiate new search or
  1838.  * Returns: new search or
  1839.  */
  1841. SEARCHOR *mail_newsearchor (void)
  1842. {
  1843.   SEARCHOR *or = (SEARCHOR *) memset (fs_get (sizeof (SEARCHOR)),0,
  1844.       sizeof (SEARCHOR));
  1845.   or->first = mail_newsearchpgm ();
  1846.   or->second = mail_newsearchpgm ();
  1847.   return or;
  1848. }
  1850. /* Mail instantiate new searchpgmlist
  1851.  * Returns: new searchpgmlist
  1852.  */
  1854. SEARCHPGMLIST *mail_newsearchpgmlist (void)
  1855. {
  1856.   SEARCHPGMLIST *pgl = (SEARCHPGMLIST *)
  1857.     memset (fs_get (sizeof (SEARCHPGMLIST)),0,sizeof (SEARCHPGMLIST));
  1858.   pgl->pgm = mail_newsearchpgm ();
  1859.   return pgl;
  1860. }
  1863. /* Mail instantiate new sortpgm
  1864.  * Returns: new sortpgm
  1865.  */
  1867. SORTPGM *mail_newsortpgm (void)
  1868. {
  1869.   return (SORTPGM *) memset (fs_get (sizeof (SORTPGM)),0,sizeof (SORTPGM));
  1870. }
  1873. /* Mail instantiate new threadnode
  1874.  * Accepts: sort cache for thread node
  1875.  * Returns: new threadnode
  1876.  */
  1878. THREADNODE *mail_newthreadnode (SORTCACHE *sc)
  1879. {
  1880.   THREADNODE *thr = (THREADNODE *) memset (fs_get (sizeof (THREADNODE)),0,
  1881.    sizeof (THREADNODE));
  1882.   if (sc) thr->sc = sc; /* initialize sortcache */
  1883.   return thr;
  1884. }
  1886. /* Mail garbage collection routines */
  1889. /* Mail garbage collect body
  1890.  * Accepts: pointer to body pointer
  1891.  */
  1893. void mail_free_body (BODY **body)
  1894. {
  1895.   if (*body) { /* only free if exists */
  1896.     mail_free_body_data (*body);/* free its data */
  1897.     fs_give ((void **) body); /* return body to free storage */
  1898.   }
  1899. }
  1902. /* Mail garbage collect body data
  1903.  * Accepts: body pointer
  1904.  */
  1906. void mail_free_body_data (BODY *body)
  1907. {
  1908.   switch (body->type) { /* free contents */
  1909.   case TYPEMULTIPART: /* multiple part */
  1910.     mail_free_body_part (&body->nested.part);
  1911.     break;
  1912.   case TYPEMESSAGE: /* encapsulated message */
  1913.     if (body->subtype && !strcmp (body->subtype,"RFC822")) {
  1914.       mail_free_stringlist (&body->nested.msg->lines);
  1915.       mail_gc_msg (body->nested.msg,GC_ENV | GC_TEXTS);
  1916.       fs_give ((void **) &body->nested.msg);
  1917.     }
  1918.     break;
  1919.   default:
  1920.     break;
  1921.   }
  1922.   if (body->subtype) fs_give ((void **) &body->subtype);
  1923.   mail_free_body_parameter (&body->parameter);
  1924.   if (body->id) fs_give ((void **) &body->id);
  1925.   if (body->description) fs_give ((void **) &body->description);
  1926.   if (body->disposition.type) fs_give ((void **) &body->disposition);
  1927.   if (body->disposition.parameter)
  1928.     mail_free_body_parameter (&body->disposition.parameter);
  1929.   if (body->language) mail_free_stringlist (&body->language);
  1930.   if (body->mime.text.data) fs_give ((void **) &body->mime.text.data);
  1931.   if (body->contents.text.data) fs_give ((void **) &body->contents.text.data);
  1932.   if (body->md5) fs_give ((void **) &body->md5);
  1933. }
  1935. /* Mail garbage collect body parameter
  1936.  * Accepts: pointer to body parameter pointer
  1937.  */
  1939. void mail_free_body_parameter (PARAMETER **parameter)
  1940. {
  1941.   if (*parameter) { /* only free if exists */
  1942.     if ((*parameter)->attribute) fs_give ((void **) &(*parameter)->attribute);
  1943.     if ((*parameter)->value) fs_give ((void **) &(*parameter)->value);
  1944. /* run down the list as necessary */
  1945.     mail_free_body_parameter (&(*parameter)->next);
  1946. /* return body part to free storage */
  1947.     fs_give ((void **) parameter);
  1948.   }
  1949. }
  1952. /* Mail garbage collect body part
  1953.  * Accepts: pointer to body part pointer
  1954.  */
  1956. void mail_free_body_part (PART **part)
  1957. {
  1958.   if (*part) { /* only free if exists */
  1959.     mail_free_body_data (&(*part)->body);
  1960. /* run down the list as necessary */
  1961.     mail_free_body_part (&(*part)->next);
  1962.     fs_give ((void **) part); /* return body part to free storage */
  1963.   }
  1964. }
  1966. /* Mail garbage collect message cache
  1967.  * Accepts: mail stream
  1968.  *
  1969.  * The message cache is set to NIL when this function finishes.
  1970.  */
  1972. void mail_free_cache (MAILSTREAM *stream)
  1973. {
  1974. /* do driver specific stuff first */
  1975.   mail_gc (stream,GC_ELT | GC_ENV | GC_TEXTS);
  1976. /* flush the cache */
  1977.   (*mailcache) (stream,(long) 0,CH_INIT);
  1978. }
  1981. /* Mail garbage collect cache element
  1982.  * Accepts: pointer to cache element pointer
  1983.  */
  1985. void mail_free_elt (MESSAGECACHE **elt)
  1986. {
  1987. /* only free if exists and no sharers */
  1988.   if (*elt && !--(*elt)->lockcount) {
  1989.     mail_gc_msg (&(*elt)->private.msg,GC_ENV | GC_TEXTS);
  1990.     fs_give ((void **) elt);
  1991.   }
  1992.   else *elt = NIL; /* else simply drop pointer */
  1993. }
  1995. /* Mail garbage collect envelope
  1996.  * Accepts: pointer to envelope pointer
  1997.  */
  1999. void mail_free_envelope (ENVELOPE **env)
  2000. {
  2001.   if (*env) { /* only free if exists */
  2002.     if ((*env)->remail) fs_give ((void **) &(*env)->remail);
  2003.     mail_free_address (&(*env)->return_path);
  2004.     if ((*env)->date) fs_give ((void **) &(*env)->date);
  2005.     mail_free_address (&(*env)->from);
  2006.     mail_free_address (&(*env)->sender);
  2007.     mail_free_address (&(*env)->reply_to);
  2008.     if ((*env)->subject) fs_give ((void **) &(*env)->subject);
  2009.     mail_free_address (&(*env)->to);
  2010.     mail_free_address (&(*env)->cc);
  2011.     mail_free_address (&(*env)->bcc);
  2012.     if ((*env)->in_reply_to) fs_give ((void **) &(*env)->in_reply_to);
  2013.     if ((*env)->message_id) fs_give ((void **) &(*env)->message_id);
  2014.     if ((*env)->newsgroups) fs_give ((void **) &(*env)->newsgroups);
  2015.     if ((*env)->followup_to) fs_give ((void **) &(*env)->followup_to);
  2016.     if ((*env)->references) fs_give ((void **) &(*env)->references);
  2017.     fs_give ((void **) env); /* return envelope to free storage */
  2018.   }
  2019. }
  2022. /* Mail garbage collect address
  2023.  * Accepts: pointer to address pointer
  2024.  */
  2026. void mail_free_address (ADDRESS **address)
  2027. {
  2028.   if (*address) { /* only free if exists */
  2029.     if ((*address)->personal) fs_give ((void **) &(*address)->personal);
  2030.     if ((*address)->adl) fs_give ((void **) &(*address)->adl);
  2031.     if ((*address)->mailbox) fs_give ((void **) &(*address)->mailbox);
  2032.     if ((*address)->host) fs_give ((void **) &(*address)->host);
  2033.     if ((*address)->error) fs_give ((void **) &(*address)->error);
  2034.     mail_free_address (&(*address)->next);
  2035.     fs_give ((void **) address);/* return address to free storage */
  2036.   }
  2037. }
  2040. /* Mail garbage collect stringlist
  2041.  * Accepts: pointer to stringlist pointer
  2042.  */
  2044. void mail_free_stringlist (STRINGLIST **string)
  2045. {
  2046.   if (*string) { /* only free if exists */
  2047.     if ((*string)->text.data) fs_give ((void **) &(*string)->text.data);
  2048.     mail_free_stringlist (&(*string)->next);
  2049.     fs_give ((void **) string); /* return string to free storage */
  2050.   }
  2051. }
  2053. /* Mail garbage collect searchpgm
  2054.  * Accepts: pointer to searchpgm pointer
  2055.  */
  2057. void mail_free_searchpgm (SEARCHPGM **pgm)
  2058. {
  2059.   if (*pgm) { /* only free if exists */
  2060.     mail_free_searchset (&(*pgm)->msgno);
  2061.     mail_free_searchset (&(*pgm)->uid);
  2062.     mail_free_searchor (&(*pgm)->or);
  2063.     mail_free_searchpgmlist (&(*pgm)->not);
  2064.     mail_free_searchheader (&(*pgm)->header);
  2065.     mail_free_stringlist (&(*pgm)->bcc);
  2066.     mail_free_stringlist (&(*pgm)->body);
  2067.     mail_free_stringlist (&(*pgm)->cc);
  2068.     mail_free_stringlist (&(*pgm)->from);
  2069.     mail_free_stringlist (&(*pgm)->keyword);
  2070.     mail_free_stringlist (&(*pgm)->subject);
  2071.     mail_free_stringlist (&(*pgm)->text);
  2072.     mail_free_stringlist (&(*pgm)->to);
  2073.     fs_give ((void **) pgm); /* return program to free storage */
  2074.   }
  2075. }
  2078. /* Mail garbage collect searchheader
  2079.  * Accepts: pointer to searchheader pointer
  2080.  */
  2082. void mail_free_searchheader (SEARCHHEADER **hdr)
  2083. {
  2084.   if (*hdr) { /* only free if exists */
  2085.     if ((*hdr)->line.data) fs_give ((void **) &(*hdr)->line.data);
  2086.     if ((*hdr)->text.data) fs_give ((void **) &(*hdr)->text.data);
  2087.     mail_free_searchheader (&(*hdr)->next);
  2088.     fs_give ((void **) hdr); /* return header to free storage */
  2089.   }
  2090. }
  2093. /* Mail garbage collect searchset
  2094.  * Accepts: pointer to searchset pointer
  2095.  */
  2097. void mail_free_searchset (SEARCHSET **set)
  2098. {
  2099.   if (*set) { /* only free if exists */
  2100.     mail_free_searchset (&(*set)->next);
  2101.     fs_give ((void **) set); /* return set to free storage */
  2102.   }
  2103. }
  2105. /* Mail garbage collect searchor
  2106.  * Accepts: pointer to searchor pointer
  2107.  */
  2109. void mail_free_searchor (SEARCHOR **orl)
  2110. {
  2111.   if (*orl) { /* only free if exists */
  2112.     mail_free_searchpgm (&(*orl)->first);
  2113.     mail_free_searchpgm (&(*orl)->second);
  2114.     mail_free_searchor (&(*orl)->next);
  2115.     fs_give ((void **) orl); /* return searchor to free storage */
  2116.   }
  2117. }
  2120. /* Mail garbage collect search program list
  2121.  * Accepts: pointer to searchpgmlist pointer
  2122.  */
  2124. void mail_free_searchpgmlist (SEARCHPGMLIST **pgl)
  2125. {
  2126.   if (*pgl) { /* only free if exists */
  2127.     mail_free_searchpgm (&(*pgl)->pgm);
  2128.     mail_free_searchpgmlist (&(*pgl)->next);
  2129.     fs_give ((void **) pgl); /* return searchpgmlist to free storage */
  2130.   }
  2131. }
  2134. /* Mail garbage collect namespace
  2135.  * Accepts: poiner to namespace
  2136.  */
  2138. void mail_free_namespace (NAMESPACE **n)
  2139. {
  2140.   if (*n) {
  2141.     fs_give ((void **) &(*n)->name);
  2142.     mail_free_namespace (&(*n)->next);
  2143.     mail_free_body_parameter (&(*n)->param);
  2144.     fs_give ((void **) n); /* return namespace to free storage */
  2145.   }
  2146. }
  2148. /* Mail garbage collect sort program
  2149.  * Accepts: pointer to sortpgm pointer
  2150.  */
  2152. void mail_free_sortpgm (SORTPGM **pgm)
  2153. {
  2154.   if (*pgm) { /* only free if exists */
  2155.     mail_free_sortpgm (&(*pgm)->next);
  2156.     fs_give ((void **) pgm); /* return sortpgm to free storage */
  2157.   }
  2158. }
  2161. /* Mail garbage collect thread node
  2162.  * Accepts: pointer to threadnode pointer
  2163.  */
  2165. void mail_free_threadnode (THREADNODE **thr)
  2166. {
  2167.   if (*thr) { /* only free if exists */
  2168.     mail_free_threadnode (&(*thr)->branch);
  2169.     mail_free_threadnode (&(*thr)->next);
  2170.     fs_give ((void **) thr); /* return threadnode to free storage */
  2171.   }
  2172. }
  2174. /* Link authenicator
  2175.  * Accepts: authenticator to add to list
  2176.  */
  2178. void auth_link (AUTHENTICATOR *auth)
  2179. {
  2180.   if (!auth->valid || (*auth->valid) ()) {
  2181.     AUTHENTICATOR **a = &mailauthenticators;
  2182.     while (*a) a = &(*a)->next; /* find end of list of authenticators */
  2183.     *a = auth; /* put authenticator at the end */
  2184.     auth->next = NIL; /* this authenticator is the end of the list */
  2185.   }
  2186. }
  2189. /* Authenticate access
  2190.  * Accepts: mechanism name
  2191.  *     responder function
  2192.  *     argument count
  2193.  *     argument vector
  2194.  * Returns: authenticated user name or NIL
  2195.  */
  2197. char *mail_auth (char *mechanism,authresponse_t resp,int argc,char *argv[])
  2198. {
  2199.   char tmp[MAILTMPLEN];
  2200.   AUTHENTICATOR *auth;
  2201. /* cretins still haven't given up */
  2202.   if (strlen (mechanism) >= MAILTMPLEN)
  2203.     syslog (LOG_ALERT|LOG_AUTH,"System break-in attempt, host=%.80s",
  2204.     tcp_clienthost ());
  2205.   else { /* make upper case copy of mechanism name */
  2206.     ucase (strcpy (tmp,mechanism));
  2207.     for (auth = mailauthenticators; auth; auth = auth->next)
  2208.       if (auth->server && !strcmp (auth->name,tmp))
  2209. return (*auth->server) (resp,argc,argv);
  2210.   }
  2211.   return NIL; /* no authenticator found */
  2212. }
  2214. /* Lookup authenticator index
  2215.  * Accepts: authenticator index
  2216.  * Returns: authenticator, or 0 if not found
  2217.  */
  2219. AUTHENTICATOR *mail_lookup_auth (unsigned long i)
  2220. {
  2221.   AUTHENTICATOR *auth = mailauthenticators;
  2222.   while (auth && --i) auth = auth->next;
  2223.   return auth;
  2224. }
  2227. /* Lookup authenticator name
  2228.  * Accepts: authenticator name
  2229.  *     security flag (non-zero to ignore non-secure authenticators)
  2230.  * Returns: index in authenticator chain, or 0 if not found
  2231.  */
  2233. unsigned int mail_lookup_auth_name (char *mechanism,long secflag)
  2234. {
  2235.   char tmp[MAILTMPLEN];
  2236.   int i;
  2237.   AUTHENTICATOR *auth;
  2238.   if (strlen (mechanism) < MAILTMPLEN) {
  2239. /* make upper case copy of mechanism name */
  2240.     ucase (strcpy (tmp,mechanism));
  2241.     for (i = 1, auth = mailauthenticators; auth; i++, auth = auth->next)
  2242.       if (auth->client && (!secflag || auth->secflag) &&
  2243.   !strcmp (auth->name,tmp)) return i;
  2244.   }
  2245.   return 0;
  2246. }
  2248. /* Standard TCP/IP network driver */
  2250. static NETDRIVER tcpdriver = {
  2251.   tcp_open, /* open connection */
  2252.   tcp_aopen, /* open preauthenticated connection */
  2253.   tcp_getline, /* get a line */
  2254.   tcp_getbuffer, /* get a buffer */
  2255.   tcp_soutr, /* output pushed data */
  2256.   tcp_sout, /* output string */
  2257.   tcp_close, /* close connection */
  2258.   tcp_host, /* return host name */
  2259.   tcp_remotehost, /* return remote host name */
  2260.   tcp_port, /* return port number */
  2261.   tcp_localhost /* return local host name */
  2262. };
  2265. /* Network open
  2266.  * Accepts: NETMBX specifier to open
  2267.  *     default network driver
  2268.  *     default port
  2269.  *     alternate network driver
  2270.  *     alternate driver service name
  2271.  *     alternate driver port
  2272.  * Returns: Network stream if success, else NIL
  2273.  */
  2275. NETSTREAM *net_open (NETMBX *mb,NETDRIVER *dv,unsigned long port,
  2276.      NETDRIVER *altd,char *alts,unsigned long altp)
  2277. {
  2278.   NETSTREAM *stream = NIL;
  2279.   char tmp[MAILTMPLEN];
  2280.   if (strlen (mb->host) >= NETMAXHOST) {
  2281.     sprintf (tmp,"Invalid host name: %.80s",mb->host);
  2282.     mm_log (tmp,ERROR);
  2283.   }
  2284. /* use designated driver if given */
  2285.   else if (dv) stream = net_open_work (dv,mb->host,mb->service,port,mb->port,
  2286.        NIL);
  2287.   else if (mb->altflag && altd) /* use alt if altflag lit */
  2288.     stream = net_open_work (altd,mb->host,alts,altp,mb->port,NIL);
  2289. /* if tryaltfirst and can open alt... */
  2290.   else if ((mb->tryaltflag || tryaltfirst) && altd &&
  2291.    (stream = net_open_work (altd,mb->host,alts,altp,mb->port,T)))
  2292.     mb->altflag = T; /* ...light altflag */
  2293. /* default to TCP driver */
  2294.   else stream = net_open_work (&tcpdriver,mb->host,mb->service,port,mb->port,
  2295.        NIL);
  2296.   return stream;
  2297. }
  2299. /* Network open worker routine
  2300.  * Accepts: network driver
  2301.  *     host name
  2302.  *     service name to look up port
  2303.  *     port number if service name not found
  2304.  *     port number to override service name
  2305.  *     flags (non-zero means silent failure)
  2306.  * Returns: Network stream if success, else NIL
  2307.  */
  2309. NETSTREAM *net_open_work (NETDRIVER *dv,char *host,char *service,
  2310.   unsigned long port,unsigned long portoverride,
  2311.   long flags)
  2312. {
  2313.   NETSTREAM *stream = NIL;
  2314.   void *tstream;
  2315.   if (portoverride) { /* explicit port number? */
  2316.     service = NIL; /* yes, override service name */
  2317.     port = portoverride; /* use that instead of default port */
  2318.   }
  2319.   if (flags) port |= 0x80000000;/* want silent open? */
  2320.   if (tstream = (*dv->open) (host,service,port)) {
  2321.     stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM));
  2322.     stream->stream = tstream;
  2323.     stream->dtb = dv;
  2324.   }
  2325.   return stream;
  2326. }
  2329. /* Network authenticated open
  2330.  * Accepts: network driver
  2331.  *     NETMBX specifier
  2332.  *     service specifier
  2333.  *     return user name buffer
  2334.  * Returns: Network stream if success else NIL
  2335.  */
  2337. NETSTREAM *net_aopen (NETDRIVER *dv,NETMBX *mb,char *service,char *user)
  2338. {
  2339.   NETSTREAM *stream = NIL;
  2340.   void *tstream;
  2341.   if (!dv) dv = &tcpdriver; /* default to TCP driver */
  2342.   if (tstream = (*dv->aopen) (mb,service,user)) {
  2343.     stream = (NETSTREAM *) fs_get (sizeof (NETSTREAM));
  2344.     stream->stream = tstream;
  2345.     stream->dtb = dv;
  2346.   }
  2347.   return stream;
  2348. }
  2350. /* Network receive line
  2351.  * Accepts: Network stream
  2352.  * Returns: text line string or NIL if failure
  2353.  */
  2355. char *net_getline (NETSTREAM *stream)
  2356. {
  2357.   return (*stream->dtb->getline) (stream->stream);
  2358. }
  2361. /* Network receive buffer
  2362.  * Accepts: Network stream (must be void * for use as readfn_t)
  2363.  *     size in bytes
  2364.  *     buffer to read into
  2365.  * Returns: T if success, NIL otherwise
  2366.  */
  2368. long net_getbuffer (void *st,unsigned long size,char *buffer)
  2369. {
  2370.   NETSTREAM *stream = (NETSTREAM *) st;
  2371.   return (*stream->dtb->getbuffer) (stream->stream,size,buffer);
  2372. }
  2375. /* Network send null-terminated string
  2376.  * Accepts: Network stream
  2377.  *     string pointer
  2378.  * Returns: T if success else NIL
  2379.  */
  2381. long net_soutr (NETSTREAM *stream,char *string)
  2382. {
  2383.   return (*stream->dtb->soutr) (stream->stream,string);
  2384. }
  2387. /* Network send string
  2388.  * Accepts: Network stream
  2389.  *     string pointer
  2390.  *     byte count
  2391.  * Returns: T if success else NIL
  2392.  */
  2394. long net_sout (NETSTREAM *stream,char *string,unsigned long size)
  2395. {
  2396.   return (*stream->dtb->sout) (stream->stream,string,size);
  2397. }
  2399. /* Network close
  2400.  * Accepts: Network stream
  2401.  */
  2403. void net_close (NETSTREAM *stream)
  2404. {
  2405.   (*stream->dtb->close) (stream->stream);
  2406.   fs_give ((void **) &stream);
  2407. }
  2410. /* Network get host name
  2411.  * Accepts: Network stream
  2412.  * Returns: host name for this stream
  2413.  */
  2415. char *net_host (NETSTREAM *stream)
  2416. {
  2417.   return (*stream->dtb->host) (stream->stream);
  2418. }
  2421. /* Network get remote host name
  2422.  * Accepts: Network stream
  2423.  * Returns: host name for this stream
  2424.  */
  2426. char *net_remotehost (NETSTREAM *stream)
  2427. {
  2428.   return (*stream->dtb->remotehost) (stream->stream);
  2429. }
  2431. /* Network return port for this stream
  2432.  * Accepts: Network stream
  2433.  * Returns: port number for this stream
  2434.  */
  2436. unsigned long net_port (NETSTREAM *stream)
  2437. {
  2438.   return (*stream->dtb->port) (stream->stream);
  2439. }
  2442. /* Network get local host name
  2443.  * Accepts: Network stream
  2444.  * Returns: local host name
  2445.  */
  2447. char *net_localhost (NETSTREAM *stream)
  2448. {
  2449.   return (*stream->dtb->localhost) (stream->stream);
  2450. }