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

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

网络编程

开发平台：

Unix_Linux

nntp.c：源码内容
  1. /*
  2.  * Program: Network News Transfer Protocol (NNTP) routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 10 February 1992
  13.  * Last Edited: 20 September 1999
  14.  *
  15.  * Copyright 1999 by the University of Washington
  16.  *
  17.  *  Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted, provided
  19.  * that the above copyright notices appear in all copies and that both the
  20.  * above copyright notices and this permission notice appear in supporting
  21.  * documentation, and that the name of the University of Washington not be
  22.  * used in advertising or publicity pertaining to distribution of the software
  23.  * without specific, written prior permission.  This software is made
  24.  * available "as is", and
  25.  * THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
  26.  * WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
  27.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
  28.  * NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
  29.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  30.  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
  31.  * (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN
  32.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33.  *
  34.  */
  37. #include <ctype.h>
  38. #include <stdio.h>
  39. #include "mail.h"
  40. #include "osdep.h"
  41. #include "nntp.h"
  42. #include "rfc822.h"
  43. #include "misc.h"
  44. #include "newsrc.h"
  45. #include "netmsg.h"
  46. #include "flstring.h"
  47. #include "utf8.h"
  49. /* Driver dispatch used by MAIL */
  51. DRIVER nntpdriver = {
  52.   "nntp", /* driver name */
  53. #ifdef INADEQUATE_MEMORY
  54.   DR_LOWMEM |
  55. #endif
  56. /* driver flags */
  57.   DR_NEWS|DR_READONLY|DR_NOFAST|DR_NAMESPACE|DR_CRLF|DR_RECYCLE,
  58.   (DRIVER *) NIL, /* next driver */
  59.   nntp_valid, /* mailbox is valid for us */
  60.   nntp_parameters, /* manipulate parameters */
  61.   nntp_scan, /* scan mailboxes */
  62.   nntp_list, /* find mailboxes */
  63.   nntp_lsub, /* find subscribed mailboxes */
  64.   nntp_subscribe, /* subscribe to mailbox */
  65.   nntp_unsubscribe, /* unsubscribe from mailbox */
  66.   nntp_create, /* create mailbox */
  67.   nntp_delete, /* delete mailbox */
  68.   nntp_rename, /* rename mailbox */
  69.   nntp_status, /* status of mailbox */
  70.   nntp_mopen, /* open mailbox */
  71.   nntp_mclose, /* close mailbox */
  72.   nntp_fetchfast, /* fetch message "fast" attributes */
  73.   nntp_flags, /* fetch message flags */
  74.   nntp_overview, /* fetch overview */
  75.   NIL, /* fetch message structure */
  76.   nntp_header, /* fetch message header */
  77.   nntp_text, /* fetch message text */
  78.   NIL, /* fetch message */
  79.   NIL, /* unique identifier */
  80.   NIL, /* message number from UID */
  81.   NIL, /* modify flags */
  82.   nntp_flagmsg, /* per-message modify flags */
  83.   nntp_search, /* search for message based on criteria */
  84.   nntp_sort, /* sort messages */
  85.   nntp_thread, /* thread messages */
  86.   nntp_ping, /* ping mailbox to see if still alive */
  87.   nntp_check, /* check for new messages */
  88.   nntp_expunge, /* expunge deleted messages */
  89.   nntp_copy, /* copy messages to another mailbox */
  90.   nntp_append, /* append string message to mailbox */
  91.   NIL /* garbage collect stream */
  92. };
  94. /* prototype stream */
  95. MAILSTREAM nntpproto = {&nntpdriver};
  98. /* driver parameters */
  99. static long nntp_maxlogintrials = MAXLOGINTRIALS;
  100. static long nntp_port = 0;
  101. static long nntp_altport = 0;
  102. static char *nntp_altname = NIL;
  104. /* NNTP validate mailbox
  105.  * Accepts: mailbox name
  106.  * Returns: our driver if name is valid, NIL otherwise
  107.  */
  109. DRIVER *nntp_valid (char *name)
  110. {
  111.   char tmp[MAILTMPLEN];
  112.   return nntp_isvalid (name,tmp);
  113. }
  116. /* NNTP validate mailbox work routine
  117.  * Accepts: mailbox name
  118.  *     buffer for returned mailbox name
  119.  * Returns: our driver if name is valid, NIL otherwise
  120.  */
  122. DRIVER *nntp_isvalid (char *name,char *mbx)
  123. {
  124.   DRIVER *ret = mail_valid_net (name,&nntpdriver,NIL,mbx);
  125.   if (ret && (mbx[0] == '#')) { /* namespace format name? */
  126.     if ((mbx[1] == 'n') && (mbx[2] == 'e') && (mbx[3] == 'w') &&
  127. (mbx[4] == 's') && (mbx[5] == '.'))
  128.       memmove (mbx,mbx+6,strlen (mbx+6) + 1);
  129.     else ret = NIL; /* bogus name */
  130.   }
  131.   return ret;
  132. }
  134. /* News manipulate driver parameters
  135.  * Accepts: function code
  136.  *     function-dependent value
  137.  * Returns: function-dependent return value
  138.  */
  140. void *nntp_parameters (long function,void *value)
  141. {
  142.   switch ((int) function) {
  143.   case SET_MAXLOGINTRIALS:
  144.     nntp_maxlogintrials = (unsigned long) value;
  145.     break;
  146.   case GET_MAXLOGINTRIALS:
  147.     value = (void *) nntp_maxlogintrials;
  148.     break;
  149.   case SET_NNTPPORT:
  150.     nntp_port = (long) value;
  151.     break;
  152.   case GET_NNTPPORT:
  153.     value = (void *) nntp_port;
  154.     break;
  155.   case SET_ALTNNTPPORT:
  156.     nntp_altport = (long) value;
  157.     break;
  158.   case GET_ALTNNTPPORT:
  159.     value = (void *) nntp_altport;
  160.     break;
  161.   case SET_ALTNNTPNAME:
  162.     nntp_altname = (char *) value;
  163.     break;
  164.   case GET_ALTNNTPNAME:
  165.     value = (void *) nntp_altname;
  166.     break;
  167.   default:
  168.     value = NIL; /* error case */
  169.     break;
  170.   }
  171.   return value;
  172. }
  174. /* NNTP mail scan mailboxes for string
  175.  * Accepts: mail stream
  176.  *     reference
  177.  *     pattern to search
  178.  *     string to scan
  179.  */
  181. void nntp_scan (MAILSTREAM *stream,char *ref,char *pat,char *contents)
  182. {
  183.   char tmp[MAILTMPLEN];
  184.   if (nntp_canonicalize (ref,pat,tmp))
  185.     mm_log ("Scan not valid for NNTP mailboxes",ERROR);
  186. }
  189. /* NNTP list newsgroups
  190.  * Accepts: mail stream
  191.  *     reference
  192.  *     pattern to search
  193.  */
  195. void nntp_list (MAILSTREAM *stream,char *ref,char *pat)
  196. {
  197.   MAILSTREAM *st = stream;
  198.   char *s,*t,*lcl,pattern[MAILTMPLEN],name[MAILTMPLEN];
  199.   int showuppers = pat[strlen (pat) - 1] == '%';
  200.   if (!pat || !*pat) {
  201.     if (nntp_canonicalize (ref,"*",pattern)) {
  202. /* tie off name at root */
  203.       if ((s = strchr (pattern,'}')) && (s = strchr (s+1,'.'))) *++s = '';
  204.       else pattern[0] = '';
  205.       mm_list (stream,'.',pattern,NIL);
  206.     }
  207.   }
  208. /* ask server for open newsgroups */
  209.   else if (nntp_canonicalize (ref,pat,pattern) &&
  210.    ((stream && LOCAL && LOCAL->nntpstream) ||
  211.     (stream = mail_open (NIL,pattern,OP_HALFOPEN))) &&
  212.    ((nntp_send (LOCAL->nntpstream,"LIST","ACTIVE") == NNTPGLIST) ||
  213.     (nntp_send (LOCAL->nntpstream,"LIST",NIL) == NNTPGLIST))) {
  214. /* namespace format name? */
  215.     if (*(lcl = strchr (strcpy (name,pattern),'}') + 1) == '#') lcl += 6;
  216. /* process data until we see final dot */
  217.     while (s = net_getline (LOCAL->nntpstream->netstream)) {
  218.       if ((*s == '.') && !s[1]){/* end of text */
  219. fs_give ((void **) &s);
  220. break;
  221.       }
  222.       if (t = strchr (s,' ')) { /* tie off after newsgroup name */
  223. *t = '';
  224. strcpy (lcl,s); /* make full form of name */
  225. /* report if match */
  226. if (pmatch_full (name,pattern,'.')) mm_list (stream,'.',name,NIL);
  227. else while (showuppers && (t = strrchr (lcl,'.'))) {
  228.   *t = ''; /* tie off the name */
  229.   if (pmatch_full (name,pattern,'.'))
  230.     mm_list (stream,'.',name,LATT_NOSELECT);
  231. }
  232.       }
  233.       fs_give ((void **) &s); /* clean up */
  234.     }
  235.     if (stream != st) mail_close (stream);
  236.   }
  237. }
  239. /* NNTP list subscribed newsgroups
  240.  * Accepts: mail stream
  241.  *     reference
  242.  *     pattern to search
  243.  */
  245. void nntp_lsub (MAILSTREAM *stream,char *ref,char *pat)
  246. {
  247.   void *sdb = NIL;
  248.   char *s,mbx[MAILTMPLEN];
  249. /* return data from newsrc */
  250.   if (nntp_canonicalize (ref,pat,mbx)) newsrc_lsub (stream,mbx);
  251.   if (*pat == '{') { /* if remote pattern, must be NNTP */
  252.     if (!nntp_valid (pat)) return;
  253.     ref = NIL; /* good NNTP pattern, punt reference */
  254.   }
  255. /* if remote reference, must be valid NNTP */
  256.   if (ref && (*ref == '{') && !nntp_valid (ref)) return;
  257. /* kludgy application of reference */
  258.   if (ref && *ref) sprintf (mbx,"%s%s",ref,pat);
  259.   else strcpy (mbx,pat);
  261.   if (s = sm_read (&sdb)) do if (nntp_valid (s) && pmatch (s,mbx))
  262.     mm_lsub (stream,NIL,s,NIL);
  263.   while (s = sm_read (&sdb)); /* until no more subscriptions */
  264. }
  267. /* NNTP canonicalize newsgroup name
  268.  * Accepts: reference
  269.  *     pattern
  270.  *     returned single pattern
  271.  * Returns: T on success, NIL on failure
  272.  */
  274. long nntp_canonicalize (char *ref,char *pat,char *pattern)
  275. {
  276.   if (ref && *ref) { /* have a reference */
  277.     if (!nntp_valid (ref)) return NIL;
  278.     strcpy (pattern,ref); /* copy reference to pattern */
  279. /* # overrides mailbox field in reference */
  280.     if (*pat == '#') strcpy (strchr (pattern,'}') + 1,pat);
  281. /* pattern starts, reference ends, with . */
  282.     else if ((*pat == '.') && (pattern[strlen (pattern) - 1] == '.'))
  283.       strcat (pattern,pat + 1); /* append, omitting one of the period */
  284.     else strcat (pattern,pat); /* anything else is just appended */
  285.   }
  286.   else strcpy (pattern,pat); /* just have basic name */
  287.   return nntp_valid (pattern) ? T : NIL;
  288. }
  290. /* NNTP subscribe to mailbox
  291.  * Accepts: mail stream
  292.  *     mailbox to add to subscription list
  293.  * Returns: T on success, NIL on failure
  294.  */
  296. long nntp_subscribe (MAILSTREAM *stream,char *mailbox)
  297. {
  298.   char mbx[MAILTMPLEN];
  299.   return nntp_isvalid (mailbox,mbx) ? newsrc_update (stream,mbx,':') : NIL;
  300. }
  303. /* NNTP unsubscribe to mailbox
  304.  * Accepts: mail stream
  305.  *     mailbox to delete from subscription list
  306.  * Returns: T on success, NIL on failure
  307.  */
  309. long nntp_unsubscribe (MAILSTREAM *stream,char *mailbox)
  310. {
  311.   char mbx[MAILTMPLEN];
  312.   return nntp_isvalid (mailbox,mbx) ? newsrc_update (stream,mbx,'!') : NIL;
  313. }
  315. /* NNTP create mailbox
  316.  * Accepts: mail stream
  317.  *     mailbox name to create
  318.  * Returns: T on success, NIL on failure
  319.  */
  321. long nntp_create (MAILSTREAM *stream,char *mailbox)
  322. {
  323.   return NIL; /* never valid for NNTP */
  324. }
  327. /* NNTP delete mailbox
  328.  *     mailbox name to delete
  329.  * Returns: T on success, NIL on failure
  330.  */
  332. long nntp_delete (MAILSTREAM *stream,char *mailbox)
  333. {
  334.   return NIL; /* never valid for NNTP */
  335. }
  338. /* NNTP rename mailbox
  339.  * Accepts: mail stream
  340.  *     old mailbox name
  341.  *     new mailbox name
  342.  * Returns: T on success, NIL on failure
  343.  */
  345. long nntp_rename (MAILSTREAM *stream,char *old,char *newname)
  346. {
  347.   return NIL; /* never valid for NNTP */
  348. }
  350. /* NNTP status
  351.  * Accepts: mail stream
  352.  *     mailbox name
  353.  *     status flags
  354.  * Returns: T on success, NIL on failure
  355.  */
  357. long nntp_status (MAILSTREAM *stream,char *mbx,long flags)
  358. {
  359.   MAILSTATUS status;
  360.   NETMBX mb;
  361.   unsigned long i;
  362.   long ret = NIL;
  363.   char *s,*name,*state,tmp[MAILTMPLEN];
  364.   char *old = (stream && !stream->halfopen) ? LOCAL->name : NIL;
  365.   MAILSTREAM *tstream = NIL;
  366.   if (!(mail_valid_net_parse (mbx,&mb) && *mb.mailbox &&
  367. ((mb.mailbox[0] != '#') ||
  368.  ((mb.mailbox[1] == 'n') && (mb.mailbox[2] == 'e') &&
  369.   (mb.mailbox[3] == 'w') && (mb.mailbox[4] == 's') &&
  370.   (mb.mailbox[5] == '.'))))) {
  371.     sprintf (tmp,"Invalid NNTP name %s",mbx);
  372.     mm_log (tmp,ERROR);
  373.     return NIL;
  374.   }
  375. /* note mailbox name */
  376.   name = (*mb.mailbox == '#') ? mb.mailbox+6 : mb.mailbox;
  377. /* stream to reuse? */
  378.   if (!(stream && LOCAL->nntpstream &&
  379. mail_usable_network_stream (stream,mbx)) &&
  380.       !(tstream = stream = mail_open (NIL,mbx,OP_HALFOPEN|OP_SILENT)))
  381.     return NIL; /* can't reuse or make a new one */
  383.   if (nntp_send (LOCAL->nntpstream,"GROUP",name) == NNTPGOK) {
  384.     status.flags = flags; /* status validity flags */
  385.     status.messages = strtoul (LOCAL->nntpstream->reply + 4,&s,10);
  386.     i = strtoul (s,&s,10);
  387.     status.uidnext = strtoul (s,NIL,10) + 1;
  388. /* initially empty */
  389.     status.recent = status.unseen = 0;
  390. /* don't bother if empty or don't want this */
  391.     if (status.messages && (flags & (SA_RECENT | SA_UNSEEN))) {
  392.       if (state = newsrc_state (stream,name)) {
  393. /* in case have to do XHDR Date */
  394. sprintf (tmp,"%lu-%lu",i,status.uidnext - 1);
  395. /* only bother if there appear to be holes */
  396. if ((status.messages < (status.uidnext - i)) &&
  397.     ((nntp_send (LOCAL->nntpstream,"LISTGROUP",name) == NNTPGOK)
  398.      || (nntp_send (LOCAL->nntpstream,"XHDR Date",tmp) == NNTPHEAD))) {
  399.   while ((s = net_getline (LOCAL->nntpstream->netstream)) &&
  400.  strcmp (s,".")) {
  401.     newsrc_check_uid (state,strtoul (s,NIL,10),&status.recent,
  402.       &status.unseen);
  403.     fs_give ((void **) &s);
  404.   }
  405.   if (s) fs_give ((void **) &s);
  406. }
  407. /* assume c-client/NNTP map is entire range */
  408. else while (i < status.uidnext)
  409.   newsrc_check_uid (state,i++,&status.recent,&status.unseen);
  410. fs_give ((void **) &state);
  411.       }
  412. /* no .newsrc state, all messages new */
  413.       else status.recent = status.unseen = status.messages;
  414.     }
  415. /* UID validity is a constant */
  416.     status.uidvalidity = stream->uid_validity;
  417. /* pass status to main program */
  418.     mm_status (stream,mbx,&status);
  419.     ret = T; /* succes */
  420.   }
  421. /* flush temporary stream */
  422.   if (tstream) mail_close (tstream);
  423. /* else reopen old newsgroup */
  424.   else if (old && nntp_send (LOCAL->nntpstream,"GROUP",old) != NNTPGOK) {
  425.     mm_log (LOCAL->nntpstream->reply,ERROR);
  426.     stream->halfopen = T; /* go halfopen */
  427.   }
  428.   return ret; /* success */
  429. }
  431. /* NNTP open
  432.  * Accepts: stream to open
  433.  * Returns: stream on success, NIL on failure
  434.  */
  436. MAILSTREAM *nntp_mopen (MAILSTREAM *stream)
  437. {
  438.   unsigned long i,j,k,nmsgs;
  439.   char *s,*mbx,tmp[MAILTMPLEN];
  440.   NETMBX mb;
  441.   SENDSTREAM *nstream = NIL;
  442. /* return prototype for OP_PROTOTYPE call */
  443.   if (!stream) return &nntpproto;
  444.   if (!(mail_valid_net_parse (stream->mailbox,&mb) &&
  445. (stream->halfopen || /* insist upon valid name */
  446.  (*mb.mailbox && ((mb.mailbox[0] != '#') ||
  447.   ((mb.mailbox[1] == 'n') && (mb.mailbox[2] == 'e') &&
  448.    (mb.mailbox[3] == 'w') && (mb.mailbox[4] == 's') &&
  449.    (mb.mailbox[5] == '.'))))))) {
  450.     sprintf (tmp,"Invalid NNTP name %s",stream->mailbox);
  451.     mm_log (tmp,ERROR);
  452.     return NIL;
  453.   }
  454. /* note mailbox anme */
  455.   mbx = (*mb.mailbox == '#') ? mb.mailbox+6 : mb.mailbox;
  456.   if (LOCAL) { /* recycle stream */
  457.     sprintf (tmp,"Reusing connection to %s",LOCAL->host);
  458.     if (!stream->silent) mm_log (tmp,(long) NIL);
  459.     nstream = LOCAL->nntpstream;
  460.     LOCAL->nntpstream = NIL; /* keep nntp_mclose() from punting it */
  461.     nntp_mclose (stream,NIL); /* do close action */
  462.     stream->dtb = &nntpdriver; /* reattach this driver */
  463.   }
  464.   if (mb.secflag) { /* in case /secure switch given */
  465.     mm_log ("Secure NNTP login not available",ERROR);
  466.     return NIL;
  467.   }
  468. /* in case /debug switch given */
  469.   if (mb.dbgflag) stream->debug = T;
  470.   mb.tryaltflag = stream->tryalt;
  471.   if (!nstream) { /* open NNTP now if not already open */
  472.     char *hostlist[2];
  473.     hostlist[0] = strcpy (tmp,mb.host);
  474.     if (mb.port || nntp_port)
  475.       sprintf (tmp + strlen (tmp),":%lu",mb.port ? mb.port : nntp_port);
  476.     if (mb.altflag) sprintf (tmp + strlen (tmp),"/%s",(char *)
  477.      mail_parameters (NIL,GET_ALTDRIVERNAME,NIL));
  478.     if (mb.user[0]) sprintf (tmp + strlen (tmp),"/user="%s"",mb.user);
  479.     hostlist[1] = NIL;
  480.     nstream = nntp_open (hostlist,OP_READONLY+(stream->debug ? OP_DEBUG:NIL));
  481.   }
  482.   if (!nstream) return NIL; /* didn't get an NNTP session */
  484. /* always zero messages if halfopen */
  485.   if (stream->halfopen) i = j = k = nmsgs = 0;
  486. /* otherwise open the newsgroup */
  487.   else if (nntp_send (nstream,"GROUP",mbx) == NNTPGOK) {
  488.     k = strtoul (nstream->reply + 4,&s,10);
  489.     i = strtoul (s,&s,10);
  490.     stream->uid_last = j = strtoul (s,&s,10);
  491.     nmsgs = (i | j) ? 1 + j - i : 0;
  492.   }
  493.   else { /* no such newsgroup */
  494.     mm_log (nstream->reply,ERROR);
  495.     nntp_close (nstream); /* punt stream */
  496.     return NIL;
  497.   }
  498. /* newsgroup open, instantiate local data */
  499.   stream->local = memset (fs_get (sizeof (NNTPLOCAL)),0,sizeof (NNTPLOCAL));
  500.   LOCAL->nntpstream = nstream;
  501.   LOCAL->name = cpystr (mbx); /* copy newsgroup name */
  502.   if (mb.user[0]) LOCAL->user = cpystr (mb.user);
  503.   stream->sequence++; /* bump sequence number */
  504.   stream->rdonly = stream->perm_deleted = T;
  505. /* UIDs are always valid */
  506.   stream->uid_validity = 0xbeefface;
  507. /* copy host name */
  508.   LOCAL->host = cpystr (net_host (nstream->netstream));
  509.   sprintf (tmp,"{%s:%lu/nntp",LOCAL->host,net_port (nstream->netstream));
  510.   if (mb.altflag) sprintf (tmp + strlen (tmp),"/%s",(char *)
  511.    mail_parameters (NIL,GET_ALTDRIVERNAME,NIL));
  512.   if (mb.secflag) strcat (tmp,"/secure");
  513.   if (LOCAL->user) sprintf (tmp + strlen (tmp),"/user="%s"",LOCAL->user);
  514.   if (stream->halfopen) strcat (tmp,"}<no_mailbox>");
  515.   else sprintf (tmp + strlen (tmp),"}#news.%s",mbx);
  516.   fs_give ((void **) &stream->mailbox);
  517.   stream->mailbox = cpystr (tmp);
  519.   if (nmsgs) { /* if any messages exist */
  520.     short silent = stream->silent;
  521.     stream->silent = T; /* don't notify main program yet */
  522.     mail_exists (stream,nmsgs); /* silently set the cache to the guesstimate */
  523.     sprintf (tmp,"%lu-%lu",i,j);/* in case have to do XHDR Date */
  524.     if ((k < nmsgs) && /* only bother if there appear to be holes */
  525. ((nntp_send (nstream,"LISTGROUP",mbx) == NNTPGOK) ||
  526.  (nntp_send (nstream,"XHDR Date",tmp) == NNTPHEAD))) {
  527.       nmsgs = 0; /* have holes, calculate true count */
  528.       while ((s = net_getline (nstream->netstream)) && strcmp (s,".")) {
  529. mail_elt (stream,++nmsgs)->private.uid = atol (s);
  530. fs_give ((void **) &s);
  531.       }
  532.       if (s) fs_give ((void **) &s);
  533.     }
  534. /* assume c-client/NNTP map is entire range */
  535.     else for (k = 1; k <= nmsgs; k++)
  536.       mail_elt (stream,k)->private.uid = i++;
  537.     stream->nmsgs = 0; /* whack it back down */
  538.     stream->silent = silent; /* restore old silent setting */
  539.     mail_exists (stream,nmsgs); /* notify upper level that messages exist */
  540. /* read .newsrc entries */
  541.     mail_recent (stream,newsrc_read (mbx,stream));
  542.   }
  543.   else { /* empty newsgroup or halfopen */
  544.     if (!(stream->silent || stream->halfopen)) {
  545.       sprintf (tmp,"Newsgroup %s is empty",mbx);
  546.       mm_log (tmp,WARN);
  547.     }
  548.     mail_exists (stream,(long) 0);
  549.     mail_recent (stream,(long) 0);
  550.   }
  551.   return stream; /* return stream to caller */
  552. }
  554. /* NNTP close
  555.  * Accepts: MAIL stream
  556.  *     option flags
  557.  */
  559. void nntp_mclose (MAILSTREAM *stream,long options)
  560. {
  561.   unsigned long i;
  562.   MESSAGECACHE *elt;
  563.   if (LOCAL) { /* only if a file is open */
  564.     nntp_check (stream); /* dump final checkpoint */
  565.     if (LOCAL->name) fs_give ((void **) &LOCAL->name);
  566.     if (LOCAL->host) fs_give ((void **) &LOCAL->host);
  567.     if (LOCAL->user) fs_give ((void **) &LOCAL->user);
  568.     if (LOCAL->txt) fclose (LOCAL->txt);
  569. /* close NNTP connection */
  570.     if (LOCAL->nntpstream) nntp_close (LOCAL->nntpstream);
  571.     for (i = 1; i <= stream->nmsgs; i++)
  572.       if ((elt = mail_elt (stream,i))->private.data)
  573. fs_give ((void **) &elt->private.data);
  574. /* nuke the local data */
  575.     fs_give ((void **) &stream->local);
  576.     stream->dtb = NIL; /* log out the DTB */
  577.   }
  578. }
  580. /* NNTP fetch fast information
  581.  * Accepts: MAIL stream
  582.  *     sequence
  583.  *     option flags
  584.  * This is ugly and slow
  585.  */
  587. void nntp_fetchfast (MAILSTREAM *stream,char *sequence,long flags)
  588. {
  589.   unsigned long i;
  590.   MESSAGECACHE *elt;
  591. /* get sequence */
  592.   if (stream && LOCAL && ((flags & FT_UID) ?
  593.   mail_uid_sequence (stream,sequence) :
  594.   mail_sequence (stream,sequence)))
  595.     for (i = 1; i <= stream->nmsgs; i++) {
  596.       if ((elt = mail_elt (stream,i))->sequence &&
  597.   !(elt->day && !elt->rfc822_size)) {
  598. ENVELOPE **env = NIL;
  599. ENVELOPE *e = NIL;
  600. if (!stream->scache) env = &elt->private.msg.env;
  601. else if (stream->msgno == i) env = &stream->env;
  602. else env = &e;
  603. if (!*env || !elt->rfc822_size) {
  604.   STRING bs;
  605.   unsigned long hs;
  606.   char *ht = (*stream->dtb->header) (stream,i,&hs,NIL);
  607. /* need to make an envelope? */
  608.   if (!*env) rfc822_parse_msg (env,NIL,ht,hs,NIL,BADHOST,
  609.        stream->dtb->flags);
  610. /* need message size too, ugh */
  611.   if (!elt->rfc822_size) {
  612.     (*stream->dtb->text) (stream,i,&bs,FT_PEEK);
  613.     elt->rfc822_size = hs + SIZE (&bs) - GETPOS (&bs);
  614.   }
  615. }
  616. /* if need date, have date in envelope? */
  617. if (!elt->day && *env && (*env)->date)
  618.   mail_parse_date (elt,(*env)->date);
  619. /* sigh, fill in bogus default */
  620. if (!elt->day) elt->day = elt->month = 1;
  621. mail_free_envelope (&e);
  622.       }
  623.     }
  624. }
  626. /* NNTP fetch flags
  627.  * Accepts: MAIL stream
  628.  *     sequence
  629.  *     option flags
  630.  */
  632. void nntp_flags (MAILSTREAM *stream,char *sequence,long flags)
  633. {
  634.   unsigned long i;
  635.   if ((flags & FT_UID) ? /* validate all elts */
  636.       mail_uid_sequence (stream,sequence) : mail_sequence (stream,sequence))
  637.     for (i = 1; i <= stream->nmsgs; i++) mail_elt (stream,i)->valid = T;
  638. }
  640. /* NNTP fetch overview
  641.  * Accepts: MAIL stream
  642.  *     UID sequence (may be NIL for nntp_search() call)
  643.  *     overview return function
  644.  * Returns: T if successful, NIL otherwise
  645.  */
  647. long nntp_overview (MAILSTREAM *stream,char *sequence,overview_t ofn)
  648. {
  649.   unsigned long i,j,k,uid;
  650.   char c,*s,*t,*v,tmp[MAILTMPLEN];
  651.   MESSAGECACHE *elt;
  652.   OVERVIEW ov;
  653. /* parse the sequence */
  654.   if (!sequence || mail_uid_sequence (stream,sequence)) {
  655. /* scan sequence to load cache */
  656.     for (i = 1; i <= stream->nmsgs; i++)
  657. /* have cached overview yet? */
  658.       if ((elt = mail_elt (stream,i))->sequence && !elt->private.data) {
  659. for (j = i + 1; /* no, find end of cache gap range */
  660.      (j <= stream->nmsgs) && (elt = mail_elt (stream,j))->sequence &&
  661.      !elt->private.data; j++);
  662. /* make NNTP range */
  663. sprintf (tmp,(i == (j - 1)) ? "%lu" : "%lu-%lu",mail_uid (stream,i),
  664.  mail_uid (stream,j - 1));
  665. i = j; /* advance beyond gap */
  666. /* ask server for overview data to cache */
  667. if (nntp_send (LOCAL->nntpstream,"XOVER",tmp) == NNTPOVER) {
  668.   while ((s = net_getline (LOCAL->nntpstream->netstream)) &&
  669.  strcmp (s,".")) {
  670. /* death to embedded newlines */
  671.     for (t = v = s; c = *v++;)
  672.       if ((c != '12') && (c != '15')) *t++ = c;
  673.     *t++ = ''; /* tie off string in case it was shortened */
  674. /* cache the overview if found its sequence */
  675.     if ((uid = atol (s)) && (k = mail_msgno (stream,uid)) &&
  676. (t = strchr (s,'t'))) {
  677.       if ((elt = mail_elt (stream,k))->private.data)
  678. fs_give ((void **) &elt->private.data);
  679.       elt->private.data = (unsigned long) cpystr (t + 1);
  680.     }
  681.     else { /* shouldn't happen, snarl if it does */
  682.       sprintf (tmp,"Server returned data for unknown UID %lu",uid);
  683.       mm_log (tmp,WARN);
  684.     }
  685. /* flush the overview */
  686.     fs_give ((void **) &s);
  687.   }
  688. /* flush the terminating dot */
  689.   if (s) fs_give ((void **) &s);
  690. }
  691. else i = stream->nmsgs; /* XOVER failed, punt cache load */
  692.       }
  694. /* now scan sequence to return overviews */
  695.     if (ofn) for (i = 1; i <= stream->nmsgs; i++)
  696.       if ((elt = mail_elt (stream,i))->sequence) {
  697. /* UID for this message */
  698. uid = mail_uid (stream,i);
  699. /* parse cached overview */
  700. if (nntp_parse_overview (&ov,s = (char *) elt->private.data))
  701.   (*ofn) (stream,uid,&ov);
  702. else { /* parse failed */
  703.   (*ofn) (stream,uid,NIL);
  704.   if (s && *s) { /* unusable cached entry? */
  705.     sprintf (tmp,"Unable to parse overview for UID %lu: %.500s",uid,s);
  706.     mm_log (tmp,WARN);
  707. /* erase it from the cache */
  708.     fs_give ((void **) &s);
  709.   }
  710. /* insert empty cached text as necessary */
  711.   if (!s) elt->private.data = (unsigned long) cpystr ("");
  712. }
  713. /* clean up overview data */
  714. if (ov.from) mail_free_address (&ov.from);
  715. if (ov.subject) fs_give ((void **) &ov.subject);
  716.       }
  717.   }
  718.   return T;
  719. }
  721. /* Parse OVERVIEW struct from cached NNTP XOVER response
  722.  * Accepts: struct to load
  723.  *     cached XOVER response
  724.  * Returns: T if success, NIL if fail
  725.  */
  727. long nntp_parse_overview (OVERVIEW *ov,char *text)
  728. {
  729.   char *t;
  730. /* nothing in overview yet */
  731.   memset ((void *) ov,0,sizeof (OVERVIEW));
  732. /* no cached data */
  733.   if (!(text && *text)) return NIL;
  734.   ov->subject = cpystr (text); /* make hackable copy of overview */
  735. /* find end of Subject */
  736.   if (t = strchr (ov->subject,'t')) {
  737.     *t++ = ''; /* tie off Subject, point to From */
  738. /* find end of From */
  739.     if (ov->date = strchr (t,'t')) {
  740.       *ov->date++ = ''; /* tie off From, point to Date */
  741. /* parse From */
  742.       rfc822_parse_adrlist (&ov->from,t,BADHOST);
  743. /* find end of Date */
  744.       if (ov->message_id = strchr (ov->date,'t')) {
  745. /* tie off Date, point to Message-ID */
  746. *ov->message_id++ = '';
  747. /* find end of Message-ID */
  748. if (ov->references = strchr (ov->message_id,'t')) {
  749. /* tie off Message-ID, point to References */
  750.   *ov->references++ = '';
  751. /* fine end of References */
  752.   if (t = strchr (ov->references,'t')) {
  753.     *t++ = ''; /* tie off References, point to octet size */
  754. /* parse size of message in octets */
  755.     ov->optional.octets = atol (t);
  756. /* find end of size */
  757.     if (t = strchr (t,'t')) {
  758. /* parse size of message in lines */
  759.       ov->optional.lines = atol (++t);
  760. /* find Xref */
  761.       if (ov->optional.xref = strchr (t,'t'))
  762. *ov->optional.xref++ = '';
  763.     }
  764.   }
  765. }
  766.       }
  767.     }
  768.   }
  769.   return ov->references ? T : NIL;
  770. }
  772. /* NNTP fetch header as text
  773.  * Accepts: mail stream
  774.  *     message number
  775.  *     pointer to return size
  776.  *     flags
  777.  * Returns: header text
  778.  */
  780. char *nntp_header (MAILSTREAM *stream,unsigned long msgno,unsigned long *size,
  781.    long flags)
  782. {
  783.   char tmp[MAILTMPLEN];
  784.   MESSAGECACHE *elt;
  785.   FILE *f;
  786.   if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return "";
  787. /* have header text? */
  788.   if (!(elt = mail_elt (stream,msgno))->private.msg.header.text.data) {
  789.     sprintf (tmp,"%lu",mail_uid (stream,msgno));
  790. /* get header text */
  791.     if ((nntp_send (LOCAL->nntpstream,"HEAD",tmp) == NNTPHEAD) &&
  792. (f = netmsg_slurp (LOCAL->nntpstream->netstream,size,NIL))) {
  793.       fread (elt->private.msg.header.text.data =
  794.      (unsigned char *) fs_get ((size_t) *size + 3),
  795.      (size_t) 1,(size_t) *size,f);
  796.       fclose (f); /* flush temp file */
  797. /* tie off header with extra CRLF and NUL */
  798.       elt->private.msg.header.text.data[*size] = '15';
  799.       elt->private.msg.header.text.data[++*size] = '12';
  800.       elt->private.msg.header.text.data[++*size] = '';
  801.       elt->private.msg.header.text.size = *size;
  802.       elt->valid = T; /* make elt valid now */
  803.     }
  804.     else { /* failed, mark as deleted and empty */
  805.       elt->valid = elt->deleted = T;
  806.       *size = elt->private.msg.header.text.size = 0;
  807.     }
  808.   }
  809. /* just return size of text */
  810.   else *size = elt->private.msg.header.text.size;
  811.   return elt->private.msg.header.text.data ?
  812.     (char *) elt->private.msg.header.text.data : "";
  813. }
  815. /* NNTP fetch body
  816.  * Accepts: mail stream
  817.  *     message number
  818.  *     pointer to stringstruct to initialize
  819.  *     flags
  820.  * Returns: T if successful, else NIL
  821.  */
  823. long nntp_text (MAILSTREAM *stream,unsigned long msgno,STRING *bs,long flags)
  824. {
  825.   char tmp[MAILTMPLEN];
  826.   MESSAGECACHE *elt;
  827.   INIT (bs,mail_string,(void *) "",0);
  828.   if ((flags & FT_UID) && !(msgno = mail_msgno (stream,msgno))) return NIL;
  829.   elt = mail_elt (stream,msgno);
  830. /* different message, flush cache */
  831.   if (LOCAL->txt && (LOCAL->msgno != msgno)) {
  832.     fclose (LOCAL->txt);
  833.     LOCAL->txt = NIL;
  834.   }
  835.   LOCAL->msgno = msgno; /* note cached message */
  836.   if (!LOCAL->txt) { /* have file for this message? */
  837.     sprintf (tmp,"%lu",elt->private.uid);
  838.     if (nntp_send (LOCAL->nntpstream,"BODY",tmp) != NNTPBODY)
  839.       elt->deleted = T; /* failed mark as deleted */
  840.     else LOCAL->txt = netmsg_slurp (LOCAL->nntpstream->netstream,
  841.     &LOCAL->txtsize,NIL);
  842.   }
  843.   if (!LOCAL->txt) return NIL; /* error if don't have a file */
  844.   if (!(flags & FT_PEEK)) { /* mark seen if needed */
  845.     elt->seen = T;
  846.     mm_flags (stream,elt->msgno);
  847.   }
  848.   INIT (bs,file_string,(void *) LOCAL->txt,LOCAL->txtsize);
  849.   return T;
  850. }
  852. /* NNTP per-message modify flag
  853.  * Accepts: MAIL stream
  854.  *     message cache element
  855.  */
  857. void nntp_flagmsg (MAILSTREAM *stream,MESSAGECACHE *elt)
  858. {
  859.   if (!LOCAL->dirty) { /* only bother checking if not dirty yet */
  860.     if (elt->valid) { /* if done, see if deleted changed */
  861.       if (elt->sequence != elt->deleted) LOCAL->dirty = T;
  862.       elt->sequence = T; /* leave the sequence set */
  863.     }
  864. /* note current setting of deleted flag */
  865.     else elt->sequence = elt->deleted;
  866.   }
  867. }
  869. /* NNTP search messages
  870.  * Accepts: mail stream
  871.  *     character set
  872.  *     search program
  873.  *     option flags
  874.  */
  876. void nntp_search (MAILSTREAM *stream,char *charset,SEARCHPGM *pgm,long flags)
  877. {
  878.   unsigned long i;
  879.   MESSAGECACHE *elt;
  880.   OVERVIEW ov;
  881.   if (charset && *charset && /* convert if charset not US-ASCII or UTF-8 */
  882.       !(((charset[0] == 'U') || (charset[0] == 'u')) &&
  883. ((((charset[1] == 'S') || (charset[1] == 's')) &&
  884.   (charset[2] == '-') &&
  885.   ((charset[3] == 'A') || (charset[3] == 'a')) &&
  886.   ((charset[4] == 'S') || (charset[4] == 's')) &&
  887.   ((charset[5] == 'C') || (charset[5] == 'c')) &&
  888.   ((charset[6] == 'I') || (charset[6] == 'i')) &&
  889.   ((charset[7] == 'I') || (charset[7] == 'i')) && !charset[8]) ||
  890.  (((charset[1] == 'T') || (charset[1] == 't')) &&
  891.   ((charset[2] == 'F') || (charset[2] == 'f')) &&
  892.   (charset[3] == '-') && (charset[4] == '8') && !charset[5])))) {
  893.     if (utf8_text (NIL,charset,NIL,T)) utf8_searchpgm (pgm,charset);
  894.     else return; /* charset unknown */
  895.   }
  896.   if (flags & SO_OVERVIEW) { /* only if specified to use overview */
  897. /* identify messages that will be searched */
  898.     for (i = 1; i <= stream->nmsgs; ++i)
  899.       mail_elt (stream,i)->sequence = nntp_search_msg (stream,i,pgm,NIL);
  900. /* load the overview cache */
  901.     nntp_overview (stream,NIL,NIL);
  902.   }
  903. /* init in case no overview at cleanup */
  904.   memset ((void *) &ov,0,sizeof (OVERVIEW));
  905. /* otherwise do default search */
  906.   for (i = 1; i <= stream->nmsgs; ++i) {
  907.     if (((flags & SO_OVERVIEW) && ((elt = mail_elt (stream,i))->sequence) &&
  908.  nntp_parse_overview (&ov,(char *) elt->private.data)) ?
  909. nntp_search_msg (stream,i,pgm,&ov) :
  910. mail_search_msg (stream,i,NIL,pgm)) {
  911.       if (flags & SE_UID) mm_searched (stream,mail_uid (stream,i));
  912.       else { /* mark as searched, notify mail program */
  913. mail_elt (stream,i)->searched = T;
  914. if (!stream->silent) mm_searched (stream,i);
  915.       }
  916.     }
  917. /* clean up overview data */
  918.     if (ov.from) mail_free_address (&ov.from);
  919.     if (ov.subject) fs_give ((void **) &ov.subject);
  920.   }
  921. }
  923. /* NNTP search message
  924.  * Accepts: MAIL stream
  925.  *     message number
  926.  *     search program
  927.  *     overview to search (NIL means preliminary pass)
  928.  * Returns: T if found, NIL otherwise
  929.  */
  931. long nntp_search_msg (MAILSTREAM *stream,unsigned long msgno,SEARCHPGM *pgm,
  932.       OVERVIEW *ov)
  933. {
  934.   unsigned short d;
  935.   MESSAGECACHE *elt = mail_elt (stream,msgno);
  936.   SEARCHHEADER *hdr;
  937.   SEARCHOR *or;
  938.   SEARCHPGMLIST *not;
  939.   if (pgm->msgno || pgm->uid) { /* message set searches */
  940.     SEARCHSET *set;
  941. /* message sequences */
  942.     if (set = pgm->msgno) { /* must be inside this sequence */
  943.       while (set) { /* run down until find matching range */
  944. if (set->last ? ((msgno < set->first) || (msgno > set->last)) :
  945.     msgno != set->first) set = set->next;
  946. else break;
  947.       }
  948.       if (!set) return NIL; /* not found within sequence */
  949.     }
  950.     if (set = pgm->uid) { /* must be inside this sequence */
  951.       unsigned long uid = mail_uid (stream,msgno);
  952.       while (set) { /* run down until find matching range */
  953. if (set->last ? ((uid < set->first) || (uid > set->last)) :
  954.     uid != set->first) set = set->next;
  955. else break;
  956.       }
  957.       if (!set) return NIL; /* not found within sequence */
  958.     }
  959.   }
  961.   /* Fast data searches */
  962. /* message flags */
  963.   if ((pgm->answered && !elt->answered) ||
  964.       (pgm->unanswered && elt->answered) ||
  965.       (pgm->deleted && !elt->deleted) ||
  966.       (pgm->undeleted && elt->deleted) ||
  967.       (pgm->draft && !elt->draft) ||
  968.       (pgm->undraft && elt->draft) ||
  969.       (pgm->flagged && !elt->flagged) ||
  970.       (pgm->unflagged && elt->flagged) ||
  971.       (pgm->recent && !elt->recent) ||
  972.       (pgm->old && elt->recent) ||
  973.       (pgm->seen && !elt->seen) ||
  974.       (pgm->unseen && elt->seen)) return NIL;
  975. /* keywords */
  976.   if ((pgm->keyword && !mail_search_keyword (stream,elt,pgm->keyword)) ||
  977.       (pgm->unkeyword && mail_search_keyword (stream,elt,pgm->unkeyword)))
  978.     return NIL;
  979.   if (ov) { /* only do this if real searching */
  980.     MESSAGECACHE delt;
  981. /* size ranges */
  982.     if ((pgm->larger && (ov->optional.octets <= pgm->larger)) ||
  983. (pgm->smaller && (ov->optional.octets >= pgm->smaller))) return NIL;
  984. /* date ranges */
  985.     if ((pgm->sentbefore || pgm->senton || pgm->sentsince ||
  986.  (pgm->before || pgm->on || pgm->since)) &&
  987. (!mail_parse_date (&delt,ov->date) ||
  988.  !(d = (delt.year << 9) + (delt.month << 5) + delt.day) ||
  989.  (pgm->sentbefore && (d >= pgm->sentbefore)) ||
  990.  (pgm->senton && (d != pgm->senton)) ||
  991.  (pgm->sentsince && (d < pgm->sentsince)) ||
  992.  (pgm->before && (d >= pgm->before)) ||
  993.  (pgm->on && (d != pgm->on)) ||
  994.  (pgm->since && (d < pgm->since)))) return NIL;
  995.     if ((pgm->from && !mail_search_addr (ov->from,pgm->from)) ||
  996. (pgm->subject && !mail_search_header_text (ov->subject,pgm->subject))||
  997. (pgm->message_id &&
  998.  !mail_search_header_text (ov->message_id,pgm->message_id)) ||
  999. (pgm->references &&
  1000.  !mail_search_header_text (ov->references,pgm->references)))
  1001.       return NIL;
  1004. /* envelope searches */
  1005.     if (pgm->bcc || pgm->cc || pgm->to || pgm->return_path || pgm->sender ||
  1006. pgm->reply_to || pgm->in_reply_to || pgm->newsgroups ||
  1007. pgm->followup_to) {
  1008.       ENVELOPE *env = mail_fetchenvelope (stream,msgno);
  1009.       if (!env) return NIL; /* no envelope obtained */
  1010. /* search headers */
  1011.       if ((pgm->bcc && !mail_search_addr (env->bcc,pgm->bcc)) ||
  1012.   (pgm->cc && !mail_search_addr (env->cc,pgm->cc)) ||
  1013.   (pgm->to && !mail_search_addr (env->to,pgm->to)))
  1014. return NIL;
  1015.       /* These criteria are not supported by IMAP and have to be emulated */
  1016.       if ((pgm->return_path &&
  1017.    !mail_search_addr (env->return_path,pgm->return_path)) ||
  1018.   (pgm->sender && !mail_search_addr (env->sender,pgm->sender)) ||
  1019.   (pgm->reply_to && !mail_search_addr (env->reply_to,pgm->reply_to)) ||
  1020.   (pgm->in_reply_to &&
  1021.    !mail_search_header_text (env->in_reply_to,pgm->in_reply_to)) ||
  1022.   (pgm->newsgroups &&
  1023.    !mail_search_header_text (env->newsgroups,pgm->newsgroups)) ||
  1024.   (pgm->followup_to &&
  1025.    !mail_search_header_text (env->followup_to,pgm->followup_to)))
  1026. return NIL;
  1027.     }
  1029. /* search header lines */
  1030.     for (hdr = pgm->header; hdr; hdr = hdr->next) {
  1031.       char *t,*e,*v;
  1032.       SIZEDTEXT s;
  1033.       STRINGLIST sth,stc;
  1034.       sth.next = stc.next = NIL;/* only one at a time */
  1035.       sth.text.data = hdr->line.data;
  1036.       sth.text.size = hdr->line.size;
  1037. /* get the header text */
  1038.       if ((t = mail_fetch_header (stream,msgno,NIL,&sth,&s.size,
  1039.   FT_INTERNAL | FT_PEEK)) && strchr (t,':')) {
  1040. if (hdr->text.size) { /* anything matches empty search string */
  1041. /* non-empty, copy field data */
  1042.   s.data = (unsigned char *) fs_get (s.size + 1);
  1043. /* for each line */
  1044.   for (v = (char *) s.data, e = t + s.size; t < e;) switch (*t) {
  1045.   default: /* non-continuation, skip leading field name */
  1046.     while ((t < e) && (*t++ != ':'));
  1047.     if ((t < e) && (*t == ':')) t++;
  1048.   case 't': case ' ': /* copy field data  */
  1049.     while ((t < e) && (*t != '15') && (*t != '12')) *v++ = *t++;
  1050.     *v++ = 'n'; /* tie off line */
  1051.     while (((*t == '15') || (*t == '12')) && (t < e)) t++;
  1052.   }
  1053. /* calculate true size */
  1054.   s.size = v - (char *) s.data;
  1055.   *v = ''; /* tie off results */
  1056.   stc.text.data = hdr->text.data;
  1057.   stc.text.size = hdr->text.size;
  1058. /* search header */
  1059.   if (mail_search_header (&s,&stc)) fs_give ((void **) &s.data);
  1060.   else { /* search failed */
  1061.     fs_give ((void **) &s.data);
  1062.     return NIL;
  1063.   }
  1064. }
  1065.       }
  1066.       else return NIL; /* no matching header text */
  1067.     }
  1068. /* search strings */
  1069.     if ((pgm->text &&
  1070.  !mail_search_text (stream,msgno,NIL,pgm->text,LONGT))||
  1071. (pgm->body && !mail_search_text (stream,msgno,NIL,pgm->body,NIL)))
  1072.       return NIL;
  1073.   }
  1074. /* logical conditions */
  1075.   for (or = pgm->or; or; or = or->next)
  1076.     if (!(nntp_search_msg (stream,msgno,or->first,ov) ||
  1077.   nntp_search_msg (stream,msgno,or->second,ov))) return NIL;
  1078.   for (not = pgm->not; not; not = not->next)
  1079.     if (nntp_search_msg (stream,msgno,not->pgm,ov)) return NIL;
  1080.   return T;
  1081. }
  1083. /* NNTP sort messages
  1084.  * Accepts: mail stream
  1085.  *     character set
  1086.  *     search program
  1087.  *     sort program
  1088.  *     option flags
  1089.  * Returns: vector of sorted message sequences or NIL if error
  1090.  */
  1092. unsigned long *nntp_sort (MAILSTREAM *stream,char *charset,SEARCHPGM *spg,
  1093.   SORTPGM *pgm,long flags)
  1094. {
  1095.   unsigned long i,start,last;
  1096.   SORTCACHE **sc;
  1097.   mailcache_t mailcache = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL);
  1098.   unsigned long *ret = NIL;
  1099.   sortresults_t sr = (sortresults_t) mail_parameters (NIL,GET_SORTRESULTS,NIL);
  1100.   if (spg) { /* only if a search needs to be done */
  1101.     int silent = stream->silent;
  1102.     stream->silent = T; /* don't pass up mm_searched() events */
  1103. /* search for messages */
  1104.     mail_search_full (stream,charset,spg,NIL);
  1105.     stream->silent = silent; /* restore silence state */
  1106.   }
  1107. /* initialize progress counters */
  1108.   pgm->nmsgs = pgm->progress.cached = 0;
  1109. /* pass 1: count messages to sort */
  1110.   for (i = 1,start = last = 0; i <= stream->nmsgs; ++i)
  1111.     if (mail_elt (stream,i)->searched) {
  1112.       pgm->nmsgs++;
  1113. /* have this in the sortcache already? */
  1114.       if (!((SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE))->date) {
  1115. /* no, record as last message */
  1116. last = mail_uid (stream,i);
  1117. /* and as first too if needed */
  1118. if (!start) start = last;
  1119.       }
  1120.     }
  1121.   if (pgm->nmsgs) { /* pass 2: load sort cache */
  1122.     sc = nntp_sort_loadcache (stream,pgm,start,last,flags);
  1123. /* pass 3: sort messages */
  1124.     if (!pgm->abort) ret = mail_sort_cache (stream,pgm,sc,flags);
  1125.     fs_give ((void **) &sc); /* don't need sort vector any more */
  1126.   }
  1127. /* empty sort results */
  1128.   else ret = (unsigned long *) memset (fs_get (sizeof (unsigned long)),0,
  1129.        sizeof (unsigned long));
  1130. /* also return via callback if requested */
  1131.   if (sr) (*sr) (stream,ret,pgm->nmsgs);
  1132.   return ret;
  1133. }
  1135. /* Mail load sortcache
  1136.  * Accepts: mail stream, already searched
  1137.  *     sort program
  1138.  *     first UID to XOVER
  1139.  *     last UID to XOVER
  1140.  *     option flags
  1141.  * Returns: vector of sortcache pointers matching search
  1142.  */
  1144. SORTCACHE **nntp_sort_loadcache (MAILSTREAM *stream,SORTPGM *pgm,
  1145.  unsigned long start,unsigned long last,
  1146.  long flags)
  1147. {
  1148.   unsigned long i;
  1149.   char c,*s,*t,*v,tmp[MAILTMPLEN];
  1150.   SORTPGM *pg;
  1151.   SORTCACHE **sc,*r;
  1152.   MESSAGECACHE telt;
  1153.   ADDRESS *adr = NIL;
  1154.   mailcache_t mailcache = (mailcache_t) mail_parameters (NIL,GET_CACHE,NIL);
  1155. /* verify that the sortpgm is OK */
  1156.   for (pg = pgm; pg; pg = pg->next) switch (pg->function) {
  1157.   case SORTARRIVAL: /* sort by arrival date */
  1158.   case SORTSIZE: /* sort by message size */
  1159.   case SORTDATE: /* sort by date */
  1160.   case SORTFROM: /* sort by first from */
  1161.   case SORTSUBJECT: /* sort by subject */
  1162.     break;
  1163.   case SORTTO: /* sort by first to */
  1164.     mm_notify (stream,"[NNTPSORT] Can't do To-field sorting in NNTP",WARN);
  1165.     break;
  1166.   case SORTCC: /* sort by first cc */
  1167.     mm_notify (stream,"[NNTPSORT] Can't do cc-field sorting in NNTP",WARN);
  1168.     break;
  1169.   default:
  1170.     fatal ("Unknown sort function");
  1171.   }
  1173.   if (start) { /* messages need to be loaded in sortcache? */
  1174. /* yes, build range */
  1175.     if (start != last) sprintf (tmp,"%lu-%lu",start,last);
  1176.     else sprintf (tmp,"%lu",start);
  1177. /* get it from the NNTP server */
  1178.     if (!nntp_send (LOCAL->nntpstream,"XOVER",tmp) == NNTPOVER)
  1179. /* ugh, have to get it the slow way */
  1180.       return mail_sort_loadcache (stream,pgm);
  1181.     while ((s = net_getline (LOCAL->nntpstream->netstream)) && strcmp (s,".")){
  1182. /* death to embedded newlines */
  1183.       for (t = v = s; c = *v++;) if ((c != '12') && (c != '15')) *t++ = c;
  1184.       *t++ = ''; /* tie off resulting string */
  1185. /* parse XOVER response */
  1186.       if ((i = mail_msgno (stream,atol (s))) &&
  1187.   (t = strchr (s,'t')) && (v = strchr (++t,'t'))) {
  1188. *v++ = ''; /* tie off subject */
  1189. /* put stripped subject in sortcache */
  1190. (r = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE))->subject =
  1191.   mail_strip_subject (t);
  1192. if (t = strchr (v,'t')) {
  1193.   *t++ = ''; /* tie off from */
  1194.   if (adr = rfc822_parse_address (&adr,adr,&v,BADHOST,0)) {
  1195.     r->from = adr->mailbox;
  1196.     adr->mailbox = NIL;
  1197.     mail_free_address (&adr);
  1198.   }
  1199.   if (v = strchr (t,'t')) {
  1200.     *v++ = ''; /* tie off date */
  1201.     if (mail_parse_date (&telt,t)) r->date = mail_longdate (&telt);
  1202.     if ((v = strchr (v,'t')) && (v = strchr (++v,'t')))
  1203.       r->size = atol (++v);
  1204.   }
  1205. }
  1206.       }
  1207.       fs_give ((void **) &s);
  1208.     }
  1209.     if (s) fs_give ((void **) &s);
  1210.   }
  1212. /* calculate size of sortcache index */
  1213.   i = pgm->nmsgs * sizeof (SORTCACHE *);
  1214. /* instantiate the index */
  1215.   sc = (SORTCACHE **) memset (fs_get ((size_t) i),0,(size_t) i);
  1216. /* see what needs to be loaded */
  1217.   for (i = 1; !pgm->abort && (i <= stream->nmsgs); i++)
  1218.     if ((mail_elt (stream,i))->searched) {
  1219.       sc[pgm->progress.cached++] =
  1220. r = (SORTCACHE *) (*mailcache) (stream,i,CH_SORTCACHE);
  1221.       r->pgm = pgm; /* note sort program */
  1222.       r->num = (flags & SE_UID) ? mail_uid (stream,i) : i;
  1223.       if (!r->date) r->date = r->num;
  1224.       if (!r->arrival) r->arrival = mail_uid (stream,i);
  1225.       if (!r->size) r->size = 1;
  1226.       if (!r->from) r->from = cpystr ("");
  1227.       if (!r->to) r->to = cpystr ("");
  1228.       if (!r->cc) r->cc = cpystr ("");
  1229.       if (!r->subject) r->subject = cpystr ("");
  1230.     }
  1231.   return sc;
  1232. }
  1235. /* NNTP thread messages
  1236.  * Accepts: mail stream
  1237.  *     thread type
  1238.  *     character set
  1239.  *     search program
  1240.  *     option flags
  1241.  * Returns: thread node tree
  1242.  */
  1244. THREADNODE *nntp_thread (MAILSTREAM *stream,char *type,char *charset,
  1245.  SEARCHPGM *spg,long flags)
  1246. {
  1247.   return mail_thread_msgs (stream,type,charset,spg,flags,nntp_sort);
  1248. }
  1250. /* NNTP ping mailbox
  1251.  * Accepts: MAIL stream
  1252.  * Returns: T if stream alive, else NIL
  1253.  */
  1255. long nntp_ping (MAILSTREAM *stream)
  1256. {
  1257.   return (nntp_send (LOCAL->nntpstream,"STAT",NIL) != NNTPSOFTFATAL);
  1258. }
  1261. /* NNTP check mailbox
  1262.  * Accepts: MAIL stream
  1263.  */
  1265. void nntp_check (MAILSTREAM *stream)
  1266. {
  1267. /* never do if no updates */
  1268.   if (LOCAL->dirty) newsrc_write (LOCAL->name,stream);
  1269.   LOCAL->dirty = NIL;
  1270. }
  1273. /* NNTP expunge mailbox
  1274.  * Accepts: MAIL stream
  1275.  */
  1277. void nntp_expunge (MAILSTREAM *stream)
  1278. {
  1279.   if (!stream->silent) mm_log ("Expunge ignored on readonly mailbox",NIL);
  1280. }
  1282. /* NNTP copy message(s)
  1283.  * Accepts: MAIL stream
  1284.  *     sequence
  1285.  *     destination mailbox
  1286.  *     option flags
  1287.  * Returns: T if copy successful, else NIL
  1288.  */
  1290. long nntp_copy (MAILSTREAM *stream,char *sequence,char *mailbox,long options)
  1291. {
  1292.   mailproxycopy_t pc =
  1293.     (mailproxycopy_t) mail_parameters (stream,GET_MAILPROXYCOPY,NIL);
  1294.   if (pc) return (*pc) (stream,sequence,mailbox,options);
  1295.   mm_log ("Copy not valid for NNTP",ERROR);
  1296.   return NIL;
  1297. }
  1300. /* NNTP append message from stringstruct
  1301.  * Accepts: MAIL stream
  1302.  *     destination mailbox
  1303.  *     stringstruct of messages to append
  1304.  * Returns: T if append successful, else NIL
  1305.  */
  1307. long nntp_append (MAILSTREAM *stream,char *mailbox,char *flags,char *date,
  1308.   STRING *message)
  1309. {
  1310.   mm_log ("Append not valid for NNTP",ERROR);
  1311.   return NIL;
  1312. }
  1314. /* NNTP open connection
  1315.  * Accepts: network driver
  1316.  *     service host list
  1317.  *     port number
  1318.  *     service name
  1319.  *     NNTP open options
  1320.  * Returns: SEND stream on success, NIL on failure
  1321.  */
  1323. SENDSTREAM *nntp_open_full (NETDRIVER *dv,char **hostlist,char *service,
  1324.     unsigned long port,long options)
  1325. {
  1326.   SENDSTREAM *stream = NIL;
  1327.   NETSTREAM *netstream;
  1328.   NETMBX mb;
  1329.   char tmp[MAILTMPLEN];
  1330.   long reply;
  1331.   if (!(hostlist && *hostlist)) mm_log ("Missing NNTP service host",ERROR);
  1332.   else do { /* try to open connection */
  1333.     sprintf (tmp,"{%.1000s/%.20s}",*hostlist,service ? service : "nntp");
  1334.     if (!mail_valid_net_parse (tmp,&mb) || mb.anoflag || mb.secflag) {
  1335.       sprintf (tmp,"Invalid host specifier: %.80s",*hostlist);
  1336.       mm_log (tmp,ERROR);
  1337.     }
  1338.     else {
  1339. /* light tryalt flag if requested */
  1340.       mb.tryaltflag = (options & OP_TRYALT) ? T : NIL;
  1341.       if (netstream = /* try to open ordinary connection */
  1342.   net_open (&mb,dv,nntp_port ? nntp_port : port,
  1343.     (NETDRIVER *) mail_parameters (NIL,GET_ALTDRIVER,NIL),
  1344.     (char *) mail_parameters (NIL,GET_ALTNNTPNAME,NIL),
  1345.     (unsigned long)mail_parameters(NIL,GET_ALTNNTPPORT,NIL))) {
  1346. stream = (SENDSTREAM *) fs_get (sizeof (SENDSTREAM));
  1347. /* initialize stream */
  1348. memset ((void *) stream,0,sizeof (SENDSTREAM));
  1349. stream->netstream = netstream;
  1350. stream->debug = (mb.dbgflag || (options & OP_DEBUG)) ? T : NIL;
  1351. /* get server greeting */
  1352. switch ((int) (reply = nntp_reply (stream))) {
  1353. case NNTPGREET: /* allow posting */
  1354.   NNTP.post = T;
  1355.   mm_notify (NIL,stream->reply + 4,(long) NIL);
  1356.   break;
  1357. case NNTPGREETNOPOST: /* posting not allowed, must be readonly */
  1358.   if (options & OP_READONLY) {
  1359.     mm_notify (NIL,stream->reply + 4,(long) NIL);
  1360.     break;
  1361.   }
  1362. /* falls through */
  1363. default: /* anything else is an error */
  1364.   mm_log (stream->reply,ERROR);
  1365.   stream = nntp_close (stream);
  1366. }
  1367.       }
  1368.     }
  1369.   } while (!stream && *++hostlist);
  1371. /* have a session, log in if have user name */
  1372.   if (mb.user[0] && !nntp_send_auth_work (stream,&mb,tmp)) {
  1373.     nntp_close (stream); /* punt stream */
  1374.     return NIL;
  1375.   }
  1376. /* in case server demands MODE READER */
  1377.   if (stream) switch ((int) nntp_send_work (stream,"MODE","READER")) {
  1378.   case NNTPWANTAUTH: /* server wants auth first, do so and retry */
  1379.   case NNTPWANTAUTH2:
  1380.     if (nntp_send_auth_work(stream,&mb,tmp)) nntp_send(stream,"MODE","READER");
  1381.     else stream = nntp_close (stream);
  1382.     break;
  1383.   default: /* only authenticate if requested */
  1384.     if (mb.user[0] && !nntp_send_auth_work (stream,&mb,tmp))
  1385.       stream = nntp_close (stream);
  1386.     break;
  1387.   }
  1388.   return stream;
  1389. }
  1391. /* NNTP close connection
  1392.  * Accepts: SEND stream
  1393.  * Returns: NIL always
  1394.  */
  1396. SENDSTREAM *nntp_close (SENDSTREAM *stream)
  1397. {
  1398.   if (stream) { /* send "QUIT" */
  1399.     if (stream->netstream) { /* only if a living stream */
  1400.       nntp_send (stream,"QUIT",NIL);
  1401. /* close NET connection */
  1402.       net_close (stream->netstream);
  1403.     }
  1404.     if (stream->reply) fs_give ((void **) &stream->reply);
  1405.     fs_give ((void **) &stream);/* flush the stream */
  1406.   }
  1407.   return NIL;
  1408. }
  1410. /* NNTP deliver news
  1411.  * Accepts: SEND stream
  1412.  *     message envelope
  1413.  *     message body
  1414.  * Returns: T on success, NIL on failure
  1415.  */
  1417. long nntp_mail (SENDSTREAM *stream,ENVELOPE *env,BODY *body)
  1418. {
  1419.   long ret;
  1420.   char *s,path[MAILTMPLEN],tmp[8*MAILTMPLEN];
  1421.   /* Gabba gabba hey, we need some brain damage to send netnews!!!
  1422.    *
  1423.    * First, we give ourselves a frontal lobotomy, and put in some UUCP
  1424.    *  syntax.  It doesn't matter that it's completely bogus UUCP, and
  1425.    *  that UUCP has nothing to do with anything we're doing.  It's been
  1426.    *  alleged that "Path: not-for-mail" is all that's needed, but without
  1427.    *  proof, it's probably not safe to make assumptions.
  1428.    *
  1429.    * Second, we bop ourselves on the head with a ball-peen hammer.  How
  1430.    *  dare we be so presumptious as to insert a *comment* in a Date:
  1431.    *  header line.  Why, we were actually trying to be nice to a human
  1432.    *  by giving a symbolic timezone (such as PST) in addition to a
  1433.    *  numeric timezone (such as -0800).  But the gods of news transport
  1434.    *  will have none of this.  Unix weenies, tried and true, rule!!!
  1435.    *
  1436.    * Third, Netscape Collabra server doesn't give the NNTPWANTAUTH error
  1437.    *  until after requesting and receiving the entire message.  So we can't
  1438.    *  call rely upon nntp_send()'s to do the auth retry.
  1439.    */
  1440. /* RFC-1036 requires this cretinism */
  1441.   sprintf (path,"Path: %s!%s1512",net_localhost (stream->netstream),
  1442.    env->sender ? env->sender->mailbox :
  1443.    (env->from ? env->from->mailbox : "not-for-mail"));
  1444. /* here's another cretinism */
  1445.   if (s = strstr (env->date," (")) *s = NIL;
  1446.   do if ((ret = nntp_send_work (stream,"POST",NIL)) == NNTPREADY)
  1447. /* output data, return success status */
  1448.     ret = (net_soutr (stream->netstream,path) &&
  1449.    rfc822_output (tmp,env,body,nntp_soutr,stream->netstream,T)) ?
  1450.      nntp_send_work (stream,".",NIL) :
  1451.        nntp_fake (stream,NNTPSOFTFATAL,
  1452.   "NNTP connection broken (message text)");
  1453.   while (((ret == NNTPWANTAUTH) || (ret == NNTPWANTAUTH2)) &&
  1454.  nntp_send_auth (stream));
  1455.   if (s) *s = ' '; /* put the comment in the date back */
  1456.   return ret;
  1457. }
  1459. /* NNTP send command
  1460.  * Accepts: SEND stream
  1461.  *     text
  1462.  * Returns: reply code
  1463.  */
  1465. long nntp_send (SENDSTREAM *stream,char *command,char *args)
  1466. {
  1467.   long ret;
  1468.   switch ((int) (ret = nntp_send_work (stream,command,args))) {
  1469.   case NNTPWANTAUTH: /* authenticate and retry */
  1470.   case NNTPWANTAUTH2:
  1471.     if (nntp_send_auth (stream)) ret = nntp_send_work (stream,command,args);
  1472.     else { /* we're probably hosed, nuke the session */
  1473.       nntp_send (stream,"QUIT",NIL);
  1474. /* close net connection */
  1475.       net_close (stream->netstream);
  1476.       stream->netstream = NIL;
  1477.     }
  1478.   default: /* all others just return */
  1479.     break;
  1480.   }
  1481.   return ret;
  1482. }
  1485. /* NNTP send command worker routine
  1486.  * Accepts: SEND stream
  1487.  *     text
  1488.  * Returns: reply code
  1489.  */
  1491. long nntp_send_work (SENDSTREAM *stream,char *command,char *args)
  1492. {
  1493.   char tmp[MAILTMPLEN];
  1494. /* build the complete command */
  1495.   if (args) sprintf (tmp,"%s %s",command,args);
  1496.   else strcpy (tmp,command);
  1497.   if (stream->debug) mm_dlog (tmp);
  1498.   strcat (tmp,"1512");
  1499. /* send the command */
  1500.   return net_soutr (stream->netstream,tmp) ? nntp_reply (stream) :
  1501.     nntp_fake (stream,NNTPSOFTFATAL,"NNTP connection broken (command)");
  1502. }
  1504. /* NNTP send authentication if needed
  1505.  * Accepts: SEND stream
  1506.  * Returns: T if need to redo command, NIL otherwise
  1507.  */
  1509. long nntp_send_auth (SENDSTREAM *stream)
  1510. {
  1511.   NETMBX mb;
  1512.   char tmp[MAILTMPLEN];
  1513.   sprintf (tmp,"{%s/nntp}<none>",net_host (stream->netstream));
  1514.   mail_valid_net_parse (tmp,&mb);
  1515.   return nntp_send_auth_work (stream,&mb,tmp);
  1516. }
  1519. /* NNTP send authentication worker routine
  1520.  * Accepts: SEND stream
  1521.  *     NETMBX structure
  1522.  *     temporary buffer
  1523.  * Returns: T if authenticated, NIL otherwise
  1524.  */
  1526. long nntp_send_auth_work (SENDSTREAM *stream,NETMBX *mb,char *tmp)
  1527. {
  1528.   long i;
  1529.   long trial = 0;
  1530.   do { /* get user name and password */
  1531.     mm_login (mb,mb->user,tmp,trial++);
  1532.     if (!*tmp) { /* abort if he refused to give password */
  1533.       mm_log ("Login aborted",ERROR);
  1534.       break;
  1535.     }
  1536. /* do the authentication */
  1537.     if ((i = nntp_send_work (stream,"AUTHINFO USER",mb->user)) == NNTPWANTPASS)
  1538.       i = nntp_send_work (stream,"AUTHINFO PASS",tmp);
  1539. /* successful authentication */
  1540.     if (i == NNTPAUTHED) return T;
  1541.     mm_log (stream->reply,WARN);
  1542.   }
  1543.   while ((i != NNTPSOFTFATAL) && (trial < nntp_maxlogintrials));
  1544.   mm_log ("Too many NNTP authentication failures",ERROR);
  1545.   return NIL; /* authentication failed */
  1546. }
  1548. /* NNTP get reply
  1549.  * Accepts: SEND stream
  1550.  * Returns: reply code
  1551.  */
  1553. long nntp_reply (SENDSTREAM *stream)
  1554. {
  1555. /* flush old reply */
  1556.   if (stream->reply) fs_give ((void **) &stream->reply);
  1557.    /* get reply */
  1558.   if (!(stream->reply = net_getline (stream->netstream)))
  1559.     return nntp_fake(stream,NNTPSOFTFATAL,"NNTP connection broken (response)");
  1560.   if (stream->debug) mm_dlog (stream->reply);
  1561. /* handle continuation by recursion */
  1562.   if (stream->reply[3] == '-') return nntp_reply (stream);
  1563. /* return response code */
  1564.   return stream->replycode = atol (stream->reply);
  1565. }
  1568. /* NNTP set fake error
  1569.  * Accepts: SEND stream
  1570.  *     NNTP error code
  1571.  *     error text
  1572.  * Returns: error code
  1573.  */
  1575. long nntp_fake (SENDSTREAM *stream,long code,char *text)
  1576. {
  1577. /* flush any old reply */
  1578.   if (stream->reply) fs_give ((void **) &stream->reply);
  1579.    /* set up pseudo-reply string */
  1580.   stream->reply = (char *) fs_get (20+strlen (text));
  1581.   sprintf (stream->reply,"%ld %s",code,text);
  1582.   return code; /* return error code */
  1583. }
  1585. /* NNTP filter mail
  1586.  * Accepts: stream
  1587.  *     string
  1588.  * Returns: T on success, NIL on failure
  1589.  */
  1591. long nntp_soutr (void *stream,char *s)
  1592. {
  1593.   char c,*t;
  1594. /* "." on first line */
  1595.   if (s[0] == '.') net_soutr (stream,".");
  1596. /* find lines beginning with a "." */
  1597.   while (t = strstr (s,"1512.")) {
  1598.     c = *(t += 3); /* remember next character after "." */
  1599.     *t = ''; /* tie off string */
  1600. /* output prefix */
  1601.     if (!net_soutr (stream,s)) return NIL;
  1602.     *t = c; /* restore delimiter */
  1603.     s = t - 1; /* push pointer up to the "." */
  1604.   }
  1605. /* output remainder of text */
  1606.   return *s ? net_soutr (stream,s) : T;
  1607. }