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

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

网络编程

开发平台：

Unix_Linux

imap4r1.c：源码内容
  1.  * Returns: parsed reply
  2.  */
  4. #define MAXSEQUENCE 1000
  6. IMAPPARSEDREPLY *imap_send (MAILSTREAM *stream,char *cmd,IMAPARG *args[])
  7. {
  8.   IMAPPARSEDREPLY *reply;
  9.   IMAPARG *arg,**arglst;
  10.   SORTPGM *spg;
  11.   STRINGLIST *list;
  12.   SIZEDTEXT st;
  13.   char c,*s,*t,tag[10];
  14.    /* gensym a new tag */
  15.   sprintf (tag,"%08lx",stream->gensym++);
  16.   if (!LOCAL->netstream) return imap_fake (stream,tag,"No-op dead stream");
  17.   mail_lock (stream); /* lock up the stream */
  18. /* ignored referral from previous command */
  19.   if (LOCAL->referral) fs_give ((void **) &LOCAL->referral);
  20.   sprintf (LOCAL->tmp,"%s ",tag);
  21.   for (t = cmd, s = LOCAL->tmp + 9; *t; *s++ = *t++);
  22.   if (arglst = args) while (arg = *arglst++) {
  23.     *s++ = ' '; /* delimit argument with space */
  24.     switch (arg->type) {
  25.     case ATOM: /* atom */
  26.       for (t = (char *) arg->text; *t; *s++ = *t++);
  27.       break;
  28.     case NUMBER: /* number */
  29.       sprintf (s,"%lu",(unsigned long) arg->text);
  30.       s += strlen (s);
  31.       break;
  32.     case FLAGS: /* flag list as a single string */
  33.       if (*(t = (char *) arg->text) != '(') {
  34. *s++ = '('; /* wrap parens around string */
  35. while (*t) *s++ = *t++;
  36. *s++ = ')'; /* wrap parens around string */
  37.       }
  38.       else while (*t) *s++ = *t++;
  39.       break;
  40.     case ASTRING: /* atom or string, must be literal? */
  41.       st.size = strlen ((char *) (st.data = (unsigned char *) arg->text));
  42.       if (reply = imap_send_astring (stream,tag,&s,&st,NIL)) return reply;
  43.       break;
  44.     case LITERAL: /* literal, as a stringstruct */
  45.       if (reply = imap_send_literal (stream,tag,&s,arg->text)) return reply;
  46.       break;
  48.     case LIST: /* list of strings */
  49.       list = (STRINGLIST *) arg->text;
  50.       c = '('; /* open paren */
  51.       do { /* for each list item */
  52. *s++ = c; /* write prefix character */
  53. if (reply = imap_send_astring (stream,tag,&s,&list->text,NIL))
  54.   return reply;
  55. c = ' '; /* prefix character for subsequent strings */
  56.       }
  57.       while (list = list->next);
  58.       *s++ = ')'; /* close list */
  59.       break;
  60.     case SEARCHPROGRAM: /* search program */
  61.       if (reply = imap_send_spgm (stream,tag,&s,arg->text)) return reply;
  62.       break;
  63.     case SORTPROGRAM: /* search program */
  64.       c = '('; /* open paren */
  65.       for (spg = (SORTPGM *) arg->text; spg; spg = spg->next) {
  66. *s++ = c; /* write prefix */
  67. if (spg->reverse) for (t = "REVERSE "; *t; *s++ = *t++);
  68. switch (spg->function) {
  69. case SORTDATE:
  70.   for (t = "DATE"; *t; *s++ = *t++);
  71.   break;
  72. case SORTARRIVAL:
  73.   for (t = "ARRIVAL"; *t; *s++ = *t++);
  74.   break;
  75. case SORTFROM:
  76.   for (t = "FROM"; *t; *s++ = *t++);
  77.   break;
  78. case SORTSUBJECT:
  79.   for (t = "SUBJECT"; *t; *s++ = *t++);
  80.   break;
  81. case SORTTO:
  82.   for (t = "TO"; *t; *s++ = *t++);
  83.   break;
  84. case SORTCC:
  85.   for (t = "CC"; *t; *s++ = *t++);
  86.   break;
  87. case SORTSIZE:
  88.   for (t = "SIZE"; *t; *s++ = *t++);
  89.   break;
  90. default:
  91.   fatal ("Unknown sort program function in imap_send()!");
  92. }
  93. c = ' '; /* prefix character for subsequent items */
  94.       }
  95.       *s++ = ')'; /* close list */
  96.       break;
  98.     case BODYTEXT: /* body section */
  99.       for (t = "BODY["; *t; *s++ = *t++);
  100.       for (t = (char *) arg->text; *t; *s++ = *t++);
  101.       break;
  102.     case BODYPEEK: /* body section */
  103.       for (t = "BODY.PEEK["; *t; *s++ = *t++);
  104.       for (t = (char *) arg->text; *t; *s++ = *t++);
  105.       break;
  106.     case BODYCLOSE: /* close bracket and possible length */
  107.       s[-1] = ']'; /* no leading space */
  108.       for (t = (char *) arg->text; *t; *s++ = *t++);
  109.       break;
  110.     case SEQUENCE: /* sequence */
  111.       while (t = (strlen ((char *) arg->text) > (size_t) MAXSEQUENCE) ?
  112.      strchr (((char *) arg->text) + MAXSEQUENCE - 20,',') : NIL) {
  113. *t = ''; /* tie off sequence */
  114. mail_unlock (stream); /* unlock stream, recurse to do part */
  115. imap_send (stream,cmd,args);
  116. mail_lock (stream); /* lock up stream again */
  117. /* rewrite the tag */
  118. memcpy (LOCAL->tmp,tag,8);
  119. *t++ = ','; /* restore the comma */
  120. arg->text = (void *) t; /* now do rest of data */
  121.       }
  122. /* falls through */
  123.     case LISTMAILBOX: /* astring with wildcards */
  124.       st.size = strlen ((char *) (st.data = (unsigned char *) arg->text));
  125.       if (reply = imap_send_astring (stream,tag,&s,&st,T)) return reply;
  126.       break;
  127.     default:
  128.       fatal ("Unknown argument type in imap_send()!");
  129.     }
  130.   }
  131. /* send the command */
  132.   reply = imap_sout (stream,tag,LOCAL->tmp,&s);
  133.   mail_unlock (stream); /* unlock stream */
  134.   return reply;
  135. }
  137. /* IMAP send atom-string
  138.  * Accepts: MAIL stream
  139.  *     reply tag
  140.  *     pointer to current position pointer of output bigbuf
  141.  *     atom-string to output
  142.  *     flag if list_wildcards allowed
  143.  * Returns: error reply or NIL if success
  144.  */
  146. IMAPPARSEDREPLY *imap_send_astring (MAILSTREAM *stream,char *tag,char **s,
  147.     SIZEDTEXT *as,long wildok)
  148. {
  149.   unsigned long j;
  150.   char c;
  151.   STRING st;
  152. /* default to not quoted unless empty */
  153.   int qflag = as->size ? NIL : T;
  154.   for (j = 0; j < as->size; j++) switch (c = as->data[j]) {
  155.   default: /* all other characters */
  156.     if (!(c & 0x80)) { /* must not be 8bit */
  157.       if (c <= ' ') qflag = T; /* must quote if a CTL */
  158.       break;
  159.     }
  160.   case '': /* not a CHAR */
  161.   case '12': case '15': /* not a TEXT-CHAR */
  162.   case '"': case '\': /* quoted-specials (IMAP2 required this) */
  163.     INIT (&st,mail_string,(void *) as->data,as->size);
  164.     return imap_send_literal (stream,tag,s,&st);
  165.   case '*': case '%': /* list_wildcards */
  166.     if (wildok) break; /* allowed if doing the wild thing */
  167. /* atom_specials */
  168.   case '(': case ')': case '{': case ' ': case 0x7f:
  169. #if 0
  170.   case '"': case '\': /* quoted-specials (could work in IMAP4) */
  171. #endif
  172.     qflag = T; /* must use quoted string format */
  173.     break;
  174.   }
  175.   if (qflag) *(*s)++ = '"'; /* write open quote */
  176.   for (j = 0; j < as->size; j++) *(*s)++ = as->data[j];
  177.   if (qflag) *(*s)++ = '"'; /* write close quote */
  178.   return NIL;
  179. }
  181. /* IMAP send literal
  182.  * Accepts: MAIL stream
  183.  *     reply tag
  184.  *     pointer to current position pointer of output bigbuf
  185.  *     literal to output as stringstruct
  186.  * Returns: error reply or NIL if success
  187.  */
  189. IMAPPARSEDREPLY *imap_send_literal (MAILSTREAM *stream,char *tag,char **s,
  190.     STRING *st)
  191. {
  192.   IMAPPARSEDREPLY *reply;
  193.   unsigned long i = SIZE (st);
  194.   sprintf (*s,"{%lu}",i); /* write literal count */
  195.   *s += strlen (*s); /* size of literal count */
  196. /* send the command */
  197.   reply = imap_sout (stream,tag,LOCAL->tmp,s);
  198.   if (strcmp (reply->tag,"+")) {/* prompt for more data? */
  199.     mail_unlock (stream); /* no, give up */
  200.     return reply;
  201.   }
  202.   while (i) { /* dump the text */
  203.     if (!net_sout (LOCAL->netstream,st->curpos,st->cursize)) {
  204.       mail_unlock (stream);
  205.       return imap_fake (stream,tag,"IMAP connection broken (data)");
  206.     }
  207.     i -= st->cursize; /* note that we wrote out this much */
  208.     st->curpos += (st->cursize - 1);
  209.     st->cursize = 0;
  210.     (*st->dtb->next) (st); /* advance to next buffer's worth */
  211.   }
  212.   return NIL; /* success */
  213. }
  215. /* IMAP send search program
  216.  * Accepts: MAIL stream
  217.  *     reply tag
  218.  *     pointer to current position pointer of output bigbuf
  219.  *     search program to output
  220.  * Returns: error reply or NIL if success
  221.  */
  223. IMAPPARSEDREPLY *imap_send_spgm (MAILSTREAM *stream,char *tag,char **s,
  224.  SEARCHPGM *pgm)
  225. {
  226.   IMAPPARSEDREPLY *reply;
  227.   SEARCHHEADER *hdr;
  228.   SEARCHOR *pgo;
  229.   SEARCHPGMLIST *pgl;
  230.   char *t = "ALL";
  231.   while (*t) *(*s)++ = *t++; /* default initial text */
  232. /* message sequences */
  233.   if (pgm->msgno) imap_send_sset (s,pgm->msgno);
  234.   if (pgm->uid) { /* UID sequence */
  235.     for (t = " UID"; *t; *(*s)++ = *t++);
  236.     imap_send_sset (s,pgm->uid);
  237.   }
  238. /* message sizes */
  239.   if (pgm->larger) {
  240.     sprintf (*s," LARGER %lu",pgm->larger);
  241.     *s += strlen (*s);
  242.   }
  243.   if (pgm->smaller) {
  244.     sprintf (*s," SMALLER %lu",pgm->smaller);
  245.     *s += strlen (*s);
  246.   }
  247. /* message flags */
  248.   if (pgm->answered) for (t = " ANSWERED"; *t; *(*s)++ = *t++);
  249.   if (pgm->unanswered) for (t =" UNANSWERED"; *t; *(*s)++ = *t++);
  250.   if (pgm->deleted) for (t =" DELETED"; *t; *(*s)++ = *t++);
  251.   if (pgm->undeleted) for (t =" UNDELETED"; *t; *(*s)++ = *t++);
  252.   if (pgm->draft) for (t =" DRAFT"; *t; *(*s)++ = *t++);
  253.   if (pgm->undraft) for (t =" UNDRAFT"; *t; *(*s)++ = *t++);
  254.   if (pgm->flagged) for (t =" FLAGGED"; *t; *(*s)++ = *t++);
  255.   if (pgm->unflagged) for (t =" UNFLAGGED"; *t; *(*s)++ = *t++);
  256.   if (pgm->recent) for (t =" RECENT"; *t; *(*s)++ = *t++);
  257.   if (pgm->old) for (t =" OLD"; *t; *(*s)++ = *t++);
  258.   if (pgm->seen) for (t =" SEEN"; *t; *(*s)++ = *t++);
  259.   if (pgm->unseen) for (t =" UNSEEN"; *t; *(*s)++ = *t++);
  260.   if ((pgm->keyword && /* keywords */
  261.        (reply = imap_send_slist (stream,tag,s,"KEYWORD",pgm->keyword))) ||
  262.       (pgm->unkeyword &&
  263.        (reply = imap_send_slist (stream,tag,s,"UNKEYWORD",pgm->unkeyword))))
  264.     return reply;
  266. /* sent date ranges */
  267.   if (pgm->sentbefore) imap_send_sdate (s,"SENTBEFORE",pgm->sentbefore);
  268.   if (pgm->senton) imap_send_sdate (s,"SENTON",pgm->senton);
  269.   if (pgm->sentsince) imap_send_sdate (s,"SENTSINCE",pgm->sentsince);
  270. /* internal date ranges */
  271.   if (pgm->before) imap_send_sdate (s,"BEFORE",pgm->before);
  272.   if (pgm->on) imap_send_sdate (s,"ON",pgm->on);
  273.   if (pgm->since) imap_send_sdate (s,"SINCE",pgm->since);
  274. /* search texts */
  275.   if ((pgm->bcc && (reply = imap_send_slist (stream,tag,s,"BCC",pgm->bcc))) ||
  276.       (pgm->cc && (reply = imap_send_slist (stream,tag,s,"CC",pgm->cc))) ||
  277.       (pgm->from && (reply = imap_send_slist(stream,tag,s,"FROM",pgm->from)))||
  278.       (pgm->to && (reply = imap_send_slist (stream,tag,s,"TO",pgm->to))))
  279.     return reply;
  280.   if ((pgm->subject &&
  281.        (reply = imap_send_slist (stream,tag,s,"SUBJECT",pgm->subject))) ||
  282.       (pgm->body && (reply = imap_send_slist(stream,tag,s,"BODY",pgm->body)))||
  283.       (pgm->text && (reply = imap_send_slist (stream,tag,s,"TEXT",pgm->text))))
  284.     return reply;
  286.   /* Note that these criteria are not supported by IMAP and have to be
  287.      emulated */
  288.   if ((pgm->return_path &&
  289.        (reply = imap_send_slist (stream,tag,s,"HEADER Return-Path",
  290.  pgm->return_path))) ||
  291.       (pgm->sender &&
  292.        (reply = imap_send_slist (stream,tag,s,"HEADER Sender",pgm->sender))) ||
  293.       (pgm->reply_to &&
  294.        (reply = imap_send_slist (stream,tag,s,"HEADER Reply-To",
  295.  pgm->reply_to))) ||
  296.       (pgm->in_reply_to &&
  297.        (reply = imap_send_slist (stream,tag,s,"HEADER In-Reply-To",
  298.  pgm->in_reply_to))) ||
  299.       (pgm->message_id &&
  300.        (reply = imap_send_slist (stream,tag,s,"HEADER Message-ID",
  301.  pgm->message_id))) ||
  302.       (pgm->newsgroups &&
  303.        (reply = imap_send_slist (stream,tag,s,"HEADER Newsgroups",
  304.  pgm->newsgroups))) ||
  305.       (pgm->followup_to &&
  306.        (reply = imap_send_slist (stream,tag,s,"HEADER Followup-To",
  307.  pgm->followup_to))) ||
  308.       (pgm->references &&
  309.        (reply = imap_send_slist (stream,tag,s,"HEADER References",
  310.  pgm->references)))) return reply;
  311. /* all other headers */
  312.   if (hdr = pgm->header) do {
  313.     for (t = " HEADER "; *t; *(*s)++ = *t++);
  314.     if (reply = imap_send_astring (stream,tag,s,&hdr->line,NIL)) return reply;
  315.     *(*s)++ = ' ';
  316.     if (reply = imap_send_astring (stream,tag,s,&hdr->text,NIL)) return reply;
  317.   }
  318.   while (hdr = hdr->next);
  319.   for (pgo = pgm->or; pgo; pgo = pgo->next) {
  320.     for (t = " OR ("; *t; *(*s)++ = *t++);
  321.     if (reply = imap_send_spgm (stream,tag,s,pgo->first)) return reply;
  322.     for (t = ") ("; *t; *(*s)++ = *t++);
  323.     if (reply = imap_send_spgm (stream,tag,s,pgo->second)) return reply;
  324.     *(*s)++ = ')';
  325.   }
  326.   for (pgl = pgm->not; pgl; pgl = pgl->next) {
  327.     for (t = " NOT ("; *t; *(*s)++ = *t++);
  328.     if (reply = imap_send_spgm (stream,tag,s,pgl->pgm)) return reply;
  329.     *(*s)++ = ')';
  330.   }
  331.   return NIL; /* search program written OK */
  332. }
  334. /* IMAP send search set
  335.  * Accepts: pointer to current position pointer of output bigbuf
  336.  *     search set to output
  337.  */
  339. void imap_send_sset (char **s,SEARCHSET *set)
  340. {
  341.   char c = ' ';
  342.   do { /* run down search set */
  343.     sprintf (*s,set->last ? "%c%ld:%ld" : "%c%ld",c,set->first,set->last);
  344.     *s += strlen (*s);
  345.     c = ','; /* if there are any more */
  346.   }
  347.   while (set = set->next);
  348. }
  351. /* IMAP send search list
  352.  * Accepts: MAIL stream
  353.  *     reply tag
  354.  *     pointer to current position pointer of output bigbuf
  355.  *     name of search list
  356.  *     search list to output
  357.  * Returns: NIL if success, error reply if error
  358.  */
  360. IMAPPARSEDREPLY *imap_send_slist (MAILSTREAM *stream,char *tag,char **s,
  361.   char *name,STRINGLIST *list)
  362. {
  363.   char *t;
  364.   IMAPPARSEDREPLY *reply;
  365.   do {
  366.     *(*s)++ = ' '; /* output name of search list */
  367.     for (t = name; *t; *(*s)++ = *t++);
  368.     *(*s)++ = ' ';
  369.     reply = imap_send_astring (stream,tag,s,&list->text,NIL);
  370.   }
  371.   while (!reply && (list = list->next));
  372.   return reply;
  373. }
  376. /* IMAP send search date
  377.  * Accepts: pointer to current position pointer of output bigbuf
  378.  *     field name
  379.  *     search date to output
  380.  */
  382. void imap_send_sdate (char **s,char *name,unsigned short date)
  383. {
  384.   sprintf (*s," %s %2d-%s-%d",name,date & 0x1f,
  385.    months[((date >> 5) & 0xf) - 1],BASEYEAR + (date >> 9));
  386.   *s += strlen (*s);
  387. }
  389. /* IMAP send buffered command to sender
  390.  * Accepts: MAIL stream
  391.  *     reply tag
  392.  *     string
  393.  *     pointer to string tail pointer
  394.  * Returns: reply
  395.  */
  397. IMAPPARSEDREPLY *imap_sout (MAILSTREAM *stream,char *tag,char *base,char **s)
  398. {
  399.   IMAPPARSEDREPLY *reply;
  400.   if (stream->debug) { /* output debugging telemetry */
  401.     **s = '';
  402.     mm_dlog (base);
  403.   }
  404.   *(*s)++ = '15'; /* append CRLF */
  405.   *(*s)++ = '12';
  406.   **s = '';
  407.   reply = net_sout (LOCAL->netstream,base,*s - base) ?
  408.     imap_reply (stream,tag) :
  409.       imap_fake (stream,tag,"IMAP connection broken (command)");
  410.   *s = base; /* restart buffer */
  411.   return reply;
  412. }
  415. /* IMAP send null-terminated string to sender
  416.  * Accepts: MAIL stream
  417.  *     string
  418.  * Returns: T if success, else NIL
  419.  */
  421. long imap_soutr (MAILSTREAM *stream,char *string)
  422. {
  423.   char tmp[MAILTMPLEN];
  424.   if (stream->debug) mm_dlog (string);
  425.   sprintf (tmp,"%s1512",string);
  426.   return net_soutr (LOCAL->netstream,tmp);
  427. }
  429. /* IMAP get reply
  430.  * Accepts: MAIL stream
  431.  *     tag to search or NIL if want a greeting
  432.  * Returns: parsed reply, never NIL
  433.  */
  435. IMAPPARSEDREPLY *imap_reply (MAILSTREAM *stream,char *tag)
  436. {
  437.   IMAPPARSEDREPLY *reply;
  438.   while (LOCAL->netstream) { /* parse reply from server */
  439.     if (reply = imap_parse_reply (stream,net_getline (LOCAL->netstream))) {
  440. /* continuation ready? */
  441.       if (!strcmp (reply->tag,"+")) return reply;
  442. /* untagged data? */
  443.       else if (!strcmp (reply->tag,"*")) {
  444. imap_parse_unsolicited (stream,reply);
  445. if (!tag) return reply; /* return if just wanted greeting */
  446.       }
  447.       else { /* tagged data */
  448. if (tag && !strcmp (tag,reply->tag)) return reply;
  449. /* report bogon */
  450. sprintf (LOCAL->tmp,"Unexpected tagged response: %.80s %.80s %.80s",
  451.  reply->tag,reply->key,reply->text);
  452. mm_log (LOCAL->tmp,WARN);
  453.       }
  454.     }
  455.   }
  456.   return imap_fake (stream,tag,"IMAP connection broken (server response)");
  457. }
  459. /* IMAP parse reply
  460.  * Accepts: MAIL stream
  461.  *     text of reply
  462.  * Returns: parsed reply, or NIL if can't parse at least a tag and key
  463.  */
  466. IMAPPARSEDREPLY *imap_parse_reply (MAILSTREAM *stream,char *text)
  467. {
  468.   if (LOCAL->reply.line) fs_give ((void **) &LOCAL->reply.line);
  469. /* init fields in case error */
  470.   LOCAL->reply.key = LOCAL->reply.text = LOCAL->reply.tag = NIL;
  471.   if (!(LOCAL->reply.line = text)) {
  472. /* NIL text means the stream died */
  473.     if (LOCAL->netstream) net_close (LOCAL->netstream);
  474.     LOCAL->netstream = NIL;
  475.     return NIL;
  476.   }
  477.   if (stream->debug) mm_dlog (LOCAL->reply.line);
  478.   if (!(LOCAL->reply.tag = (char *) strtok (LOCAL->reply.line," "))) {
  479.     mm_log ("IMAP server sent a blank line",WARN);
  480.     return NIL;
  481.   }
  482. /* non-continuation replies */
  483.   if (strcmp (LOCAL->reply.tag,"+")) {
  484. /* parse key */
  485.     if (!(LOCAL->reply.key = (char *) strtok (NIL," "))) {
  486. /* determine what is missing */
  487.       sprintf (LOCAL->tmp,"Missing IMAP reply key: %.80s",LOCAL->reply.tag);
  488.       mm_log (LOCAL->tmp,WARN); /* pass up the barfage */
  489.       return NIL; /* can't parse this text */
  490.     }
  491.     ucase (LOCAL->reply.key); /* make sure key is upper case */
  492. /* get text as well, allow empty text */
  493.     if (!(LOCAL->reply.text = (char *) strtok (NIL,"n")))
  494.       LOCAL->reply.text = LOCAL->reply.key + strlen (LOCAL->reply.key);
  495.   }
  496.   else { /* special handling of continuation */
  497.     LOCAL->reply.key = "BAD"; /* so it barfs if not expecting continuation */
  498.     if (!(LOCAL->reply.text = (char *) strtok (NIL,"n")))
  499.       LOCAL->reply.text = "";
  500.   }
  501.   return &LOCAL->reply; /* return parsed reply */
  502. }
  504. /* IMAP fake reply
  505.  * Accepts: MAIL stream
  506.  *     tag
  507.  *     text of fake reply
  508.  * Returns: parsed reply
  509.  */
  511. IMAPPARSEDREPLY *imap_fake (MAILSTREAM *stream,char *tag,char *text)
  512. {
  513.   mm_notify (stream,text,BYE); /* send bye alert */
  514.   if (LOCAL->netstream) net_close (LOCAL->netstream);
  515.   LOCAL->netstream = NIL; /* farewell, dear NET stream... */
  516. /* build fake reply string */
  517.   sprintf (LOCAL->tmp,"%s NO [CLOSED] %s",tag ? tag : "*",text);
  518. /* parse and return it */
  519.   return imap_parse_reply (stream,cpystr (LOCAL->tmp));
  520. }
  523. /* IMAP check for OK response in tagged reply
  524.  * Accepts: MAIL stream
  525.  *     parsed reply
  526.  * Returns: T if OK else NIL
  527.  */
  529. long imap_OK (MAILSTREAM *stream,IMAPPARSEDREPLY *reply)
  530. {
  531.   long ret = NIL;
  532. /* OK - operation succeeded */
  533.   if (!strcmp (reply->key,"OK") ||
  534.       (!strcmp (reply->tag,"*") && !strcmp (reply->key,"PREAUTH"))) {
  535.     imap_parse_response (stream,reply->text,NIL,NIL);
  536.     ret = T;
  537.   }
  538. /* NO - operation failed */
  539.   else if (!strcmp (reply->key,"NO"))
  540.     imap_parse_response (stream,reply->text,WARN,NIL);
  541.   else { /* BAD - operation rejected */
  542.     if (!strcmp (reply->key,"BAD")) {
  543.       imap_parse_response (stream,reply->text,ERROR,NIL);
  544.       sprintf (LOCAL->tmp,"IMAP protocol error: %.80s",reply->text);
  545.     }
  546. /* bad protocol received */
  547.     else sprintf (LOCAL->tmp,"Unexpected IMAP response: %.80s %.80s",
  548.   reply->key,reply->text);
  549.     mm_log (LOCAL->tmp,ERROR); /* either way, this is not good */
  550.   }
  551.   return ret;
  552. }
  554. /* IMAP parse and act upon unsolicited reply
  555.  * Accepts: MAIL stream
  556.  *     parsed reply
  557.  */
  559. void imap_parse_unsolicited (MAILSTREAM *stream,IMAPPARSEDREPLY *reply)
  560. {
  561.   unsigned long i = 0;
  562.   unsigned long msgno;
  563.   char *s,*t;
  564.   if (isdigit (*reply->key)) { /* see if key is a number */
  565.     msgno = strtoul (reply->key,&s,10);
  566.     if (*s) { /* better be nothing after number */
  567.       sprintf (LOCAL->tmp,"Unexpected untagged message: %.80s",reply->key);
  568.       mm_log (LOCAL->tmp,WARN);
  569.       return;
  570.     }
  571.     if (!reply->text) { /* better be some data */
  572.       mm_log ("Missing message data",WARN);
  573.       return;
  574.     }
  575. /* get keyword */
  576.     s = ucase ((char *) strtok (reply->text," "));
  577. /* and locate the text after it */
  578.     t = (char *) strtok (NIL,"n");
  579. /* now take the action */
  580. /* change in size of mailbox */
  581.     if (!strcmp (s,"EXISTS")) mail_exists (stream,msgno);
  582.     else if (!strcmp (s,"RECENT")) mail_recent (stream,msgno);
  583.     else if (!strcmp (s,"EXPUNGE") && msgno && (msgno <= stream->nmsgs)) {
  584.       mailcache_t mc = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL);
  585.       MESSAGECACHE *elt = (MESSAGECACHE *) (*mc) (stream,msgno,CH_ELT);
  586.       if (elt) imap_gc_body (elt->private.msg.body);
  587. /* notify upper level */
  588.       mail_expunged (stream,msgno);
  589.     }
  591.     else if ((!strcmp (s,"FETCH") || !strcmp (s,"STORE")) &&
  592.      msgno && (msgno <= stream->nmsgs)) {
  593.       char *prop;
  594.       GETS_DATA md;
  595.       ENVELOPE **e;
  596.       MESSAGECACHE *elt = mail_elt (stream,msgno);
  597.       ENVELOPE *env = NIL;
  598.       imapenvelope_t ie =
  599. (imapenvelope_t) mail_parameters (stream,GET_IMAPENVELOPE,NIL);
  600.       ++t; /* skip past open parenthesis */
  601. /* parse Lisp-form property list */
  602.       while (prop = ((char *) strtok (t," )"))) {
  603. t = (char *) strtok (NIL,"n");
  604. INIT_GETS (md,stream,elt->msgno,NIL,0,0);
  605. e = NIL; /* not pointing at any envelope yet */
  606. /* parse the property and its value */
  607. if (!strcmp (ucase (prop),"FLAGS")) imap_parse_flags (stream,elt,&t);
  608. else if (!strcmp (prop,"INTERNALDATE") &&
  609.  (s = imap_parse_string (stream,&t,reply,NIL,NIL))) {
  610.   if (!mail_parse_date (elt,s)) {
  611.     sprintf (LOCAL->tmp,"Bogus date: %.80s",s);
  612.     mm_log (LOCAL->tmp,WARN);
  613.   }
  614.   fs_give ((void **) &s);
  615. }
  616. else if (!strcmp (prop,"UID")) /* unique identifier */
  617.   elt->private.uid = strtoul (t,&t,10);
  618. else if (!strcmp (prop,"ENVELOPE")) {
  619.   if (stream->scache) { /* short cache, flush old stuff */
  620.     mail_free_body (&stream->body);
  621.     stream->msgno = elt->msgno;
  622.     e = &stream->env; /* get pointer to envelope */
  623.   }
  624.   else e = &elt->private.msg.env;
  625.   imap_parse_envelope (stream,e,&t,reply);
  626. }
  627. else if (!strncmp (prop,"BODY",4)) {
  628.   if (!prop[4] || !strcmp (prop+4,"STRUCTURE")) {
  629.     BODY **body;
  630.     if (stream->scache){/* short cache, flush old stuff */
  631.       if (stream->msgno != msgno) {
  632. mail_free_envelope (&stream->env);
  633. sprintf (LOCAL->tmp,"Body received for %lu but current is %lu",
  634.  msgno,stream->msgno);
  635. stream->msgno = msgno;
  636.       }
  637. /* get pointer to body */
  638.       body = &stream->body;
  639.     }
  640.     else body = &elt->private.msg.body;
  641. /* flush any prior body */
  642.     mail_free_body (body);
  643. /* instantiate and parse a new body */
  644.     imap_parse_body_structure (stream,*body = mail_newbody(),&t,reply);
  645.   }
  647.   else if (prop[4] == '[') {
  648.     STRINGLIST *stl = NIL;
  649.     SIZEDTEXT text;
  650. /* will want to return envelope data */
  651.     if (!strcmp (md.what = cpystr (prop + 5),"HEADER]") ||
  652. !strcmp (md.what,"0]"))
  653.       e = stream->scache ? &stream->env : &elt->private.msg.env;
  654.     LOCAL->tmp[0] ='';/* no errors yet */
  655. /* found end of section? */
  656.     if (!(s = strchr (md.what,']'))) {
  657. /* skip leading nesting */
  658.       for (s = md.what; *s && (isdigit (*s) || (*s == '.')); s++);
  659. /* better be one of these */
  660.       if (strncmp (s,"HEADER.FIELDS",13) &&
  661.   (!s[13] || strcmp (s+13,".NOT")))
  662. sprintf (LOCAL->tmp,"Unterminated section: %.80s",md.what);
  663. /* get list of headers */
  664.       else if (!(stl = imap_parse_stringlist (stream,&t,reply)))
  665. sprintf (LOCAL->tmp,"Bogus header field list: %.80s",t);
  666.       else if (*t != ']')
  667. sprintf (LOCAL->tmp,"Unterminated header section: %.80s",t);
  668. /* point after the text */
  669.       else if (t = strchr (s = t,' ')) *t++ = '';
  670.     }
  671.     if (s && !LOCAL->tmp[0]) {
  672.       *s++ = ''; /* tie off section specifier */
  673.       if (*s == '<') { /* partial specifier? */
  674. md.first = strtoul (s+1,&s,10) + 1;
  675. if (*s++ != '>') /* make sure properly terminated */
  676.   sprintf (LOCAL->tmp,"Unterminated partial data: %.80s",s-1);
  677.       }
  678.       if (!LOCAL->tmp[0] && *s)
  679. sprintf (LOCAL->tmp,"Junk after section: %.80s",s);
  680.     }
  681.     if (LOCAL->tmp[0]) { /* got any errors? */
  682.       mm_log (LOCAL->tmp,WARN);
  683.       mail_free_stringlist (&stl);
  684.     }
  685.     else { /* parse text from server */
  686.       text.data = (unsigned char *)
  687. imap_parse_string (stream,&t,reply,
  688.    ((md.what[0] && (md.what[0] != 'H')) ||
  689.     md.first || md.last) ? &md : NIL,
  690.    &text.size);
  691. /* all done if partial */
  692.       if (md.first || md.last) mail_free_stringlist (&stl);
  693. /* otherwise register it in the cache */
  694.       else imap_cache (stream,msgno,md.what,stl,&text);
  695.     }
  696.     fs_give ((void **) &md.what);
  697.   }
  698.   else {
  699.     sprintf (LOCAL->tmp,"Unknown body message property: %.80s",prop);
  700.     mm_log (LOCAL->tmp,WARN);
  701.   }
  702. }
  704. /* one of the RFC822 props? */
  705. else if (!strncmp (prop,"RFC822",6) && (!prop[6] || (prop[6] == '.'))){
  706.   SIZEDTEXT text;
  707.   if (!prop[6]) { /* cache full message */
  708.     md.what = "";
  709.     text.data = (unsigned char *)
  710.       imap_parse_string (stream,&t,reply,&md,&text.size);
  711.     imap_cache (stream,msgno,md.what,NIL,&text);
  712.   }
  713.   else if (!strcmp (prop+7,"SIZE"))
  714.     elt->rfc822_size = strtoul (t,&t,10);
  715. /* legacy properties */
  716.   else if (!strcmp (prop+7,"HEADER")) {
  717.     text.data = (unsigned char *)
  718.       imap_parse_string (stream,&t,reply,NIL,&text.size);
  719.     imap_cache (stream,msgno,"HEADER",NIL,&text);
  720.     e = stream->scache ? &stream->env : &elt->private.msg.env;
  721.   }
  722.   else if (!strcmp (prop+7,"TEXT")) {
  723.     md.what = "TEXT";
  724.     text.data = (unsigned char *)
  725.       imap_parse_string (stream,&t,reply,&md,&text.size);
  726.     imap_cache (stream,msgno,md.what,NIL,&text);
  727.   }
  728.   else {
  729.     sprintf (LOCAL->tmp,"Unknown RFC822 message property: %.80s",prop);
  730.     mm_log (LOCAL->tmp,WARN);
  731.   }
  732. }
  733. else {
  734.   sprintf (LOCAL->tmp,"Unknown message property: %.80s",prop);
  735.   mm_log (LOCAL->tmp,WARN);
  736. }
  737. if (e && *e) env = *e; /* note envelope if we got one */
  738.       }
  739. /* do callback if requested */
  740.       if (ie && env) (*ie) (stream,msgno,env);
  741.     }
  742. /* obsolete response to COPY */
  743.     else if (strcmp (s,"COPY")) {
  744.       sprintf (LOCAL->tmp,"Unknown message data: %lu %.80s",msgno,s);
  745.       mm_log (LOCAL->tmp,WARN);
  746.     }
  747.   }
  749.   else if (!strcmp (reply->key,"FLAGS")) {
  750. /* flush old user flags if any */
  751.     while ((i < NUSERFLAGS) && stream->user_flags[i])
  752.       fs_give ((void **) &stream->user_flags[i++]);
  753.     i = 0; /* add flags */
  754.     if (reply->text && (s = (char *) strtok (reply->text+1," )"))) do
  755.       if (*s != '\') stream->user_flags[i++] = cpystr (s);
  756.     while (s = (char *) strtok (NIL," )"));
  757.   }
  758.   else if (!strcmp (reply->key,"SEARCH")) {
  759. /* only do something if have text */
  760.     if (reply->text && (t = (char *) strtok (reply->text," "))) do {
  761. /* UIDs always passed to main program */
  762.       if (LOCAL->uidsearch) mm_searched (stream,atol (t));
  763. /* should be a msgno then */
  764.       else if ((i = atol (t)) <= stream->nmsgs) {
  765. mail_elt (stream,i)->searched = T;
  766. if (!stream->silent) mm_searched (stream,i);
  767.       }
  768.     } while (t = (char *) strtok (NIL," "));
  769.   }
  770.   else if (!strcmp (reply->key,"NAMESPACE")) {
  771.     if (LOCAL->namespace) {
  772.       mail_free_namespace (&LOCAL->namespace[0]);
  773.       mail_free_namespace (&LOCAL->namespace[1]);
  774.       mail_free_namespace (&LOCAL->namespace[2]);
  775.     }
  776.     else LOCAL->namespace = (NAMESPACE **) fs_get (3 * sizeof (NAMESPACE *));
  777.     if (s = reply->text) { /* parse namespace results */
  778.       LOCAL->namespace[0] = imap_parse_namespace (stream,&s,reply);
  779.       LOCAL->namespace[1] = imap_parse_namespace (stream,&s,reply);
  780.       LOCAL->namespace[2] = imap_parse_namespace (stream,&s,reply);
  781.       if (s && *s) {
  782. sprintf (LOCAL->tmp,"Junk after namespace list: %.80s",s);
  783. mm_log (LOCAL->tmp,WARN);
  784.       }
  785.     }
  786.     else mm_log ("Missing namespace list",WARN);
  787.   }
  788.   else if (!strcmp (reply->key,"SORT")) {
  789.     sortresults_t sr = (sortresults_t)
  790.       mail_parameters (NIL,GET_SORTRESULTS,NIL);
  791.     LOCAL->sortsize = 0; /* initialize sort data */
  792.     if (LOCAL->sortdata) fs_give ((void **) &LOCAL->sortdata);
  793.     LOCAL->sortdata = (unsigned long *)
  794.       fs_get ((stream->nmsgs + 1) * sizeof (unsigned long));
  795. /* only do something if have text */
  796.     if (reply->text && (t = (char *) strtok (reply->text," "))) do
  797.       LOCAL->sortdata[LOCAL->sortsize++] = atol (t);
  798.     while ((t = (char *) strtok (NIL," ")) && (LOCAL->sortsize<stream->nmsgs));
  799.     LOCAL->sortdata[LOCAL->sortsize] = 0;
  800. /* also return via callback if requested */
  801.     if (sr) (*sr) (stream,LOCAL->sortdata,LOCAL->sortsize);
  802.   }
  803.   else if (!strcmp (reply->key,"THREAD")) {
  804.     threadresults_t tr = (threadresults_t)
  805.       mail_parameters (NIL,GET_THREADRESULTS,NIL);
  806.     if (LOCAL->threaddata) mail_free_threadnode (&LOCAL->threaddata);
  807.     if (s = reply->text) {
  808.       LOCAL->threaddata = imap_parse_thread (&s);
  809.       if (tr) (*tr) (stream,LOCAL->threaddata);
  810.       if (s && *s) {
  811. sprintf (LOCAL->tmp,"Junk at end of thread: %.80s",s);
  812. mm_log (LOCAL->tmp,WARN);
  813.       }
  814.     }
  815.   }
  817.   else if (!strcmp (reply->key,"STATUS")) {
  818.     MAILSTATUS status;
  819.     char *txt;
  820.     if (!reply->text) {
  821.       mm_log ("Missing STATUS data",WARN);
  822.       return;
  823.     }
  824.     switch (*reply->text) { /* mailbox is an astring */
  825.     case '"': /* quoted string? */
  826.     case '{': /* literal? */
  827.       txt = reply->text; /* status data is in reply */
  828.       t = imap_parse_string (stream,&txt,reply,NIL,NIL);
  829. /* must be followed by space */
  830.       if (!(txt && (*txt++ == ' '))) txt = NIL;
  831.       break;
  832.     default: /* must be atom */
  833.       t = cpystr (reply->text);
  834.       if (txt = strchr (t,' ')) *txt++ = '';
  835.       break;
  836.     }
  837.     if (t && txt && (*txt++ == '(') && (s = strchr (txt,')')) && (s - txt) &&
  838. !s[1]) {
  839.       *s = ''; /* tie off status data */
  840. /* initialize data block */
  841.       status.flags = status.messages = status.recent = status.unseen =
  842. status.uidnext = status.uidvalidity = 0;
  843.       ucase (txt); /* do case-independent match */
  844.       while (*txt && (s = strchr (txt,' '))) {
  845. *s++ = ''; /* tie off status attribute name */
  846. i = strtoul (s,&s,10);/* get attribute value */
  847. if (!strcmp (txt,"MESSAGES")) {
  848.   status.flags |= SA_MESSAGES;
  849.   status.messages = i;
  850. }
  851. else if (!strcmp (txt,"RECENT")) {
  852.   status.flags |= SA_RECENT;
  853.   status.recent = i;
  854. }
  855. else if (!strcmp (txt,"UNSEEN")) {
  856.   status.flags |= SA_UNSEEN;
  857.   status.unseen = i;
  858. }
  859. else if (!strcmp (txt,"UIDNEXT") || !strcmp (txt,"UID-NEXT")) {
  860.   status.flags |= SA_UIDNEXT;
  861.   status.uidnext = i;
  862. }
  863. else if (!strcmp (txt,"UIDVALIDITY")|| !strcmp (txt,"UID-VALIDITY")){
  864.   status.flags |= SA_UIDVALIDITY;
  865.   status.uidvalidity = i;
  866. }
  867. /* next attribute */
  868. txt = (*s == ' ') ? s + 1 : s;
  869.       }
  870.       strcpy (strchr (strcpy (LOCAL->tmp,stream->mailbox),'}') + 1,t);
  871. /* pass status to main program */
  872.       mm_status (stream,LOCAL->tmp,&status);
  873.     }
  874.     fs_give ((void **) &t);
  875.   }
  877.   else if ((!strcmp (reply->key,"LIST") || !strcmp (reply->key,"LSUB")) &&
  878.    (*reply->text == '(') && (s = strchr (reply->text,')')) &&
  879.    (s[1] == ' ')) {
  880.     char delimiter = '';
  881.     if (!reply->text) {
  882.       mm_log ("Missing LIST/LSUB data",WARN);
  883.       return;
  884.     }
  885.     *s++ = ''; /* tie off attribute list */
  886. /* parse attribute list */
  887.     if (t = (char *) strtok (reply->text+1," ")) do {
  888.       if (!strcmp (ucase (t),"\NOINFERIORS")) i |= LATT_NOINFERIORS;
  889.       else if (!strcmp (t,"\NOSELECT")) i |= LATT_NOSELECT;
  890.       else if (!strcmp (t,"\MARKED")) i |= LATT_MARKED;
  891.       else if (!strcmp (t,"\UNMARKED")) i |= LATT_UNMARKED;
  892. /* ignore extension flags */
  893.     }
  894.     while (t = (char *) strtok (NIL," "));
  895.     switch (*++s) { /* process delimiter */
  896.     case 'N': /* NIL */
  897.     case 'n':
  898.       s += 4; /* skip over NIL<space> */
  899.       break;
  900.     case '"': /* have a delimiter */
  901.       delimiter = (*++s == '\') ? *++s : *s;
  902.       s += 3; /* skip over <delimiter><quote><space> */
  903.     }
  904. /* need to prepend a prefix? */
  905.     if (LOCAL->prefix) strcpy (LOCAL->tmp,LOCAL->prefix);
  906.     else LOCAL->tmp[0] = ''; /* no prefix needed */
  907. /* need to do string parse? */
  908.     if ((*s == '"') || (*s == '{')) {
  909.       strcat (LOCAL->tmp,t = imap_parse_string (stream,&s,reply,NIL,NIL));
  910.       fs_give ((void **) &t);
  911.     }
  912.     else strcat(LOCAL->tmp,s);/* atom is easy */
  913.     if (reply->key[1] == 'S') mm_lsub (stream,delimiter,LOCAL->tmp,i);
  914.     else mm_list (stream,delimiter,LOCAL->tmp,i);
  915.   }
  916.   else if (!strcmp (reply->key,"MAILBOX")) {
  917.     if (!reply->text) {
  918.       mm_log ("Missing MAILBOX data",WARN);
  919.       return;
  920.     }
  921.     if (LOCAL->prefix)
  922.       sprintf (t = LOCAL->tmp,"%s%s",LOCAL->prefix,reply->text);
  923.     else t = reply->text;
  924.     mm_list (stream,NIL,t,NIL);
  925.   }
  926.   else if (!strcmp (reply->key,"OK") || !strcmp (reply->key,"PREAUTH"))
  927.     imap_parse_response (stream,reply->text,NIL,T);
  928.   else if (!strcmp (reply->key,"NO"))
  929.     imap_parse_response (stream,reply->text,WARN,T);
  930.   else if (!strcmp (reply->key,"BAD"))
  931.     imap_parse_response (stream,reply->text,ERROR,T);
  932.   else if (!strcmp (reply->key,"BYE")) {
  933.     LOCAL->byeseen = T; /* note that a BYE seen */
  934.     imap_parse_response (stream,reply->text,BYE,T);
  935.   }
  937.   else if (!strcmp (reply->key,"CAPABILITY")) {
  938. /* only do something if have text */
  939.     if (reply->text && (t = (char *) strtok (ucase (reply->text)," "))) do {
  940.       if (!strcmp (t,"IMAP4")) LOCAL->imap4 = T;
  941.       else if (!strcmp (t,"IMAP4REV1")) LOCAL->imap4rev1 = T;
  942.       else if (!strcmp (t,"NAMESPACE")) LOCAL->use_namespace = T;
  943.       else if (!strcmp (t,"MAILBOX-REFERRALS")) LOCAL->use_mbx_ref = T;
  944.       else if (!strcmp (t,"LOGIN-REFERRALS")) LOCAL->use_log_ref = T;
  945.       else if (!strcmp (t,"SCAN")) LOCAL->use_scan = T;
  946.       else if (!strncmp (t,"SORT",4)) LOCAL->use_sort = T;
  947.       else if (!strncmp (t,"THREAD=",7)) {
  948. THREADER *thread = (THREADER *) fs_get (sizeof (THREADER));
  949. thread->name = cpystr (t+7);
  950. thread->dispatch = NIL;
  951. thread->next = LOCAL->threader;
  952. LOCAL->threader = thread;
  953.       }
  954.       else if (!strncmp (t,"AUTH",4) && ((t[4] == '=') || (t[4] == '-'))) {
  955. if ((i = mail_lookup_auth_name (t+5,stream->secure)) &&
  956.     (--i < MAXAUTHENTICATORS)) LOCAL->use_auth |= (1 << i);
  957. else if (!strcmp (t+5,"ANONYMOUS")) LOCAL->use_authanon = T;
  958.       }
  959. /* unsupported IMAP4 extension */
  960.       else if (!strcmp (t,"STATUS")) LOCAL->use_status = T;
  961. /* ignore other capabilities */
  962.     }
  963.     while (t = (char *) strtok (NIL," "));
  964.   }
  965.   else {
  966.     sprintf (LOCAL->tmp,"Unexpected untagged message: %.80s",reply->key);
  967.     mm_log (LOCAL->tmp,WARN);
  968.   }
  969. }
  971. /* Parse human-readable response text
  972.  * Accepts: mail stream
  973.  *     text
  974.  *     error level for mm_notify()
  975.  *     non-NIL if want mm_notify() event even if no response code
  976.  */
  978. void imap_parse_response (MAILSTREAM *stream,char *text,long errflg,long ntfy)
  979. {
  980.   char *s,*t;
  981.   size_t i;
  982.   if (text && (*text == '[') && (t = strchr (s = text + 1,']')) &&
  983.       ((i = t - s) < IMAPTMPLEN)) {
  984.     LOCAL->tmp[i] = ''; /* make mungable copy of text code */
  985.     if (s = strchr (strncpy (LOCAL->tmp,s,i),' ')) *s++ = '';
  986.     ucase (LOCAL->tmp); /* make code uppercase */
  987.     if (s) { /* have argument? */
  988.       ntfy = NIL; /* suppress mm_notify if normal SELECT data */
  989.       if (!strcmp (LOCAL->tmp,"UIDVALIDITY"))
  990. stream->uid_validity = strtoul (s,NIL,10);
  991.       else if (!strcmp (LOCAL->tmp,"UIDNEXT"))
  992. stream->uid_last = strtoul (s,NIL,10) - 1;
  993.       else if (!strcmp (LOCAL->tmp,"PERMANENTFLAGS") && (*s == '(') &&
  994.        (LOCAL->tmp[i-1] == ')')) {
  995. LOCAL->tmp[i-1] = ''; /* tie off flags */
  996. stream->perm_seen = stream->perm_deleted = stream->perm_answered =
  997.   stream->perm_draft = stream->kwd_create = NIL;
  998. stream->perm_user_flags = NIL;
  999. if (s = strtok (s+1," ")) do {
  1000.   if (*ucase (s) == '\') { /* system flags */
  1001.     if (!strcmp (s,"\SEEN")) stream->perm_seen = T;
  1002.     else if (!strcmp (s,"\DELETED")) stream->perm_deleted = T;
  1003.     else if (!strcmp (s,"\FLAGGED")) stream->perm_flagged = T;
  1004.     else if (!strcmp (s,"\ANSWERED")) stream->perm_answered = T;
  1005.     else if (!strcmp (s,"\DRAFT")) stream->perm_draft = T;
  1006.     else if (!strcmp (s,"\*")) stream->kwd_create = T;
  1007.   }
  1008.   else stream->perm_user_flags |= imap_parse_user_flag (stream,s);
  1009. }
  1010. while (s = strtok (NIL," "));
  1011.       }
  1012.       else { /* all other response code events */
  1013. ntfy = T; /* must mm_notify() */
  1014. if (!strcmp (LOCAL->tmp,"REFERRAL"))
  1015.   LOCAL->referral = cpystr (LOCAL->tmp + 9);
  1016.       }
  1017.     }
  1018.     else { /* no arguments */
  1019.       if (!strcmp (LOCAL->tmp,"UIDNOTSTICKY")) {
  1020. ntfy = NIL;
  1021. stream->uid_nosticky = T;
  1022.       }
  1023.       else if (!strcmp (LOCAL->tmp,"READ-ONLY")) stream->rdonly = T;
  1024.       else if (!strcmp (LOCAL->tmp,"READ-WRITE")) stream->rdonly = NIL;
  1025.     }
  1026.   }
  1027. /* give event to main program */
  1028.   if (ntfy && !stream->silent) mm_notify (stream,text ? text : "",errflg);
  1029. }
  1031. /* Parse a namespace
  1032.  * Accepts: mail stream
  1033.  *     current text pointer
  1034.  *     parsed reply
  1035.  * Returns: namespace list, text pointer updated
  1036.  */
  1038. NAMESPACE *imap_parse_namespace (MAILSTREAM *stream,char **txtptr,
  1039.  IMAPPARSEDREPLY *reply)
  1040. {
  1041.   NAMESPACE *ret = NIL;
  1042.   NAMESPACE *nam = NIL;
  1043.   NAMESPACE *prev = NIL;
  1044.   PARAMETER *par = NIL;
  1045.   if (*txtptr) { /* only if argument given */
  1046. /* ignore leading space */
  1047.     while (**txtptr == ' ') ++*txtptr;
  1048.     switch (**txtptr) {
  1049.     case 'N': /* if NIL */
  1050.     case 'n':
  1051.       ++*txtptr; /* bump past "N" */
  1052.       ++*txtptr; /* bump past "I" */
  1053.       ++*txtptr; /* bump past "L" */
  1054.       break;
  1055.     case '(':
  1056.       ++*txtptr; /* skip past open paren */
  1057.       while (**txtptr == '(') {
  1058. ++*txtptr; /* skip past open paren */
  1059. prev = nam; /* note previous if any */
  1060. nam = (NAMESPACE *) memset (fs_get (sizeof (NAMESPACE)),0,
  1061.   sizeof (NAMESPACE));
  1062. if (!ret) ret = nam; /* if first time note first namespace */
  1063. /* if previous link new block to it */
  1064. if (prev) prev->next = nam;
  1065. nam->name = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1066. /* ignore whitespace */
  1067. while (**txtptr == ' ') ++*txtptr;
  1068. switch (**txtptr) { /* parse delimiter */
  1069. case 'N':
  1070. case 'n':
  1071.   *txtptr += 3; /* bump past "NIL" */
  1072.   break;
  1073. case '"':
  1074.   if (*++*txtptr == '\') nam->delimiter = *++*txtptr;
  1075.   else nam->delimiter = **txtptr;
  1076.   *txtptr += 2; /* bump past character and closing quote */
  1077.   break;
  1078. default:
  1079.   sprintf (LOCAL->tmp,"Missing delimiter in namespace: %.80s",*txtptr);
  1080.   mm_log (LOCAL->tmp,WARN);
  1081.   *txtptr = NIL; /* stop parse */
  1082.   return ret;
  1083. }
  1085. while (**txtptr == ' '){/* append new parameter to tail */
  1086.   if (nam->param) par = par->next = mail_newbody_parameter ();
  1087.   else nam->param = par = mail_newbody_parameter ();
  1088.   if (!(par->attribute = imap_parse_string (stream,txtptr,reply,NIL,
  1089.     NIL))) {
  1090.     mm_log ("Missing namespace extension attribute",WARN);
  1091.     par->attribute = cpystr ("UNKNOWN");
  1092.   }
  1093.   if (!(par->value = imap_parse_string (stream,txtptr,reply,NIL,NIL))){
  1094.     sprintf (LOCAL->tmp,"Missing value for namespace attribute %.80s",
  1095.      par->attribute);
  1096.     mm_log (LOCAL->tmp,WARN);
  1097.     par->value = cpystr ("UNKNOWN");
  1098.   }
  1099. }
  1100. if (**txtptr == ')') ++*txtptr;
  1101. else { /* missing trailing paren */
  1102.   sprintf (LOCAL->tmp,"Junk at end of namespace: %.80s",*txtptr);
  1103.   mm_log (LOCAL->tmp,WARN);
  1104.   return ret;
  1105. }
  1106.       }
  1107.       if (**txtptr == ')') { /* expected trailing paren? */
  1108. ++*txtptr; /* got it! */
  1109. break;
  1110.       }
  1111.     default:
  1112.       sprintf (LOCAL->tmp,"Not a namespace: %.80s",*txtptr);
  1113.       mm_log (LOCAL->tmp,WARN);
  1114.       *txtptr = NIL; /* stop parse now */
  1115.       break;
  1116.     }
  1117.   }
  1118.   return ret;
  1119. }
  1121. /* Parse a thread node list
  1122.  * Accepts: current text pointer
  1123.  * Returns: thread node list, text pointer updated
  1124.  */
  1126. THREADNODE *imap_parse_thread (char **txtptr)
  1127. {
  1128.   THREADNODE *ret = NIL;
  1129.   THREADNODE *last = NIL;
  1130.   THREADNODE *cur = NIL;
  1131.   THREADNODE *n;
  1132.   while (**txtptr == '(') { /* see a thread? */
  1133.     ++*txtptr; /* skip past open paren */
  1134.     while (**txtptr && (isdigit (**txtptr) || (**txtptr == '('))) {
  1135. /* thread branch */
  1136.       if (**txtptr == '(') n = imap_parse_thread (txtptr);
  1137. /* threaded message number */
  1138.       else (n = mail_newthreadnode (NIL))->num = strtoul (*txtptr,txtptr,10);
  1139. /* new current node */
  1140.       if (cur) cur = cur->next = n;
  1141.       else { /* entirely new thread */
  1142. /* plop at end of tree */
  1143. if (ret) last = last->branch = cur = n;
  1144. /* entirely new tree */
  1145. else ret = last = cur = n;
  1146.       }
  1147. /* skip past any space */
  1148.       if (**txtptr == ' ') ++*txtptr;
  1149.     }
  1150.     if (**txtptr == ')') { /* end of thread? */
  1151.       ++*txtptr; /* skip past end of thread */
  1152.       cur = NIL; /* close current thread */
  1153.     }
  1154.     else break;
  1155.   }
  1156.   return ret;
  1157. }
  1159. /* Parse RFC822 message header
  1160.  * Accepts: MAIL stream
  1161.  *     envelope to parse into
  1162.  *     header as sized text
  1163.  *     stringlist if partial header
  1164.  */
  1166. void imap_parse_header (MAILSTREAM *stream,ENVELOPE **env,SIZEDTEXT *hdr,
  1167. STRINGLIST *stl)
  1168. {
  1169.   ENVELOPE *nenv;
  1170. /* parse what we can from this header */
  1171.   rfc822_parse_msg (&nenv,NIL,(char *) hdr->data,hdr->size,NIL,
  1172.     imap_host (stream),stream->dtb->flags);
  1173.   if (*env) { /* need to merge this header into envelope? */
  1174.     if (!(*env)->newsgroups) { /* need Newsgroups? */
  1175.       (*env)->newsgroups = nenv->newsgroups;
  1176.       (*env)->ngbogus = nenv->ngbogus;
  1177.       nenv->newsgroups = NIL;
  1178.     }
  1179.     if (!(*env)->followup_to) { /* need Followup-To? */
  1180.       (*env)->followup_to = nenv->followup_to;
  1181.       nenv->followup_to = NIL;
  1182.     }
  1183.     if (!(*env)->references) { /* need References? */
  1184.       (*env)->references = nenv->references;
  1185.       nenv->references = NIL;
  1186.     }
  1187.     mail_free_envelope (&nenv);
  1188.   }
  1189. /* otherwise set it to this envelope */
  1190.   else (*env = nenv)->incomplete = stl ? T : NIL;
  1191. }
  1193. /* IMAP parse envelope
  1194.  * Accepts: MAIL stream
  1195.  *     pointer to envelope pointer
  1196.  *     current text pointer
  1197.  *     parsed reply
  1198.  *
  1199.  * Updates text pointer
  1200.  */
  1202. void imap_parse_envelope (MAILSTREAM *stream,ENVELOPE **env,char **txtptr,
  1203.   IMAPPARSEDREPLY *reply)
  1204. {
  1205.   ENVELOPE *oenv = *env;
  1206.   char c = *((*txtptr)++); /* grab first character */
  1207. /* ignore leading spaces */
  1208.   while (c == ' ') c = *((*txtptr)++);
  1209.   switch (c) { /* dispatch on first character */
  1210.   case '(': /* if envelope S-expression */
  1211.     *env = mail_newenvelope (); /* parse the new envelope */
  1212.     (*env)->date = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1213.     (*env)->subject = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1214.     (*env)->from = imap_parse_adrlist (stream,txtptr,reply);
  1215.     (*env)->sender = imap_parse_adrlist (stream,txtptr,reply);
  1216.     (*env)->reply_to = imap_parse_adrlist (stream,txtptr,reply);
  1217.     (*env)->to = imap_parse_adrlist (stream,txtptr,reply);
  1218.     (*env)->cc = imap_parse_adrlist (stream,txtptr,reply);
  1219.     (*env)->bcc = imap_parse_adrlist (stream,txtptr,reply);
  1220.     (*env)->in_reply_to = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1221.     (*env)->message_id = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1222.     if (oenv) { /* need to merge old envelope? */
  1223.       (*env)->newsgroups = oenv->newsgroups;
  1224.       oenv->newsgroups = NIL;
  1225.       (*env)->ngbogus = oenv->ngbogus;
  1226.       (*env)->followup_to = oenv->followup_to;
  1227.       oenv->followup_to = NIL;
  1228.       (*env)->references = oenv->references;
  1229.       oenv->references = NIL;
  1230.       mail_free_envelope(&oenv);/* free old envelope */
  1231.     }
  1232.     if (**txtptr != ')') {
  1233.       sprintf (LOCAL->tmp,"Junk at end of envelope: %.80s",*txtptr);
  1234.       mm_log (LOCAL->tmp,WARN);
  1235.     }
  1236.     else ++*txtptr; /* skip past delimiter */
  1237.     break;
  1238.   case 'N': /* if NIL */
  1239.   case 'n':
  1240.     ++*txtptr; /* bump past "I" */
  1241.     ++*txtptr; /* bump past "L" */
  1242.     break;
  1243.   default:
  1244.     sprintf (LOCAL->tmp,"Not an envelope: %.80s",*txtptr);
  1245.     mm_log (LOCAL->tmp,WARN);
  1246.     break;
  1247.   }
  1248. }
  1250. /* IMAP parse address list
  1251.  * Accepts: MAIL stream
  1252.  *     current text pointer
  1253.  *     parsed reply
  1254.  * Returns: address list, NIL on failure
  1255.  *
  1256.  * Updates text pointer
  1257.  */
  1259. ADDRESS *imap_parse_adrlist (MAILSTREAM *stream,char **txtptr,
  1260.      IMAPPARSEDREPLY *reply)
  1261. {
  1262.   ADDRESS *adr = NIL;
  1263.   char c = **txtptr; /* sniff at first character */
  1264. /* ignore leading spaces */
  1265.   while (c == ' ') c = *++*txtptr;
  1266.   ++*txtptr; /* skip past open paren */
  1267.   switch (c) {
  1268.   case '(': /* if envelope S-expression */
  1269.     adr = imap_parse_address (stream,txtptr,reply);
  1270.     if (**txtptr != ')') {
  1271.       sprintf (LOCAL->tmp,"Junk at end of address list: %.80s",*txtptr);
  1272.       mm_log (LOCAL->tmp,WARN);
  1273.     }
  1274.     else ++*txtptr; /* skip past delimiter */
  1275.     break;
  1276.   case 'N': /* if NIL */
  1277.   case 'n':
  1278.     ++*txtptr; /* bump past "I" */
  1279.     ++*txtptr; /* bump past "L" */
  1280.     break;
  1281.   default:
  1282.     sprintf (LOCAL->tmp,"Not an address: %.80s",*txtptr);
  1283.     mm_log (LOCAL->tmp,WARN);
  1284.     break;
  1285.   }
  1286.   return adr;
  1287. }
  1289. /* IMAP parse address
  1290.  * Accepts: MAIL stream
  1291.  *     current text pointer
  1292.  *     parsed reply
  1293.  * Returns: address, NIL on failure
  1294.  *
  1295.  * Updates text pointer
  1296.  */
  1298. ADDRESS *imap_parse_address (MAILSTREAM *stream,char **txtptr,
  1299.      IMAPPARSEDREPLY *reply)
  1300. {
  1301.   ADDRESS *adr = NIL;
  1302.   ADDRESS *ret = NIL;
  1303.   ADDRESS *prev = NIL;
  1304.   char c = **txtptr; /* sniff at first address character */
  1305.   switch (c) {
  1306.   case '(': /* if envelope S-expression */
  1307.     while (c == '(') { /* recursion dies on small stack machines */
  1308.       ++*txtptr; /* skip past open paren */
  1309.       if (adr) prev = adr; /* note previous if any */
  1310.       adr = mail_newaddr (); /* instantiate address and parse its fields */
  1311.       adr->personal = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1312.       adr->adl = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1313.       adr->mailbox = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1314.       adr->host = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1315.       if (**txtptr != ')') { /* handle trailing paren */
  1316. sprintf (LOCAL->tmp,"Junk at end of address: %.80s",*txtptr);
  1317. mm_log (LOCAL->tmp,WARN);
  1318.       }
  1319.       else ++*txtptr; /* skip past close paren */
  1320.       c = **txtptr; /* set up for while test */
  1321. /* ignore leading spaces in front of next */
  1322.       while (c == ' ') c = *++*txtptr;
  1323.       if (!ret) ret = adr; /* if first time note first adr */
  1324. /* if previous link new block to it */
  1325.       if (prev) prev->next = adr;
  1326.     }
  1327.     break;
  1329.   case 'N': /* if NIL */
  1330.   case 'n':
  1331.     *txtptr += 3; /* bump past NIL */
  1332.     break;
  1333.   default:
  1334.     sprintf (LOCAL->tmp,"Not an address: %.80s",*txtptr);
  1335.     mm_log (LOCAL->tmp,WARN);
  1336.     break;
  1337.   }
  1338.   return ret;
  1339. }
  1341. /* IMAP parse flags
  1342.  * Accepts: current message cache
  1343.  *     current text pointer
  1344.  *
  1345.  * Updates text pointer
  1346.  */
  1348. void imap_parse_flags (MAILSTREAM *stream,MESSAGECACHE *elt,char **txtptr)
  1349. {
  1350.   char *flag;
  1351.   char c = '';
  1352.   struct { /* old flags */
  1353.     unsigned int valid : 1;
  1354.     unsigned int seen : 1;
  1355.     unsigned int deleted : 1;
  1356.     unsigned int flagged : 1;
  1357.     unsigned int answered : 1;
  1358.     unsigned int draft : 1;
  1359.     unsigned long user_flags;
  1360.   } old;
  1361.   old.valid = elt->valid; old.seen = elt->seen; old.deleted = elt->deleted;
  1362.   old.flagged = elt->flagged; old.answered = elt->answered;
  1363.   old.draft = elt->draft; old.user_flags = elt->user_flags;
  1364.   elt->valid = T; /* mark have valid flags now */
  1365.   elt->user_flags = NIL; /* zap old flag values */
  1366.   elt->seen = elt->deleted = elt->flagged = elt->answered = elt->draft =
  1367.     elt->recent = NIL;
  1368.   while (c != ')') { /* parse list of flags */
  1369. /* point at a flag */
  1370.     while (*(flag = ++*txtptr) == ' ');
  1371. /* scan for end of flag */
  1372.     while (**txtptr != ' ' && **txtptr != ')') ++*txtptr;
  1373.     c = **txtptr; /* save delimiter */
  1374.     **txtptr = ''; /* tie off flag */
  1375.     if (!*flag) break; /* null flag */
  1376. /* if starts with  must be sys flag */
  1377.     else if (*ucase (flag) == '\') {
  1378.       if (!strcmp (flag,"\SEEN")) elt->seen = T;
  1379.       else if (!strcmp (flag,"\DELETED")) elt->deleted = T;
  1380.       else if (!strcmp (flag,"\FLAGGED")) elt->flagged = T;
  1381.       else if (!strcmp (flag,"\ANSWERED")) elt->answered = T;
  1382.       else if (!strcmp (flag,"\RECENT")) elt->recent = T;
  1383.       else if (!strcmp (flag,"\DRAFT")) elt->draft = T;
  1384.     }
  1385. /* otherwise user flag */
  1386.     else elt->user_flags |= imap_parse_user_flag (stream,flag);
  1387.   }
  1388.   ++*txtptr; /* bump past delimiter */
  1389.   if (!old.valid || (old.seen != elt->seen) ||
  1390.       (old.deleted != elt->deleted) || (old.flagged != elt->flagged) ||
  1391.       (old.answered != elt->answered) || (old.draft != elt->draft) ||
  1392.       (old.user_flags != elt->user_flags)) mm_flags (stream,elt->msgno);
  1393. }
  1396. /* IMAP parse user flag
  1397.  * Accepts: MAIL stream
  1398.  *     flag name
  1399.  * Returns: flag bit position
  1400.  */
  1402. unsigned long imap_parse_user_flag (MAILSTREAM *stream,char *flag)
  1403. {
  1404.   char tmp[MAILTMPLEN];
  1405.   long i;
  1406. /* sniff through all user flags */
  1407.   for (i = 0; i < NUSERFLAGS; ++i) if (stream->user_flags[i]) {
  1408.     sprintf (tmp,"%.1000s",stream->user_flags[i]);
  1409.     if (!strcmp (flag,ucase (tmp))) return (1 << i);
  1410.   }
  1411.   return (unsigned long) 0; /* not found */
  1412. }
  1414. /* IMAP parse string
  1415.  * Accepts: MAIL stream
  1416.  *     current text pointer
  1417.  *     parsed reply
  1418.  *     mailgets data
  1419.  *     returned string length
  1420.  * Returns: string
  1421.  *
  1422.  * Updates text pointer
  1423.  */
  1425. char *imap_parse_string (MAILSTREAM *stream,char **txtptr,
  1426.  IMAPPARSEDREPLY *reply,GETS_DATA *md,
  1427.  unsigned long *len)
  1428. {
  1429.   char *st;
  1430.   char *string = NIL;
  1431.   unsigned long i,j,k;
  1432.   char c = **txtptr; /* sniff at first character */
  1433.   mailgets_t mg = (mailgets_t) mail_parameters (NIL,GET_GETS,NIL);
  1434.   readprogress_t rp =
  1435.     (readprogress_t) mail_parameters (NIL,GET_READPROGRESS,NIL);
  1436. /* ignore leading spaces */
  1437.   while (c == ' ') c = *++*txtptr;
  1438.   st = ++*txtptr; /* remember start of string */
  1439.   switch (c) {
  1440.   case '"': /* if quoted string */
  1441.     i = 0; /* initial byte count */
  1442.     while (**txtptr != '"') { /* search for end of string */
  1443.       if (**txtptr == '\') ++*txtptr;
  1444.       ++i; /* bump count */
  1445.       ++*txtptr; /* bump pointer */
  1446.     }
  1447.     ++*txtptr; /* bump past delimiter */
  1448.     string = (char *) fs_get ((size_t) i + 1);
  1449.     for (j = 0; j < i; j++) { /* copy the string */
  1450.       if (*st == '\') ++st; /* quoted character */
  1451.       string[j] = *st++;
  1452.     }
  1453.     string[j] = ''; /* tie off string */
  1454.     if (len) *len = i; /* set return value too */
  1455.     if (md && mg) { /* have special routine to slurp string? */
  1456.       STRING bs;
  1457.       if (md->first) { /* partial fetch? */
  1458. md->first--; /* restore origin octet */
  1459. md->last = i; /* number of octets that we got */
  1460.       }
  1461.       INIT (&bs,mail_string,string,i);
  1462.       (*mg) (mail_read,&bs,i,md);
  1463.     }
  1464.     break;
  1465.   case 'N': /* if NIL */
  1466.   case 'n':
  1467.     ++*txtptr; /* bump past "I" */
  1468.     ++*txtptr; /* bump past "L" */
  1469.     if (len) *len = 0;
  1470.     break;
  1472.   case '{': /* if literal string */
  1473. /* get size of string */ 
  1474.     i = strtoul (*txtptr,txtptr,10);
  1475.     if (len) *len = i; /* set return value */
  1476.     if (md && mg) { /* have special routine to slurp string? */
  1477.       if (md->first) { /* partial fetch? */
  1478. md->first--; /* restore origin octet */
  1479. md->last = i; /* number of octets that we got */
  1480.       }
  1481.       else md->flags |= MG_COPY;/* otherwise flag need to copy */
  1482.       string = (*mg) (net_getbuffer,LOCAL->netstream,i,md);
  1483.     }
  1484.     else { /* must slurp into free storage */
  1485.       string = (char *) fs_get ((size_t) i + 1);
  1486.       *string = ''; /* init in case getbuffer fails */
  1487. /* get the literal */
  1488.       if (rp) for (k = 0; j = min ((long) MAILTMPLEN,(long) i); i -= j) {
  1489. net_getbuffer (LOCAL->netstream,j,string + k);
  1490. (*rp) (md,k += j);
  1491.       }
  1492.       else net_getbuffer (LOCAL->netstream,i,string);
  1493.     }
  1494.     fs_give ((void **) &reply->line);
  1495. /* get new reply text line */
  1496.     reply->line = net_getline (LOCAL->netstream);
  1497.     if (stream->debug) mm_dlog (reply->line);
  1498.     *txtptr = reply->line; /* set text pointer to point at it */
  1499.     break;
  1500.   default:
  1501.     sprintf (LOCAL->tmp,"Not a string: %c%.80s",c,*txtptr);
  1502.     mm_log (LOCAL->tmp,WARN);
  1503.     if (len) *len = 0;
  1504.     break;
  1505.   }
  1506.   return string;
  1507. }
  1509. /* Register text in IMAP cache
  1510.  * Accepts: MAIL stream
  1511.  *     message number
  1512.  *     IMAP segment specifier
  1513.  *     header string list (if a HEADER section specifier)
  1514.  *     sized text to register
  1515.  * Returns: non-zero if cache non-empty
  1516.  */
  1518. long imap_cache (MAILSTREAM *stream,unsigned long msgno,char *seg,
  1519.  STRINGLIST *stl,SIZEDTEXT *text)
  1520. {
  1521.   char *t,tmp[MAILTMPLEN];
  1522.   unsigned long i;
  1523.   BODY *b;
  1524.   SIZEDTEXT *ret;
  1525.   STRINGLIST *stc;
  1526.   MESSAGECACHE *elt = mail_elt (stream,msgno);
  1527. /* top-level header never does mailgets */
  1528.   if (!strcmp (seg,"HEADER") || !strcmp (seg,"0") ||
  1529.       !strcmp (seg,"HEADER.FIELDS") || !strcmp (seg,"HEADER.FIELDS.NOT")) {
  1530.     ret = &elt->private.msg.header.text;
  1531.     if (text) { /* don't do this if no text */
  1532.       if (ret->data) fs_give ((void **) &ret->data);
  1533.       mail_free_stringlist (&elt->private.msg.lines);
  1534.       elt->private.msg.lines = stl;
  1535. /* prevent cache reuse of .NOT */
  1536.       if ((seg[0] == 'H') && (seg[6] == '.') && (seg[13] == '.'))
  1537. for (stc = stl; stc; stc = stc->next) stc->text.size = 0;
  1538.       if (stream->scache) { /* short caching puts it in the stream */
  1539. if (stream->msgno != msgno) {
  1540. /* flush old stuff */
  1541.   mail_free_envelope (&stream->env);
  1542.   mail_free_body (&stream->body);
  1543.   stream->msgno = msgno;
  1544. }
  1545. imap_parse_header (stream,&stream->env,text,stl);
  1546.       }
  1547. /* regular caching */
  1548.       else imap_parse_header (stream,&elt->private.msg.env,text,stl);
  1549.     }
  1550.   }
  1551. /* top level text */
  1552.   else if (!strcmp (seg,"TEXT")) {
  1553.     ret = &elt->private.msg.text.text;
  1554.     if (text && ret->data) fs_give ((void **) &ret->data);
  1555.   }
  1556.   else if (!*seg) { /* full message */
  1557.     ret = &elt->private.msg.full.text;
  1558.     if (text && ret->data) fs_give ((void **) &ret->data);
  1559.   }
  1561.   else { /* nested, find non-contents specifier */
  1562.     for (t = seg; *t && !((*t == '.') && (isalpha(t[1]) || !atol (t+1))); t++);
  1563.     if (*t) *t++ = ''; /* tie off section from data specifier */
  1564.     if (!(b = mail_body (stream,msgno,seg))) {
  1565.       sprintf (tmp,"Unknown section number: %.80s",seg);
  1566.       mm_log (tmp,WARN);
  1567.       return NIL;
  1568.     }
  1569.     if (*t) { /* if a non-numberic subpart */
  1570.       if ((i = (b->type == TYPEMESSAGE) && (!strcmp (b->subtype,"RFC822"))) &&
  1571.   (!strcmp (t,"HEADER") || !strcmp (t,"0") ||
  1572.    !strcmp (t,"HEADER.FIELDS") || !strcmp (t,"HEADER.FIELDS.NOT"))) {
  1573. ret = &b->nested.msg->header.text;
  1574. if (text) {
  1575.   if (ret->data) fs_give ((void **) &ret->data);
  1576.   mail_free_stringlist (&b->nested.msg->lines);
  1577.   b->nested.msg->lines = stl;
  1578. /* prevent cache reuse of .NOT */
  1579.   if ((t[0] == 'H') && (t[6] == '.') && (t[13] == '.'))
  1580.     for (stc = stl; stc; stc = stc->next) stc->text.size = 0;
  1581.   imap_parse_header (stream,&b->nested.msg->env,text,stl);
  1582. }
  1583.       }
  1584.       else if (i && !strcmp (t,"TEXT")) {
  1585. ret = &b->nested.msg->text.text;
  1586. if (text && ret->data) fs_give ((void **) &ret->data);
  1587.       }
  1588. /* otherwise it must be MIME */
  1589.       else if (!strcmp (t,"MIME")) {
  1590. ret = &b->mime.text;
  1591. if (text && ret->data) fs_give ((void **) &ret->data);
  1592.       }
  1593.       else {
  1594. sprintf (tmp,"Unknown section specifier: %.80s.%.80s",seg,t);
  1595. mm_log (tmp,WARN);
  1596. return NIL;
  1597.       }
  1598.     }
  1599.     else { /* ordinary contents */
  1600.       ret = &b->contents.text;
  1601.       if (text && ret->data) fs_give ((void **) &ret->data);
  1602.     }
  1603.   }
  1604.   if (text) { /* update cache if requested */
  1605.     ret->data = text->data;
  1606.     ret->size = text->size;
  1607.   }
  1608.   return ret->data ? LONGT : NIL;
  1609. }
  1611. /* IMAP parse body structure
  1612.  * Accepts: MAIL stream
  1613.  *     body structure to write into
  1614.  *     current text pointer
  1615.  *     parsed reply
  1616.  *
  1617.  * Updates text pointer
  1618.  */
  1620. void imap_parse_body_structure (MAILSTREAM *stream,BODY *body,char **txtptr,
  1621. IMAPPARSEDREPLY *reply)
  1622. {
  1623.   int i;
  1624.   char *s;
  1625.   PART *part = NIL;
  1626.   char c = *((*txtptr)++); /* grab first character */
  1627. /* ignore leading spaces */
  1628.   while (c == ' ') c = *((*txtptr)++);
  1629.   switch (c) { /* dispatch on first character */
  1630.   case '(': /* body structure list */
  1631.     if (**txtptr == '(') { /* multipart body? */
  1632.       body->type= TYPEMULTIPART;/* yes, set its type */
  1633.       do { /* instantiate new body part */
  1634. if (part) part = part->next = mail_newbody_part ();
  1635. else body->nested.part = part = mail_newbody_part ();
  1636. /* parse it */
  1637. imap_parse_body_structure (stream,&part->body,txtptr,reply);
  1638.       } while (**txtptr == '(');/* for each body part */
  1639.       if (body->subtype = imap_parse_string (stream,txtptr,reply,NIL,NIL))
  1640. ucase (body->subtype);
  1641.       else {
  1642. mm_log ("Missing multipart subtype",WARN);
  1643. body->subtype = cpystr (rfc822_default_subtype (body->type));
  1644.       }
  1645.       if (**txtptr == ' ') /* multipart parameters */
  1646. body->parameter = imap_parse_body_parameter (stream,txtptr,reply);
  1647.       if (**txtptr == ' ') /* disposition */
  1648. imap_parse_disposition (stream,body,txtptr,reply);
  1649.       if (**txtptr == ' ') /* language */
  1650. body->language = imap_parse_language (stream,txtptr,reply);
  1651.       while (**txtptr == ' ') imap_parse_extension (stream,txtptr,reply);
  1652.       if (**txtptr != ')') { /* validate ending */
  1653. sprintf (LOCAL->tmp,"Junk at end of multipart body: %.80s",*txtptr);
  1654. mm_log (LOCAL->tmp,WARN);
  1655.       }
  1656.       else ++*txtptr; /* skip past delimiter */
  1657.     }
  1659.     else { /* not multipart, parse type name */
  1660.       if (**txtptr == ')') { /* empty body? */
  1661. ++*txtptr; /* bump past it */
  1662. break; /* and punt */
  1663.       }
  1664.       body->type = TYPEOTHER; /* assume unknown type */
  1665.       body->encoding = ENCOTHER;/* and unknown encoding */
  1666. /* parse type */
  1667.       if (s = imap_parse_string (stream,txtptr,reply,NIL,NIL)) {
  1668. ucase (s);
  1669. for (i=0;(i<=TYPEMAX) && body_types[i] && strcmp(s,body_types[i]);i++);
  1670. if (i <= TYPEMAX) { /* only if found a slot */
  1671.   body->type = i; /* set body type */
  1672.   if (body_types[i]) fs_give ((void **) &s);
  1673.   else body_types[i]=s; /* assign empty slot */
  1674. }
  1675.       }
  1676. /* parse subtype */
  1677.       if (body->subtype = imap_parse_string (stream,txtptr,reply,NIL,NIL))
  1678. ucase (body->subtype);
  1679.       else {
  1680. mm_log ("Missing body subtype",WARN);
  1681. body->subtype = cpystr (rfc822_default_subtype (body->type));
  1682.       }
  1683.       body->parameter = imap_parse_body_parameter (stream,txtptr,reply);
  1684.       body->id = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1685.       body->description = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1686.       if (s = imap_parse_string (stream,txtptr,reply,NIL,NIL)) {
  1687. ucase (s); /* search for body encoding */
  1688. for (i = 0; (i <= ENCMAX) && body_encodings[i] &&
  1689.      strcmp (s,body_encodings[i]); i++);
  1690. if (i > ENCMAX) body->type = ENCOTHER;
  1691. else { /* only if found a slot */
  1692.   body->encoding = i; /* set body encoding */
  1693.   if (body_encodings[i]) fs_give ((void **) &s);
  1694. /* assign empty slot */
  1695.   else body_encodings[i] = s;
  1696. }
  1697.       }
  1698. /* parse size of contents in bytes */
  1699.       body->size.bytes = strtoul (*txtptr,txtptr,10);
  1700.       switch (body->type) { /* possible extra stuff */
  1701.       case TYPEMESSAGE: /* message envelope and body */
  1702. if (strcmp (body->subtype,"RFC822")) break;
  1703. body->nested.msg = mail_newmsg ();
  1704. imap_parse_envelope (stream,&body->nested.msg->env,txtptr,reply);
  1705. body->nested.msg->body = mail_newbody ();
  1706. imap_parse_body_structure (stream,body->nested.msg->body,txtptr,reply);
  1707. /* drop into text case */
  1708.       case TYPETEXT: /* size in lines */
  1709. body->size.lines = strtoul (*txtptr,txtptr,10);
  1710. break;
  1711.       default: /* otherwise nothing special */
  1712. break;
  1713.       }
  1714.       if (**txtptr == ' ') /* if extension data */
  1715. body->md5 = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1716.       if (**txtptr == ' ') /* disposition */
  1717. imap_parse_disposition (stream,body,txtptr,reply);
  1718.       if (**txtptr == ' ') /* language */
  1719. body->language = imap_parse_language (stream,txtptr,reply);
  1720.       while (**txtptr == ' ') imap_parse_extension (stream,txtptr,reply);
  1721.       if (**txtptr != ')') { /* validate ending */
  1722. sprintf (LOCAL->tmp,"Junk at end of body part: %.80s",*txtptr);
  1723. mm_log (LOCAL->tmp,WARN);
  1724.       }
  1725.       else ++*txtptr; /* skip past delimiter */
  1726.     }
  1727.     break;
  1728.   case 'N': /* if NIL */
  1729.   case 'n':
  1730.     ++*txtptr; /* bump past "I" */
  1731.     ++*txtptr; /* bump past "L" */
  1732.     break;
  1733.   default: /* otherwise quite bogus */
  1734.     sprintf (LOCAL->tmp,"Bogus body structure: %.80s",*txtptr);
  1735.     mm_log (LOCAL->tmp,WARN);
  1736.     break;
  1737.   }
  1738. }
  1740. /* IMAP parse body parameter
  1741.  * Accepts: MAIL stream
  1742.  *     current text pointer
  1743.  *     parsed reply
  1744.  * Returns: body parameter
  1745.  * Updates text pointer
  1746.  */
  1748. PARAMETER *imap_parse_body_parameter (MAILSTREAM *stream,char **txtptr,
  1749.       IMAPPARSEDREPLY *reply)
  1750. {
  1751.   PARAMETER *ret = NIL;
  1752.   PARAMETER *par = NIL;
  1753.   char c,*s;
  1754. /* ignore leading spaces */
  1755.   while ((c = *(*txtptr)++) == ' ');
  1756. /* parse parameter list */
  1757.   if (c == '(') while (c != ')') {
  1758. /* append new parameter to tail */
  1759.     if (ret) par = par->next = mail_newbody_parameter ();
  1760.     else ret = par = mail_newbody_parameter ();
  1761.     if(!(par->attribute=imap_parse_string (stream,txtptr,reply,NIL,NIL))) {
  1762.       mm_log ("Missing parameter attribute",WARN);
  1763.       par->attribute = cpystr ("UNKNOWN");
  1764.     }
  1765.     if (!(par->value = imap_parse_string (stream,txtptr,reply,NIL,NIL))) {
  1766.       sprintf (LOCAL->tmp,"Missing value for parameter %.80s",par->attribute);
  1767.       mm_log (LOCAL->tmp,WARN);
  1768.       par->value = cpystr ("UNKNOWN");
  1769.     }
  1770.     switch (c = **txtptr) { /* see what comes after */
  1771.     case ' ': /* flush whitespace */
  1772.       while ((c = *++*txtptr) == ' ');
  1773.       break;
  1774.     case ')': /* end of attribute/value pairs */
  1775.       ++*txtptr; /* skip past closing paren */
  1776.       break;
  1777.     default:
  1778.       sprintf (LOCAL->tmp,"Junk at end of parameter: %.80s",*txtptr);
  1779.       mm_log (LOCAL->tmp,WARN);
  1780.       break;
  1781.     }
  1782.   }
  1783. /* empty parameter, must be NIL */
  1784.   else if (((c == 'N') || (c == 'n')) &&
  1785.    ((*(s = *txtptr) == 'I') || (*s == 'i')) &&
  1786.    ((s[1] == 'L') || (s[1] == 'l'))) *txtptr += 2;
  1787.   else {
  1788.     sprintf (LOCAL->tmp,"Bogus body parameter: %c%.80s",c,(*txtptr) - 1);
  1789.     mm_log (LOCAL->tmp,WARN);
  1790.   }
  1791.   return ret;
  1792. }
  1794. /* IMAP parse body disposition
  1795.  * Accepts: MAIL stream
  1796.  *     body structure to write into
  1797.  *     current text pointer
  1798.  *     parsed reply
  1799.  */
  1801. void imap_parse_disposition (MAILSTREAM *stream,BODY *body,char **txtptr,
  1802.      IMAPPARSEDREPLY *reply)
  1803. {
  1804.   switch (*++*txtptr) {
  1805.   case '(':
  1806.     ++*txtptr; /* skip open paren */
  1807.     body->disposition.type = imap_parse_string (stream,txtptr,reply,NIL,NIL);
  1808.     body->disposition.parameter =
  1809.       imap_parse_body_parameter (stream,txtptr,reply);
  1810.     if (**txtptr != ')') { /* validate ending */
  1811.       sprintf (LOCAL->tmp,"Junk at end of disposition: %.80s",*txtptr);
  1812.       mm_log (LOCAL->tmp,WARN);
  1813.     }
  1814.     else ++*txtptr; /* skip past delimiter */
  1815.     break;
  1816.   case 'N': /* if NIL */
  1817.   case 'n':
  1818.     ++*txtptr; /* bump past "N" */
  1819.     ++*txtptr; /* bump past "I" */
  1820.     ++*txtptr; /* bump past "L" */
  1821.     break;
  1822.   default:
  1823.     sprintf (LOCAL->tmp,"Unknown body disposition: %.80s",*txtptr);
  1824.     mm_log (LOCAL->tmp,WARN);
  1825. /* try to skip to next space */
  1826.     while ((*++*txtptr != ' ') && (**txtptr != ')') && **txtptr);
  1827.     break;
  1828.   }
  1829. }
  1831. /* IMAP parse body language
  1832.  * Accepts: MAIL stream
  1833.  *     current text pointer
  1834.  *     parsed reply
  1835.  * Returns: string list or NIL if empty or error
  1836.  */
  1838. STRINGLIST *imap_parse_language (MAILSTREAM *stream,char **txtptr,
  1839.  IMAPPARSEDREPLY *reply)
  1840. {
  1841.   unsigned long i;
  1842.   char *s;
  1843.   STRINGLIST *ret = NIL;
  1844. /* language is a list */
  1845.   if (*++*txtptr == '(') ret = imap_parse_stringlist (stream,txtptr,reply);
  1846.   else if (s = imap_parse_string (stream,txtptr,reply,NIL,&i)) {
  1847.     (ret = mail_newstringlist ())->text.data = (unsigned char *) s;
  1848.     ret->text.size = i;
  1849.   }
  1850.   return ret;
  1851. }
  1853. /* IMAP parse string list
  1854.  * Accepts: MAIL stream
  1855.  *     current text pointer
  1856.  *     parsed reply
  1857.  * Returns: string list or NIL if empty or error
  1858.  */
  1860. STRINGLIST *imap_parse_stringlist (MAILSTREAM *stream,char **txtptr,
  1861.    IMAPPARSEDREPLY *reply)
  1862. {
  1863.   STRINGLIST *stl = NIL;
  1864.   STRINGLIST *stc = NIL;
  1865.   char c,*s;
  1866.   char *t = *txtptr;
  1867. /* parse the list */
  1868.   if (*t++ == '(') while (*t != ')') {
  1869.     if (stl) stc = stc->next = mail_newstringlist ();
  1870.     else stc = stl = mail_newstringlist ();
  1871. /* atom */
  1872.     if ((*t != '{') && (*t != '"') && (s = strpbrk (t," )"))) {
  1873.       c = *s; /* note delimiter */
  1874.       *s = ''; /* tie off atom and copy it*/
  1875.       stc->text.size = strlen ((char *) (stc->text.data =
  1876.  (unsigned char *) cpystr (t)));
  1877.       if (c == ' ') t = ++s; /* another token follows */
  1878.       else *(t = s) = c; /* restore delimiter */
  1879.     }
  1880. /* string */
  1881.     else if (!(stc->text.data = (unsigned char *)
  1882.        imap_parse_string (stream,&t,reply,NIL,&stc->text.size))) {
  1883.       sprintf (LOCAL->tmp,"Bogus string list member: %.80s",t);
  1884.       mm_log (LOCAL->tmp,WARN);
  1885.       mail_free_stringlist (&stl);
  1886.       break;
  1887.     }
  1888.     else if (*t == ' ') ++t; /* another token follows */
  1889.   }
  1890.   if (stl) *txtptr = ++t; /* update return string */
  1891.   return stl;
  1892. }
  1894. /* IMAP parse unknown body extension data
  1895.  * Accepts: MAIL stream
  1896.  *     current text pointer
  1897.  *     parsed reply
  1898.  *
  1899.  * Updates text pointer
  1900.  */
  1902. void imap_parse_extension (MAILSTREAM *stream,char **txtptr,
  1903.    IMAPPARSEDREPLY *reply)
  1904. {
  1905.   unsigned long i,j;
  1906.   switch (*++*txtptr) { /* action depends upon first character */
  1907.   case '(':
  1908.     while (**txtptr != ')') imap_parse_extension (stream,txtptr,reply);
  1909.     ++*txtptr; /* bump past closing parenthesis */
  1910.     break;
  1911.   case '"': /* if quoted string */
  1912.     while (*++*txtptr != '"') if (**txtptr == '\') ++*txtptr;
  1913.     ++*txtptr; /* bump past closing quote */
  1914.     break;
  1915.   case 'N': /* if NIL */
  1916.   case 'n':
  1917.     ++*txtptr; /* bump past "N" */
  1918.     ++*txtptr; /* bump past "I" */
  1919.     ++*txtptr; /* bump past "L" */
  1920.     break;
  1921.   case '{': /* get size of literal */
  1922.     ++*txtptr; /* bump past open squiggle */
  1923.     if (i = strtoul (*txtptr,txtptr,10)) do
  1924.       net_getbuffer (LOCAL->netstream,j = max (i,(long)IMAPTMPLEN),LOCAL->tmp);
  1925.     while (i -= j);
  1926. /* get new reply text line */
  1927.     reply->line = net_getline (LOCAL->netstream);
  1928.     if (stream->debug) mm_dlog (reply->line);
  1929.     *txtptr = reply->line; /* set text pointer to point at it */
  1930.     break;
  1931.   case '0': case '1': case '2': case '3': case '4':
  1932.   case '5': case '6': case '7': case '8': case '9':
  1933.     strtoul (*txtptr,txtptr,10);
  1934.     break;
  1935.   default:
  1936.     sprintf (LOCAL->tmp,"Unknown extension token: %.80s",*txtptr);
  1937.     mm_log (LOCAL->tmp,WARN);
  1938. /* try to skip to next space */
  1939.     while ((*++*txtptr != ' ') && (**txtptr != ')') && **txtptr);
  1940.     break;
  1941.   }
  1942. }
  1944. /* IMAP return host name
  1945.  * Accepts: MAIL stream
  1946.  * Returns: host name
  1947.  */
  1949. char *imap_host (MAILSTREAM *stream)
  1950. {
  1951. /* return host name on stream if open */
  1952.   return (LOCAL && LOCAL->netstream) ? net_host (LOCAL->netstream) :
  1953.     ".NO-IMAP-CONNECTION.";
  1954. }