home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / com / utils / smplnews / patches.os2 < prev    next >
Encoding:
Text File  |  1992-08-09  |  156.6 KB  |  5,668 lines
  1. diff -cb orig/active.c new/active.c
  2. *** orig/active.c    Thu Jun 11 22:48:12 1992
  3. --- new/active.c    Sun Aug 09 01:39:15 1992
  4. ***************
  5. *** 1,5 ****
  6.   /*
  7. !     SNEWS 1.0
  8.   
  9.       active.c - routines to manipulate the active and ng files
  10.   
  11. --- 1,5 ----
  12.   /*
  13. !     SNEWS 2.0
  14.   
  15.       active.c - routines to manipulate the active and ng files
  16.   
  17. ***************
  18. *** 122,127 ****
  19. --- 122,128 ----
  20.       }
  21.   
  22.       this->next = NULL;
  23. +     head->groups = ct;
  24.   
  25.       local_head = head;
  26.   
  27. ***************
  28. *** 181,187 ****
  29.        *  of the linked list.
  30.        */
  31.       char        fn[80], buf[81], *p;
  32. !     POST_GROUPS *this, *head = NULL ;
  33.       int         ct = 0;
  34.       FILE        *ngf;
  35.   
  36. --- 182,188 ----
  37.        *  of the linked list.
  38.        */
  39.       char        fn[80], buf[81], *p;
  40. !     POST_GROUPS *this = NULL, *head = NULL ;
  41.       int         ct = 0;
  42.       FILE        *ngf;
  43.   
  44. ***************
  45. *** 215,221 ****
  46.                   exit(1);
  47.               }
  48.   
  49. - 
  50.               if ((p = strtok(buf, " \n\r\t")) == NULL) {
  51.                   fprintf(stderr, "newsgroup 'ng' file corrupt at line %d\n", ct);
  52.                   exit(1);
  53. --- 216,221 ----
  54. ***************
  55. *** 222,231 ****
  56. --- 222,234 ----
  57.               }
  58.   
  59.               strcpy(this->group, p);
  60. +             this -> local = isupper(*this -> group);
  61. +             strlwr(this -> group);
  62.           }
  63.   
  64.       }
  65.   
  66. +     if ( this )
  67.           this->next = NULL;
  68.   
  69.       fclose(ngf);
  70. ***************
  71. *** 281,286 ****
  72. --- 284,305 ----
  73.   }
  74.   
  75.   
  76. + int is_local_group(char *ng)
  77. + {
  78. +     POST_GROUPS *this;
  79. + 
  80. +     this = pg;
  81. + 
  82. +     while (this != NULL) {
  83. +         if (strcmp(ng, this->group) == 0)
  84. +             return(this->local);
  85. +         this = this->next;
  86. +     }
  87. + 
  88. +     return (TRUE);
  89. + }
  90. + 
  91. + 
  92.   
  93.   
  94.   /*-------------------- find a newsgroup in active list ----------------------*/
  95. ***************
  96. *** 481,486 ****
  97. --- 500,506 ----
  98.   
  99.               ct = 0;
  100.   
  101. +             if (act->read_list)
  102.                   for (i = 0; i < articles; i++) {
  103.                       if(*((act->read_list)+i)) {
  104.                           ct++;
  105. ***************
  106. *** 515,521 ****
  107.   
  108.       int  res = 0;
  109.       int  i;
  110. !     char buf[256];
  111.       char *fn, *p, *v;
  112.       FILE *tmp;
  113.   
  114. --- 535,541 ----
  115.   
  116.       int  res = 0;
  117.       int  i;
  118. !     char buf[256], confdir[256];
  119.       char *fn, *p, *v;
  120.       FILE *tmp;
  121.   
  122. ***************
  123. *** 531,538 ****
  124.       if (my_stuff.news_dir[ strlen(my_stuff.news_dir)-1 ] != '\\')
  125.           strcat(my_stuff.news_dir, "\\");
  126.   
  127. - 
  128. - 
  129.       /* read the system file first */
  130.       for (i = 0; i < 2; i++) {
  131.   
  132. --- 551,556 ----
  133. ***************
  134. *** 554,563 ****
  135.   
  136.               while (fgets(buf, 255, tmp)) {
  137.                   p = strtok(buf, " =\r\n");
  138. !                 if (*p != '#') {
  139.   
  140.                       v = strtok(NULL, " =\r\n");
  141.   
  142.                       if (stricmp(p, "mailserv") == 0) {
  143.                           strcpy(my_stuff.mail_server, v);
  144.                           res++;
  145. --- 572,584 ----
  146.   
  147.               while (fgets(buf, 255, tmp)) {
  148.                   p = strtok(buf, " =\r\n");
  149. !                 if (p && *p != '#') {
  150.   
  151.                       v = strtok(NULL, " =\r\n");
  152.   
  153. +                     if (stricmp(p, "confdir") == 0)
  154. +                         strcpy(confdir, v);
  155. + 
  156.                       if (stricmp(p, "mailserv") == 0) {
  157.                           strcpy(my_stuff.mail_server, v);
  158.                           res++;
  159. ***************
  160. *** 572,577 ****
  161. --- 593,604 ----
  162.                               strcat(my_stuff.incoming_dir, "\\");
  163.                           res++;
  164.                       }
  165. +                     if (stricmp(p, "spooldir") == 0) {
  166. +                         strcpy(my_stuff.spool_dir, v);
  167. +                         if (my_stuff.spool_dir[ strlen(my_stuff.spool_dir)-1 ] != '\\')
  168. +                             strcat(my_stuff.spool_dir, "\\");
  169. +                         res++;
  170. +                     }
  171.                       if (stricmp(p, "domain") == 0) {
  172.                           strcpy(my_stuff.my_domain, v);
  173.                           res++;
  174. ***************
  175. *** 578,584 ****
  176.                       }
  177.                       if (stricmp(p, "tempdir") == 0) {
  178.                           strcpy(my_stuff.temp_name, v);
  179. -                         strcat(my_stuff.temp_name, "\\$unbatch");
  180.                           res++;
  181.                       }
  182.                       if (stricmp(p, "mailbox") == 0) {
  183. --- 605,610 ----
  184. ***************
  185. *** 634,640 ****
  186.           }
  187.       }
  188.   
  189. !     return(res == 11);
  190.   }
  191.   
  192.   
  193. --- 660,677 ----
  194.           }
  195.       }
  196.   
  197. !     if ( (p = getenv("LOGNAME")) != NULL ) {
  198. !         struct passwd *pwd;
  199. !         if ( (pwd = getpwnam(p, confdir)) != NULL ) {
  200. !             strcpy(my_stuff.user, pwd -> pw_name);
  201. !             strcpy(my_stuff.home, pwd -> pw_dir);
  202. !             strcpy(my_stuff.my_name, pwd -> pw_gecos);
  203. !             if (my_stuff.home[ strlen(my_stuff.home)-1 ] != '\\')
  204. !                 strcat(my_stuff.home, "\\");
  205. !         }
  206. !     }
  207. ! 
  208. !     return(res >= 12);
  209.   }
  210.   
  211.   
  212. ***************
  213. *** 657,663 ****
  214.       (gp->hi_num)++;
  215.       update_active_entry(gp);
  216.   
  217. !     if ((tmp = fopen(fn, "r+b")) == NULL) {
  218.           fprintf(stderr,"active: cannot open text file %s\n", fn);
  219.           exit(1);
  220.       }
  221. --- 694,700 ----
  222.       (gp->hi_num)++;
  223.       update_active_entry(gp);
  224.   
  225. !     if ((tmp = flockopen(fn, "r+b")) == NULL) {
  226.           fprintf(stderr,"active: cannot open text file %s\n", fn);
  227.           exit(1);
  228.       }
  229. ***************
  230. *** 664,671 ****
  231.       fseek(tmp, 0, SEEK_END);
  232.   
  233.       return(tmp);
  234. - 
  235. - 
  236.   }
  237.   
  238.   
  239. --- 701,706 ----
  240. ***************
  241. *** 685,691 ****
  242.       fn = make_news_group_name(gp->group);
  243.       sprintf(fnx, "%s.IDX", fn);
  244.   
  245. !     if((tmp = fopen(fnx, "r+b")) == NULL) {
  246.           fprintf(stderr, "active: cannot open index file %s\n", fn);
  247.           exit(1);
  248.       }
  249. --- 720,726 ----
  250.       fn = make_news_group_name(gp->group);
  251.       sprintf(fnx, "%s.IDX", fn);
  252.   
  253. !     if((tmp = flockopen(fnx, "r+b")) == NULL) {
  254.           fprintf(stderr, "active: cannot open index file %s\n", fn);
  255.           exit(1);
  256.       }
  257. ***************
  258. *** 692,698 ****
  259.       fseek(tmp, 0, SEEK_END);
  260.   
  261.       return(tmp);
  262. - 
  263.   }
  264.   
  265.   
  266. --- 727,732 ----
  267. ***************
  268. *** 712,724 ****
  269.       strcpy(fn, my_stuff.news_dir);
  270.       strcat(fn, "nseq");
  271.   
  272. !     if ((seq_file = fopen(fn, "r+")) != NULL) {
  273.           fscanf(seq_file, "%d", &seq);
  274.           seq++;
  275.           rewind(seq_file);
  276.       } else {
  277.           seq = 0;
  278. !         seq_file = fopen(fn, "wt");
  279.       }
  280.   
  281.       fprintf(seq_file, "%d", seq);
  282. --- 746,758 ----
  283.       strcpy(fn, my_stuff.news_dir);
  284.       strcat(fn, "nseq");
  285.   
  286. !     if ((seq_file = flockopen(fn, "r+t")) != NULL) {
  287.           fscanf(seq_file, "%d", &seq);
  288.           seq++;
  289.           rewind(seq_file);
  290.       } else {
  291.           seq = 0;
  292. !         seq_file = flockopen(fn, "wt");
  293.       }
  294.   
  295.       fprintf(seq_file, "%d", seq);
  296. ***************
  297. *** 733,739 ****
  298.   {
  299.       void *p;
  300.       if ((p = malloc(size)) == NULL) {
  301. -         gotoxy(1,25);
  302.           fprintf(stderr, "\n\nSORRY - NO MEMORY LEFT \n");
  303.           exit(1);
  304.       }
  305. --- 767,772 ----
  306. diff -cb orig/addgroup.c new/addgroup.c
  307. *** orig/addgroup.c    Thu Jun 11 22:48:13 1992
  308. --- new/addgroup.c    Sun Aug 02 20:34:18 1992
  309. ***************
  310. *** 1,5 ****
  311.   /*
  312. !     SNEWS 1.0
  313.   
  314.       addgroup - add a new newsgroup
  315.   
  316. --- 1,5 ----
  317.   /*
  318. !     SNEWS 2.0
  319.   
  320.       addgroup - add a new newsgroup
  321.   
  322. ***************
  323. *** 46,51 ****
  324. --- 46,53 ----
  325.       FILE   *active_file, *new_active_file;
  326.   
  327.   
  328. +     fprintf(stderr, "ADDGROUP: (%s)\n\n", VERSION);
  329. + 
  330.       if (argc > 1) {
  331.   
  332.           if (!load_stuff()) {
  333. ***************
  334. *** 74,81 ****
  335.                   fprintf(stderr, "addgroup: cannot create file %s\n", buf);
  336.                   exit(1);
  337.               }
  338. -         }
  339.               fclose(tmp);
  340.           sprintf(buf, "%snewsbase\\00000000.idx", my_stuff.news_dir);
  341.           if (access(buf, 0) != 0) {
  342.               if ((tmp = fopen(buf, "wb")) == NULL) {
  343. --- 76,83 ----
  344.                   fprintf(stderr, "addgroup: cannot create file %s\n", buf);
  345.                   exit(1);
  346.               }
  347.               fclose(tmp);
  348. +         }
  349.           sprintf(buf, "%snewsbase\\00000000.idx", my_stuff.news_dir);
  350.           if (access(buf, 0) != 0) {
  351.               if ((tmp = fopen(buf, "wb")) == NULL) {
  352. ***************
  353. *** 82,89 ****
  354.                   fprintf(stderr, "addgroup: cannot create file %s\n", buf);
  355.                   exit(1);
  356.               }
  357. -         }
  358.               fclose(tmp);
  359.   
  360.           load_active_file();
  361.           close_active();
  362. --- 84,91 ----
  363.                   fprintf(stderr, "addgroup: cannot create file %s\n", buf);
  364.                   exit(1);
  365.               }
  366.               fclose(tmp);
  367. +         }
  368.   
  369.           load_active_file();
  370.           close_active();
  371. ***************
  372. *** 180,186 ****
  373.   
  374.   
  375.               } else {
  376. !                 fprintf(stderr, "addgroup: newsgroup %s already exists\n", argv[1]);
  377.               }
  378.   
  379.           }
  380. --- 182,188 ----
  381.   
  382.   
  383.               } else {
  384. !                 fprintf(stderr, "addgroup: newsgroup %s already exists\n", argv[i]);
  385.               }
  386.   
  387.           }
  388. ***************
  389. *** 188,194 ****
  390.           close_active_file();
  391.   
  392.       } else {
  393. !         printf("USAGE: addgroup  newsgroup names....\n");
  394.       }
  395.   
  396.   }
  397. --- 190,196 ----
  398.           close_active_file();
  399.   
  400.       } else {
  401. !         printf("usage: addgroup  newsgroup names....\n");
  402.       }
  403.   
  404.   }
  405. Only in new: amatch.c
  406. diff -cb orig/article.c new/article.c
  407. *** orig/article.c    Thu Jun 11 22:48:13 1992
  408. --- new/article.c    Sun Aug 02 20:34:18 1992
  409. ***************
  410. *** 1,6 ****
  411.   /*
  412.   
  413. !     SNEWS 1.0
  414.   
  415.       news - routines to read and display an article
  416.   
  417. --- 1,6 ----
  418.   /*
  419.   
  420. !     SNEWS 2.0
  421.   
  422.       news - routines to read and display an article
  423.   
  424. ***************
  425. *** 24,33 ****
  426.    */
  427.   
  428.   
  429.   #include "defs.h"
  430.   #include "snews.h"
  431.   
  432. ! #include <io.h>
  433.   
  434.   /*------------------------- read in an article -----------------------------*/
  435.   TEXT *load_article(char *fnx, long offset)
  436. --- 24,74 ----
  437.    */
  438.   
  439.   
  440. + #include <process.h>
  441. + 
  442.   #include "defs.h"
  443.   #include "snews.h"
  444.   
  445. ! 
  446. ! /*------------------------- recognize address ------------------------------*/
  447. ! char *plain_address(char *raw)
  448. ! {
  449. !   char *ptr = raw, *end;
  450. ! 
  451. !   while (*ptr && !isalnum(*ptr)) {
  452. ! 
  453. !     while (isspace(*ptr)) ptr++;
  454. ! 
  455. !     if (isalnum(*ptr))
  456. !       break;
  457. ! 
  458. !     if (*ptr == '(') {
  459. !       for (ptr++; *ptr && *ptr != ')'; ptr++);
  460. !       if (*ptr == ')') ptr++;
  461. !     }
  462. !     else if (*ptr == '"') {
  463. !       for (ptr++; *ptr && *ptr != '"'; ptr++);
  464. !       if (*ptr == '"') ptr++;
  465. !     }
  466. !     else if (*ptr == '<') {
  467. !       ptr++;
  468. !       if ((end = strchr(ptr, '>')) != NULL)
  469. !     *end = 0;
  470. !     }
  471. !     else
  472. !       ptr++;
  473. !   }
  474. ! 
  475. !   if ((end = strchr(ptr, ' ')) != NULL)
  476. !     *end = 0;
  477. !   if ((end = strchr(ptr, '\t')) != NULL)
  478. !     *end = 0;
  479. !   if ((end = strchr(ptr, '\n')) != NULL)
  480. !     *end = 0;
  481. ! 
  482. !   return ptr;
  483. ! }
  484. ! 
  485.   
  486.   /*------------------------- read in an article -----------------------------*/
  487.   TEXT *load_article(char *fnx, long offset)
  488. ***************
  489. *** 38,44 ****
  490.        */
  491.   
  492.       FILE *tmp_file;
  493. !     char buf[256], lnbuf[256], *p;
  494.       TEXT *tx;
  495.       LINE *ln, *lz;
  496.       int  ct, i;
  497. --- 79,85 ----
  498.        */
  499.   
  500.       FILE *tmp_file;
  501. !     char lnbuf[MAXLINE];
  502.       TEXT *tx;
  503.       LINE *ln, *lz;
  504.       int  ct, i;
  505. ***************
  506. *** 46,91 ****
  507.       tx = NULL;
  508.       ct = 0;
  509.   
  510. !     if ((tmp_file = fopen(fnx, "rb")) != NULL) {
  511.   
  512.           fseek(tmp_file, offset, SEEK_SET);
  513.   
  514.           tx = xmalloc(sizeof(TEXT));
  515.           tx->top = NULL;
  516.           tx->start = NULL;
  517. !         strcpy(tx->follow_up, "");
  518. !         strcpy(tx->author, " ** none ** ");
  519. !         strcpy(tx->organisation, " ** none ** ");
  520. ! 
  521. !         while (fgets(buf, 255, tmp_file) != NULL) {
  522.   
  523. !             if (strncmp(buf, "@@@@END", 7) == 0) break;
  524.   
  525. !             expand_tabs(buf, 255);
  526.   
  527. !             /*
  528. !              *  We now have a line of input.  If the line is two long
  529. !              *  it is wrapped at spaces or '!'.  The lines of text are
  530. !              *  stored in LINE structures
  531. !              */
  532. !             p = &buf[0];
  533. !             while (strlen(p) > 0) {
  534. ! 
  535. !                 strcpy(lnbuf, p);
  536. !                 if (strlen(p) <= 80) {
  537. !                     strcpy(lnbuf, p);
  538. !                     *p = '\x00';
  539. !                 } else {
  540. !                     p += 79;
  541. !                     for (i = 79; i > 50; i--) {
  542. !                         if ((lnbuf[i] == ' ') || (lnbuf[i] == '!'))
  543. !                             break;
  544. !                         p--;
  545. !                     }
  546. !                     lnbuf[i] = '\x00';
  547. !                 }
  548.   
  549. !                 /* is it the first line - if so int the TEXT structure */
  550.                   if (ct == 0) {
  551.                       ln = xmalloc(sizeof(LINE));
  552.                       ln->last = NULL;
  553. --- 87,112 ----
  554.       tx = NULL;
  555.       ct = 0;
  556.   
  557. !     if ((tmp_file = flockopen(fnx, "rb")) != NULL) {
  558.   
  559. +         setvbuf(tmp_file, iobuf, _IOFBF, IOBUFSIZE);
  560.           fseek(tmp_file, offset, SEEK_SET);
  561.   
  562.           tx = xmalloc(sizeof(TEXT));
  563.           tx->top = NULL;
  564.           tx->start = NULL;
  565. !         tx->subject = NULL;
  566. !         tx->follow_up = NULL;
  567. !         tx->author = NULL;
  568. !         tx->organisation = NULL;
  569.   
  570. !         while (fgets(lnbuf, sizeof(lnbuf) - 1, tmp_file) != NULL) {
  571.   
  572. !             lnbuf[sizeof(lnbuf) -1] = 0;
  573.   
  574. !             if (strncmp(lnbuf, "@@@@END", 7) == 0) break;
  575.   
  576. !             /* is it the first line - if so init the TEXT structure */
  577.               if (ct == 0) {
  578.                   ln = xmalloc(sizeof(LINE));
  579.                   ln->last = NULL;
  580. ***************
  581. *** 97,104 ****
  582.                       ln->last = lz;
  583.                   }
  584.   
  585. -                 lnbuf[79] = '\x00';
  586.                   ln->index = ct;
  587.                   strcpy(ln->data, lnbuf);
  588.   
  589.                   if ((strlen(lnbuf) == 1) && (tx->start == NULL))
  590. --- 118,125 ----
  591.                   ln->last = lz;
  592.               }
  593.   
  594.               ln->index = ct;
  595. +             ln->data = xmalloc(strlen(lnbuf) + 1);
  596.               strcpy(ln->data, lnbuf);
  597.   
  598.               if ((strlen(lnbuf) == 1) && (tx->start == NULL))
  599. ***************
  600. *** 108,130 ****
  601.   
  602.                   /* save the header info */
  603.                   if ((tx->start == NULL) && (strncmp("From:", lnbuf, 5) == 0)) {
  604. !                     eat_gunk(lnbuf);
  605. !                     lnbuf[WHO_LENGTH-1] = '\x00';
  606.                       strcpy(tx->author, lnbuf);
  607.                   }
  608.                   if ((tx->start == NULL) &&
  609.                     ((strncmp("Organisation:", lnbuf, 13) == 0) ||
  610.                     (strncmp("Organization:", lnbuf, 13) == 0))) {
  611. !                     eat_gunk(lnbuf);
  612. !                     lnbuf[WHO_LENGTH-1] = '\x00';
  613. !                     strcpy(tx->organisation, lnbuf);
  614.                   }
  615.   
  616. !                 if ((tx->start == NULL) && (strncmp("Followup-To:", lnbuf, 12) == 0)) {
  617. !                     eat_gunk(lnbuf);
  618. !                     lnbuf[79] = '\x00';
  619. !                     strcpy(tx->follow_up, lnbuf);
  620.                   }
  621.               }
  622.   
  623.           }
  624. --- 129,156 ----
  625.   
  626.               /* save the header info */
  627.               if ((tx->start == NULL) && (strncmp("From:", lnbuf, 5) == 0)) {
  628. !                 strcpy(lnbuf, plain_address(lnbuf + 5));
  629. !                 tx->author = xmalloc(strlen(lnbuf) + 1);
  630.                   strcpy(tx->author, lnbuf);
  631.               }
  632.               if ((tx->start == NULL) &&
  633.                 ((strncmp("Organisation:", lnbuf, 13) == 0) ||
  634.                  (strncmp("Organization:", lnbuf, 13) == 0))) {
  635. !                 lnbuf[strlen(lnbuf) - 1] = 0;
  636. !                 tx->organisation = xmalloc(strlen(lnbuf + 14) + 1);
  637. !                 strcpy(tx->organisation, lnbuf + 14);
  638.               }
  639.   
  640. !             if ((tx->start == NULL) && (strncmp("Subject:", lnbuf, 8) == 0)) {
  641. !                 lnbuf[strlen(lnbuf) - 1] = 0;
  642. !                 tx->subject = xmalloc(strlen(lnbuf + 9) + 1);
  643. !                 strcpy(tx->subject, lnbuf + 9);
  644.               }
  645. + 
  646. +             if ((tx->start == NULL) && (strncmp("Followup-To:", lnbuf, 12) == 0)) {
  647. +                 lnbuf[strlen(lnbuf) - 1] = 0;
  648. +                 tx->follow_up = xmalloc(strlen(lnbuf + 13) + 1);
  649. +                 strcpy(tx->follow_up, lnbuf + 13);
  650.               }
  651.   
  652.           }
  653. ***************
  654. *** 150,165 ****
  655.       while (l != NULL) {
  656.           k = l;
  657.           l = l->next;
  658.           free(k);
  659.       }
  660.   
  661.       free(t);
  662.   }
  663.   
  664.   
  665.   
  666.   /*---------------------------- read an article ----------------------------*/
  667. ! int read_article(ACTIVE *gp, TEXT *tx, char *subject, int a_ct, int of_ct)
  668.   {
  669.       /*
  670.        *  This routine alloas the user to read an article
  671. --- 176,222 ----
  672.       while (l != NULL) {
  673.           k = l;
  674.           l = l->next;
  675. +         free(k->data);
  676.           free(k);
  677.       }
  678.   
  679. +     if (t->subject)
  680. +         free(t->subject);
  681. +     if (t->follow_up)
  682. +         free(t->follow_up);
  683. +     if (t->author)
  684. +         free(t->author);
  685. +     if (t->organisation)
  686. +         free(t->organisation);
  687.       free(t);
  688.   }
  689.   
  690.   
  691. + /*---------------------------- display a line -----------------------------*/
  692. + void putline(char *line, int margin)
  693. + {
  694. +     char buf[MAXLINE];
  695. +     int length;
  696. + 
  697. +     strcpy(buf, line);
  698. +     expand_tabs(buf, MAXLINE);
  699. +     length = strlen(buf);
  700. + 
  701. +     if ( length > margin ) {
  702. +         if ( length > margin + _columns )
  703. +             printf("%-*.*s$", _columns - 1, _columns - 1, buf + margin);
  704. +         else {
  705. +             puts(buf + margin);
  706. +         if ( length - margin < _columns )
  707. +           clreol();
  708. +         }
  709. +     }
  710. +     else
  711. +         clreol();
  712. + }
  713.   
  714.   /*---------------------------- read an article ----------------------------*/
  715. ! int read_article(ACTIVE *gp, TEXT *tx, int a_ct, int of_ct)
  716.   {
  717.       /*
  718.        *  This routine alloas the user to read an article
  719. ***************
  720. *** 167,179 ****
  721.   
  722.       LINE   *this, *tmp;   /* current thread                    */
  723.       int    exit_code;     /* why we are exiting the loop      */
  724. !     char   sub_tmp[80];
  725. ! 
  726. !     int    ch, i;
  727.   
  728.       this = tx->start;
  729.       exit_code = 0;
  730. !     show_article(gp, tx, subject, this, a_ct, of_ct);
  731.   
  732.       while ((exit_code == 0) || (exit_code == EX_DUMMY)) {
  733.   
  734. --- 224,239 ----
  735.   
  736.       LINE   *this, *tmp;   /* current thread                    */
  737.       int    exit_code;     /* why we are exiting the loop      */
  738. !     char   buf[MAXLINE];
  739. !     int    ch, i, maxx, margin, newmargin;
  740.   
  741.       this = tx->start;
  742. +     if (this->next != NULL)
  743. +         this = this->next;
  744. + 
  745.       exit_code = 0;
  746. !     margin = 0;
  747. !     show_article(gp, tx, this, a_ct, of_ct, margin);
  748.   
  749.       while ((exit_code == 0) || (exit_code == EX_DUMMY)) {
  750.   
  751. ***************
  752. *** 182,211 ****
  753.           switch (ch) {
  754.   
  755.               case 0      :
  756. !                 ch = getch();
  757.               
  758.                   switch (ch) {
  759.   
  760.                       case UP_ARR :
  761.                           if (this->last != NULL) {
  762.                               this = this->last;
  763. -                             gotoxy(1,TEXT_LINE+PAGE_LENGTH-1);
  764. -                             delline();
  765.                               gotoxy(1,TEXT_LINE);
  766.                               insline();
  767. !                             clreol();
  768. !                             cputs(this->data);
  769. !                             exit_code = EX_DUMMY;
  770.                           }
  771.                           break;
  772.   
  773.                       case DN_ARR :
  774. !                         if (this->next != NULL) {
  775.                               this = this->next;
  776.                               gotoxy(1,TEXT_LINE);
  777.                               delline();
  778.                               gotoxy(1,TEXT_LINE+PAGE_LENGTH-1);
  779. -                             insline();
  780.   
  781.                               tmp = this;
  782.                               for (i = 0; i < PAGE_LENGTH-1; i++) {
  783. --- 242,321 ----
  784.           switch (ch) {
  785.   
  786.               case 0      :
  787. !             case 0xE0   :
  788.               
  789. +                 ch = getch();
  790.                   switch (ch) {
  791.   
  792. +                     case F1     :
  793. +                         show_help(HELP_ARTICLES);
  794. +                         break;
  795. + 
  796. +                     case L_ARR  :
  797. +                         if ( margin == 0 )
  798. +                             exit_code = EX_DUMMY;
  799. +                         else
  800. +                             margin = max(0, margin - 4);
  801. +                         break;
  802. + 
  803. +                     case C_L_ARR  :
  804. +                         if ( margin == 0 )
  805. +                             exit_code = EX_DUMMY;
  806. +                         else
  807. +                             margin = 0;
  808. +                         break;
  809. + 
  810. +                     case R_ARR  :
  811. +                         tmp = this;
  812. +                         newmargin = margin;
  813. +                         for (i = 0; i < PAGE_LENGTH-1; i++) {
  814. +                             strcpy(buf, tmp->data);
  815. +                             expand_tabs(buf, MAXLINE);
  816. +                             newmargin = max(newmargin, strlen(buf));
  817. +                             tmp = tmp->next;
  818. +                             if (tmp == NULL) break;
  819. +                         }
  820. +                         if ( margin >= newmargin - _columns )
  821. +                             exit_code = EX_DUMMY;
  822. +                         else
  823. +                             margin += 4;
  824. +                         break;
  825. + 
  826. +                     case C_R_ARR  :
  827. +                         tmp = this;
  828. +                         newmargin = margin;
  829. +                         for (i = 0; i < PAGE_LENGTH-1; i++) {
  830. +                             strcpy(buf, tmp->data);
  831. +                             expand_tabs(buf, MAXLINE);
  832. +                             newmargin = max(newmargin, strlen(buf));
  833. +                             tmp = tmp->next;
  834. +                             if (tmp == NULL) break;
  835. +                         }
  836. +                         newmargin = ((newmargin - 1) / 4 + 1) * 4;
  837. +                         if ( newmargin == margin + _columns )
  838. +                             exit_code = EX_DUMMY;
  839. +                         else
  840. +                             margin = newmargin - _columns;
  841. +                         break;
  842. + 
  843.                       case UP_ARR :
  844.                           if (this->last != NULL) {
  845.                               this = this->last;
  846.                               gotoxy(1,TEXT_LINE);
  847.                               insline();
  848. !                             putline(this->data, margin);
  849.                           }
  850. +                         exit_code = EX_DUMMY;
  851.                           break;
  852.   
  853.                       case DN_ARR :
  854. !                         if (this->next != NULL &&
  855. !                             (this->index + PAGE_LENGTH < tx->lines ||
  856. !                              this->index <= tx->start->index)) {
  857.                               this = this->next;
  858.                               gotoxy(1,TEXT_LINE);
  859.                               delline();
  860.                               gotoxy(1,TEXT_LINE+PAGE_LENGTH-1);
  861.   
  862.                               tmp = this;
  863.                               for (i = 0; i < PAGE_LENGTH-1; i++) {
  864. ***************
  865. *** 213,225 ****
  866.                                   if (tmp == NULL) break;
  867.                               }
  868.   
  869. !                             clreol();
  870. !                             cputs(tmp->data);
  871.                               exit_code = EX_DUMMY;
  872.                           }
  873.                           break;
  874.   
  875.                       case PGUP   :
  876.                               for (i = 0; i < PAGE_LENGTH-1; i++) {
  877.                                   if (this->last == NULL) break;
  878.                                   this = this->last;
  879. --- 323,362 ----
  880.                                   if (tmp == NULL) break;
  881.                               }
  882.   
  883. !                             if (tmp)
  884. !                                 putline(tmp->data, margin);
  885. !                         }
  886. !                         exit_code = EX_DUMMY;
  887. !                         break;
  888. ! 
  889. !                     case HOME   :
  890. !                         tmp = this;
  891. !                         this = tx->start;
  892. !                         if (this->next != NULL)
  893. !                             this = this->next;
  894. !                         if (this == tmp)
  895.                               exit_code = EX_DUMMY;
  896. +                         break;
  897. + 
  898. +                     case END    :
  899. +                         tmp = this;
  900. +                         this = tx->start;
  901. +                         while (this->next != NULL)
  902. +                             this = this->next;
  903. +                         for (i = 0; i < PAGE_LENGTH-1; i++) {
  904. +                             if (this->last == NULL) break;
  905. +                             if (tx->start->next && this == tx->start->next)
  906. +                                 break;
  907. +                             this = this->last;
  908.                           }
  909. +                         if (this == tmp)
  910. +                             exit_code = EX_DUMMY;
  911.                           break;
  912.   
  913.                       case PGUP   :
  914. +                         if ( this->last == NULL )
  915. +                             exit_code = EX_DUMMY;
  916. +                         else
  917.                               for (i = 0; i < PAGE_LENGTH-1; i++) {
  918.                                   if (this->last == NULL) break;
  919.                                   this = this->last;
  920. ***************
  921. *** 227,280 ****
  922.                           break;
  923.   
  924.                       case PGDN   :
  925. !                         for (i = 0; i < PAGE_LENGTH-2; i++) {
  926.                                       if (this->next == NULL) break;
  927.                                       this = this->next;
  928.                                   }
  929.                           break;
  930.   
  931. !                     case HOME   :
  932. !                         this = tx->start;
  933. !                         break;
  934. !                     case END    :
  935. !                         this = tx->start;
  936. !                         while (this->next != NULL)
  937. !                             this = this->next;
  938.                           break;
  939.                   }
  940.                   break;
  941.   
  942.               case 'p'    :
  943. !                 strcpy(sub_tmp, "");
  944. !                 post(NULL, gp->group, sub_tmp);
  945.                   break;
  946.   
  947.               case 'f'    :
  948. !                 if (strcmp(tx->follow_up, "") == 0)
  949. !                     post(tx, gp->group, subject);
  950.                   else
  951. !                     post(tx, tx->follow_up, subject);
  952.                   break;
  953.   
  954.               case 'r'    :
  955. !                 reply_to_article(tx, subject);
  956.                   break;
  957.   
  958.               case 'm'    :
  959.                   mail_to_someone(tx);
  960.                   break;
  961.   
  962.               case 's'    :
  963.                   save_to_disk(tx);
  964. -                 message("-- Done --");
  965.                   break;
  966.   
  967.               case 'x'    :
  968.                   rot13(tx);
  969.                   break;
  970.   
  971. -             case '?'    :
  972.               case 'h'    :
  973.                   show_help(HELP_ARTICLES);
  974.                   break;
  975.   
  976. --- 364,427 ----
  977.                           break;
  978.   
  979.                       case PGDN   :
  980. !                         if ( this->next == NULL )
  981. !                             exit_code = EX_DUMMY;
  982. !                         else {
  983. !                             maxx = tx->lines - this->index - PAGE_LENGTH;
  984. !                             maxx = min(maxx, PAGE_LENGTH - 1);
  985. !                             maxx = max(maxx, tx->start->index + 1 - this->index);
  986. ! 
  987. !                             if ( maxx <= 0 )
  988. !                                 exit_code = EX_DUMMY;
  989. !                             else
  990. !                                 for (i = 0; i < maxx; i++) {
  991.                                       if (this->next == NULL) break;
  992.                                       this = this->next;
  993.                                   }
  994. +                         }
  995.                           break;
  996.   
  997. !                     default:
  998. !                         exit_code = EX_DUMMY;
  999.                           break;
  1000.                   }
  1001.                   break;
  1002.   
  1003.               case 'p'    :
  1004. !             case 'P'    :
  1005. !                 post(NULL, gp->group);
  1006.                   break;
  1007.   
  1008.               case 'f'    :
  1009. !             case 'F'    :
  1010. !                 if (!tx->follow_up || strcmp(tx->follow_up, "") == 0)
  1011. !                     post(tx, gp->group);
  1012.                   else
  1013. !                     post(tx, tx->follow_up);
  1014.                   break;
  1015.   
  1016.               case 'r'    :
  1017. !             case 'R'    :
  1018. !                 reply_to_article(tx);
  1019.                   break;
  1020.   
  1021.               case 'm'    :
  1022. +             case 'M'    :
  1023.                   mail_to_someone(tx);
  1024.                   break;
  1025.   
  1026.               case 's'    :
  1027. +             case 'S'    :
  1028.                   save_to_disk(tx);
  1029.                   break;
  1030.   
  1031.               case 'x'    :
  1032. +             case 'X'    :
  1033.                   rot13(tx);
  1034.                   break;
  1035.   
  1036.               case 'h'    :
  1037. +             case 'H'    :
  1038.                   show_help(HELP_ARTICLES);
  1039.                   break;
  1040.   
  1041. ***************
  1042. *** 286,297 ****
  1043.                   exit_code = EX_NEXT;
  1044.                   break;
  1045.   
  1046.               case ESCAPE :
  1047.                   exit_code = EX_QUIT;
  1048.                   break;
  1049.           };
  1050.           if (exit_code == 0)
  1051. !             show_article(gp, tx, subject, this, a_ct, of_ct);
  1052.       }
  1053.   
  1054.       return(exit_code);
  1055. --- 433,470 ----
  1056.                   exit_code = EX_NEXT;
  1057.                   break;
  1058.   
  1059. +             case BACKSP :
  1060. +                 exit_code = EX_PREVIOUS;
  1061. +                 break;
  1062. + 
  1063. +         case '+'    :
  1064. +         case '/'    :
  1065. +                 exit_code = EX_SEARCH_FORW;
  1066. +         break;
  1067. + 
  1068. +         case '-'    :
  1069. +         case '?'    :
  1070. +                 exit_code = EX_SEARCH_BACKW;
  1071. +         break;
  1072. + 
  1073.               case ESCAPE :
  1074.                   exit_code = EX_QUIT;
  1075.                   break;
  1076. + 
  1077. +             default:
  1078. +                 exit_code = EX_DUMMY;
  1079. +                 break;
  1080.           };
  1081. + 
  1082.           if (exit_code == 0)
  1083. !             show_article(gp, tx, this, a_ct, of_ct, margin);
  1084. !         else {
  1085. !             gotoxy(_columns - 16,2);
  1086. !             textbackground(LIGHTGRAY);  textcolor(BLACK);
  1087. !             sprintf(buf, "Line %d of %d", this->index + 1, tx->lines);
  1088. !             printf("%17s", buf);
  1089. !             textbackground(BLACK);  textcolor(LIGHTGRAY);
  1090. !         }
  1091.       }
  1092.   
  1093.       return(exit_code);
  1094. ***************
  1095. *** 300,346 ****
  1096.   
  1097.   
  1098.   /*-------------------- show the list of active groups -----------------------*/
  1099. ! void show_article(ACTIVE *gp, TEXT *tx, char *subject, LINE *this, int a_ct,
  1100. !                   int of_ct)
  1101.   {
  1102.       /*
  1103.        *  This routine show a page of an article
  1104.        */
  1105.   
  1106. !     int    i;
  1107. !     char   buf[60];
  1108. ! 
  1109. ! 
  1110. ! 
  1111. !     clrscr();
  1112. !     strcpy(buf, subject);
  1113. !     buf[49] = '\x00';
  1114. ! 
  1115.   
  1116.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  1117. !     clreol();
  1118. !     cprintf("Group: %-30s                         Article: %2d of %2d\r\n",
  1119. !            gp->group, a_ct, of_ct);
  1120. !     clreol();
  1121. !     cprintf("Subject: %-50s          %4d lines\r\n", buf, tx->lines);
  1122. !     clreol();
  1123. !     cprintf("From: %s; %s", tx->author, tx->organisation);
  1124.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  1125.   
  1126. - 
  1127. -     gotoxy(1, TEXT_LINE);
  1128.       for (i = 0; i < PAGE_LENGTH; i++) {
  1129.           gotoxy(1, i+TEXT_LINE);
  1130. !         cputs(this->data);
  1131.           this = this->next;
  1132. -         if (this == NULL) break;
  1133.       }
  1134.   
  1135. !     command("ESC=select thread   TAB=next unread   ENTER=next   ?=help");
  1136. ! }
  1137. ! 
  1138. ! 
  1139.   
  1140.   
  1141.   
  1142.   /*-------------------------- save article --------------------------------*/
  1143. --- 473,521 ----
  1144.   
  1145.   
  1146.   /*-------------------- show the list of active groups -----------------------*/
  1147. ! void show_article(ACTIVE *gp, TEXT *tx, LINE *this, int a_ct,
  1148. !                   int of_ct, int margin)
  1149.   {
  1150.       /*
  1151.        *  This routine show a page of an article
  1152.        */
  1153.   
  1154. !     int    i, length;
  1155. !     char   buf[256], buf2[32];
  1156.   
  1157. +     gotoxy(1,1);
  1158.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  1159. !     sprintf(buf2, "Article %d of %d", a_ct, of_ct);
  1160. !     printf("Group: %-*.*s  %18s", _columns - 27, _columns - 27,
  1161. !            gp->group, buf2);
  1162. !     gotoxy(1,2);
  1163. !     strcpy(buf, tx->author ? tx->author : "<unknown>");
  1164. !     if (tx->organisation) {
  1165. !         strcat(buf, "; ");
  1166. !         strcat(buf, tx->organisation);
  1167. !     }
  1168. !     sprintf(buf2, "Line %d of %d", this->index + 1, tx->lines);
  1169. !     printf("From: %-*.*s  %17s", _columns - 25, _columns - 25, buf, buf2);
  1170. !     gotoxy(1,3);
  1171. !     sprintf(buf2, margin ? ">%d" : "", margin);
  1172. !     printf("Subject: %-*.*s %4s", _columns - 14, _columns - 14,
  1173. !            tx->subject, buf2);
  1174.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  1175.   
  1176.       for (i = 0; i < PAGE_LENGTH; i++) {
  1177. +         if (this == NULL) break;
  1178.           gotoxy(1, i+TEXT_LINE);
  1179. !         putline(this->data, margin);
  1180.           this = this->next;
  1181.       }
  1182.   
  1183. !     if ( i < PAGE_LENGTH ) {
  1184. !         gotoxy(1, i+TEXT_LINE);
  1185. !         clreos();
  1186. !     }
  1187.   
  1188. +     message("ESC=select thread   TAB=next unread   ENTER=next   F1=help");
  1189. + }
  1190.   
  1191.   
  1192.   /*-------------------------- save article --------------------------------*/
  1193. ***************
  1194. *** 352,363 ****
  1195.   
  1196.       FILE *tmp = NULL;
  1197.       LINE *ln;
  1198. !     char fn[80];
  1199.       int  ch;
  1200. ! 
  1201. ! 
  1202. !     message("Enter filename? ");
  1203.   
  1204.       gets(fn);
  1205.   
  1206.       if (access(fn, 0) == 0) {
  1207. --- 527,539 ----
  1208.   
  1209.       FILE *tmp = NULL;
  1210.       LINE *ln;
  1211. !     char fn[256];
  1212.       int  ch;
  1213. !     time_t now;
  1214. !     struct tm *tmnow;
  1215. !     char timestr[64];
  1216.   
  1217. +     lmessage("Enter filename? ");
  1218.       gets(fn);
  1219.   
  1220.       if (access(fn, 0) == 0) {
  1221. ***************
  1222. *** 366,373 ****
  1223.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1224.           if (ch == 'y') {
  1225.               if ((tmp = fopen(fn, "at")) == NULL) {
  1226. !                 message("*** Cannot open file for appending - "
  1227. !                         "please any key to continue ***");
  1228.                   getch();
  1229.               }
  1230.           }
  1231. --- 542,549 ----
  1232.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1233.           if (ch == 'y') {
  1234.               if ((tmp = fopen(fn, "at")) == NULL) {
  1235. !                 message("*** cannot open file for appending - "
  1236. !                         "press any key ***");
  1237.                   getch();
  1238.               }
  1239.           }
  1240. ***************
  1241. *** 375,388 ****
  1242.       } else {
  1243.   
  1244.           if ((tmp = fopen(fn, "wt")) == NULL) {
  1245. !             message("*** Cannot open file for output - press a key to continue ***");
  1246.               getch();
  1247.           }
  1248.   
  1249.       }
  1250.   
  1251.       if (tmp != NULL) {
  1252.   
  1253.           ln = tx->top;
  1254.           while (ln != NULL) {
  1255.               fputs(ln->data, tmp);
  1256. --- 551,578 ----
  1257.       } else {
  1258.   
  1259.           if ((tmp = fopen(fn, "wt")) == NULL) {
  1260. !             message("*** cannot open file for output - press any key  ***");
  1261.               getch();
  1262.           }
  1263.   
  1264. +     setvbuf(tmp, iobuf, _IOFBF, IOBUFSIZE);
  1265.       }
  1266.   
  1267.       if (tmp != NULL) {
  1268.   
  1269. +         time(&now);
  1270. +     tmnow = localtime(&now);
  1271. +     strftime(timestr, sizeof(timestr), "%a %b %d %H:%M:%S %z %Y", tmnow);
  1272. + 
  1273. +         ln = tx->top;
  1274. +         while (ln != NULL && strncmp(ln->data, "Path: ", 6)) {
  1275. +             ln = ln->next;
  1276. +         }
  1277. +     strcpy(fn, ln->data + 6);
  1278. +     for ( ch = strlen(fn); fn[ch - 1] == '\n' || fn[ch - 1] == '\r'; ch--)
  1279. +         fn[ch - 1] = 0;
  1280. +     fprintf(tmp, "From %s %s\n", fn, timestr);
  1281. + 
  1282.           ln = tx->top;
  1283.           while (ln != NULL) {
  1284.               fputs(ln->data, tmp);
  1285. ***************
  1286. *** 398,404 ****
  1287.   
  1288.   
  1289.   /*-------------------------- reply to article ---------------------------*/
  1290. ! void reply_to_article(TEXT *tx, char *subject)
  1291.   {
  1292.       /*
  1293.        *  Mail reply to article
  1294. --- 588,594 ----
  1295.   
  1296.   
  1297.   /*-------------------------- reply to article ---------------------------*/
  1298. ! void reply_to_article(TEXT *tx)
  1299.   {
  1300.       /*
  1301.        *  Mail reply to article
  1302. ***************
  1303. *** 405,411 ****
  1304.        */
  1305.   
  1306.   #ifdef INCLUDE_SIG
  1307. !     FILE *sig
  1308.       char sig_fn[80];
  1309.   #endif
  1310.   
  1311. --- 595,601 ----
  1312.        */
  1313.   
  1314.   #ifdef INCLUDE_SIG
  1315. !     FILE *sig;
  1316.       char sig_fn[80];
  1317.   #endif
  1318.   
  1319. ***************
  1320. *** 412,424 ****
  1321.       FILE *tmp;
  1322.       LINE *ln;
  1323.       int  ch;
  1324. !     char fn[80];
  1325.       char buf[256];
  1326. !     char author[80], msg_id[80];
  1327.   
  1328. !     strcpy(fn, "reply.tmp");
  1329.   
  1330. !     if ((tmp= fopen(fn, "wt")) != NULL) {
  1331.   
  1332.           get_his_stuff(tx, author, msg_id);
  1333.   
  1334. --- 602,620 ----
  1335.       FILE *tmp;
  1336.       LINE *ln;
  1337.       int  ch;
  1338. !     char fn[256];
  1339.       char buf[256];
  1340. !     char author[80], msg_id[MAXLINE];
  1341. !     char *mailer = getenv("MAILER");
  1342.   
  1343. !     if (mailer == NULL)
  1344. !         mailer = "mail";
  1345.   
  1346. !     strcpy(fn, my_stuff.news_dir);
  1347. !     strcat(fn, "letter");
  1348. !     unlink(fn);
  1349. ! 
  1350. !     if ((tmp = fopen(fn, "wt")) != NULL) {
  1351.   
  1352.           get_his_stuff(tx, author, msg_id);
  1353.   
  1354. ***************
  1355. *** 427,436 ****
  1356.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1357.   
  1358.           if (ch == 'y') {
  1359. !             fprintf(tmp, "\nIn article %s you write:\n\n", msg_id);
  1360.               ln = tx->start;
  1361.               while (ln != NULL) {
  1362. !                 fprintf(tmp, "  > %s", ln->data);
  1363.                   ln = ln->next;
  1364.               }
  1365.           }
  1366. --- 623,632 ----
  1367.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1368.   
  1369.           if (ch == 'y') {
  1370. !             fprintf(tmp, "In article %s you write:\n", msg_id);
  1371.               ln = tx->start;
  1372.               while (ln != NULL) {
  1373. !                 fprintf(tmp, "> %s", ln->data);
  1374.                   ln = ln->next;
  1375.               }
  1376.           }
  1377. ***************
  1378. *** 443,451 ****
  1379.           if ((sig= fopen(sig_fn, "rt")) != NULL) {
  1380.               while (fgets(buf, 79, sig) != NULL)
  1381.                   fputs(buf, tmp);
  1382. -         }
  1383. - 
  1384.               fclose(sig);
  1385.   #endif
  1386.           fclose(tmp);
  1387.   
  1388. --- 639,646 ----
  1389.           if ((sig= fopen(sig_fn, "rt")) != NULL) {
  1390.               while (fgets(buf, 79, sig) != NULL)
  1391.                   fputs(buf, tmp);
  1392.               fclose(sig);
  1393. +         }
  1394.   #endif
  1395.           fclose(tmp);
  1396.   
  1397. ***************
  1398. *** 455,470 ****
  1399.           sprintf(buf, "Send message to %s (y/n)? ", author);
  1400.           message(buf);
  1401.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1402.           if (ch == 'y') {
  1403. !             sprintf(buf, "mail -s \"Re: %s\" %s <%s", subject, author, fn);
  1404.               system(buf);
  1405.           }
  1406. !         unlink(fn);
  1407. !         message("-- Press any key to continue --");
  1408. !         getch();
  1409.   
  1410.       } else {
  1411. !         message("*** Cannot open temp file - press any key to continue ***");
  1412.           getch();
  1413.       }
  1414.   
  1415. --- 650,671 ----
  1416.           sprintf(buf, "Send message to %s (y/n)? ", author);
  1417.           message(buf);
  1418.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1419. +         gotoxy(1,PAGE_SIZE);
  1420. +         clreol();
  1421. + 
  1422. +         strcpy(msg_id, tx->subject);
  1423. +         eat_gunk(msg_id);
  1424. + 
  1425.           if (ch == 'y') {
  1426. !             sprintf(buf, "%s -s \"Re: %s\" %s <%s >nul 2>&1",
  1427. !                     mailer, msg_id, author, fn);
  1428.               system(buf);
  1429.           }
  1430. ! 
  1431. !         /* unlink(fn); /* keep it around like rn */
  1432.   
  1433.       } else {
  1434. !         message("*** cannot open temp file - press any key ***");
  1435.           getch();
  1436.       }
  1437.   
  1438. ***************
  1439. *** 484,530 ****
  1440.       FILE *tmp;
  1441.       LINE *ln;
  1442.       int  ch;
  1443. !     char fn[80];
  1444.       char buf[256], who[80];
  1445. !     char author[80], msg_id[80];
  1446.   
  1447. !     strcpy(fn, "reply.tmp");
  1448.   
  1449.       if ((tmp= fopen(fn, "wt")) != NULL) {
  1450.   
  1451. !         get_his_stuff(tx, author, msg_id);
  1452. ! 
  1453. !         /* add the quoted message */
  1454. !         command("");
  1455. !         lmessage("Who do you want to mail this article to? ");
  1456.           gets(who);
  1457.   
  1458. !         fprintf(tmp, "\nThis article was forwarded to you by %s@%s (%s):\n\n",
  1459.               my_stuff.user, my_stuff.my_domain, my_stuff.my_name);
  1460. !         fprintf(tmp,"--------------------------------- cut here -----------------------------\n\n");
  1461.           ln = tx->top;
  1462.           while (ln != NULL) {
  1463. !             fprintf(tmp, "%s", ln->data);
  1464.               ln = ln->next;
  1465.           }
  1466.   
  1467. -         fprintf(tmp,"--------------------------------- cut here -----------------------------\n\n");
  1468. - 
  1469.           fclose(tmp);
  1470.   
  1471. !         sprintf(buf, "Send message to %s (y/n)? ", who);
  1472.           message(buf);
  1473.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1474.           if (ch == 'y') {
  1475. !             sprintf(buf, "mail %s <%s", who, fn);
  1476.               system(buf);
  1477.           }
  1478.           unlink(fn);
  1479. -         message("-- Press any key to continue --");
  1480. -         getch();
  1481.   
  1482.       } else {
  1483. !         message("*** Cannot open temp file - press any key to continue ***");
  1484.           getch();
  1485.       }
  1486.   
  1487. --- 685,733 ----
  1488.       FILE *tmp;
  1489.       LINE *ln;
  1490.       int  ch;
  1491. !     char fn[256];
  1492.       char buf[256], who[80];
  1493. !     char *subj = tx->subject ? tx->subject : "No subject";
  1494.   
  1495. !     sprintf(fn, "%s\\snews.tmp", my_stuff.temp_name);
  1496.   
  1497.       if ((tmp= fopen(fn, "wt")) != NULL) {
  1498.   
  1499. !         lmessage("Mail this article to? ");
  1500.           gets(who);
  1501.   
  1502. !     fprintf(tmp, "Resent-From: %s@%s (%s)\n",
  1503.           my_stuff.user, my_stuff.my_domain, my_stuff.my_name);
  1504. !     fprintf(tmp, "Resent-To: %s\n", who);
  1505. ! 
  1506.           ln = tx->top;
  1507.           while (ln != NULL) {
  1508. !             fputs(ln->data, tmp);
  1509.               ln = ln->next;
  1510.           }
  1511.   
  1512.           fclose(tmp);
  1513.   
  1514. !         message("Edit outgoing message (y/n)? ");
  1515. !         while (((ch = getch()) != 'y') && (ch != 'n'));
  1516. ! 
  1517. !         if (ch == 'y') {
  1518. !       sprintf(buf, my_stuff.editor, fn);
  1519. !       system(buf);
  1520. !     }
  1521. ! 
  1522. !         sprintf(buf, "Mail article to %s (y/n)? ", who);
  1523.           message(buf);
  1524.           while (((ch = getch()) != 'y') && (ch != 'n'));
  1525.           if (ch == 'y') {
  1526. !             sprintf(buf, "rmail -t <%s 2>nul", fn);
  1527.               system(buf);
  1528.           }
  1529. + 
  1530.           unlink(fn);
  1531.   
  1532.       } else {
  1533. !         message("*** cannot open temp file - press any key ***");
  1534.           getch();
  1535.       }
  1536.   
  1537. ***************
  1538. *** 541,547 ****
  1539.   
  1540.       LINE *ln;
  1541.       char *p;
  1542. !     char buf[100];
  1543.       char *null_name = {" ** none ** "};
  1544.   
  1545.       strcpy(author, null_name);
  1546. --- 744,750 ----
  1547.   
  1548.       LINE *ln;
  1549.       char *p;
  1550. !     char buf[MAXLINE];
  1551.       char *null_name = {" ** none ** "};
  1552.   
  1553.       strcpy(author, null_name);
  1554. ***************
  1555. *** 549,554 ****
  1556. --- 752,759 ----
  1557.   
  1558.       ln = tx->top;
  1559.       while (ln != NULL) {
  1560. +         if (strlen(ln->data) < 2) break;
  1561. + 
  1562.           strcpy(buf, ln->data);
  1563.           p = strtok(buf, " :\n\r");
  1564.           p = strtok(NULL, " :\n\r");
  1565. ***************
  1566. *** 558,571 ****
  1567.   
  1568.           if ((strnicmp(ln->data, "From:", 5) == 0) &&
  1569.             (strcmp(author, null_name) == 0)) {
  1570. !             strcpy(author, p);
  1571.           }
  1572.   
  1573. !         if (strnicmp(ln->data, "Reply-To:", 5) == 0) {
  1574. !             strcpy(author, p);
  1575.           }
  1576.   
  1577. -         if (strlen(ln->data) < 2) break;
  1578.           ln = ln->next;
  1579.       }
  1580.   }
  1581. --- 763,775 ----
  1582.   
  1583.           if ((strnicmp(ln->data, "From:", 5) == 0) &&
  1584.             (strcmp(author, null_name) == 0)) {
  1585. !             strcpy(author, plain_address(ln->data+5));
  1586.           }
  1587.   
  1588. !         if (strnicmp(ln->data, "Reply-to:", 9) == 0) {
  1589. !             strcpy(author, plain_address(ln->data+9));
  1590.           }
  1591.   
  1592.           ln = ln->next;
  1593.       }
  1594.   }
  1595. ***************
  1596. *** 600,606 ****
  1597.   void expand_tabs(char *buf, int max_len)
  1598.   {
  1599.       int  l, k;
  1600. !     char tmp[256], *p, *t;
  1601.   
  1602.       p = buf;
  1603.       t = &tmp[0];
  1604. --- 804,810 ----
  1605.   void expand_tabs(char *buf, int max_len)
  1606.   {
  1607.       int  l, k;
  1608. !     char tmp[MAXLINE], *p, *t;
  1609.   
  1610.       p = buf;
  1611.       t = &tmp[0];
  1612. ***************
  1613. *** 625,628 ****
  1614. --- 829,836 ----
  1615.   
  1616.       *t = '\x00';
  1617.       strcpy(buf, tmp);
  1618. +     l = strlen(buf);
  1619. +     
  1620. +     if (buf[l - 1] == '\n')
  1621. +       buf[l - 1] = 0;
  1622.   }
  1623. diff -cb orig/defs.h new/defs.h
  1624. *** orig/defs.h    Thu Jun 11 22:48:14 1992
  1625. --- new/defs.h    Sun Aug 02 20:34:18 1992
  1626. ***************
  1627. *** 1,5 ****
  1628.   /*
  1629. !     SNEWS 1.0
  1630.   
  1631.       General public decls
  1632.   
  1633. --- 1,5 ----
  1634.   /*
  1635. !     SNEWS 2.0
  1636.   
  1637.       General public decls
  1638.   
  1639. ***************
  1640. *** 22,28 ****
  1641.   
  1642.    */
  1643.   
  1644. ! #include <alloc.h>
  1645.   #include <time.h>
  1646.   #include <string.h>
  1647.   #include <conio.h>
  1648. --- 22,28 ----
  1649.   
  1650.    */
  1651.   
  1652. ! #include <malloc.h>
  1653.   #include <time.h>
  1654.   #include <string.h>
  1655.   #include <conio.h>
  1656. ***************
  1657. *** 30,41 ****
  1658.   #include <stdio.h>
  1659.   #include <stdlib.h>
  1660.   #include <string.h>
  1661.   #include <sys/stat.h>
  1662. ! #include <dir.h>
  1663.   
  1664.   
  1665. - #define VERSION      "Simple NEWS 1.12"
  1666.   
  1667.   #define HIST_MEM_LIMIT  75000l  /* leave this much meme free loading history */
  1668.   
  1669.   #define ACTIVE_NUM_LEN   8      /* length of the numbers in the active file */
  1670. --- 30,47 ----
  1671.   #include <stdio.h>
  1672.   #include <stdlib.h>
  1673.   #include <string.h>
  1674. + #include <io.h>
  1675. + #include <sys/types.h>
  1676.   #include <sys/stat.h>
  1677. ! #include <direct.h>
  1678.   
  1679. + #include "os2defs.h"
  1680.   
  1681.   
  1682. + #define VERSION      "SNEWS /2 2.0"
  1683. + #define COPYRIGHT    "(c) 1991 John McCombs, (c) 1992 Kai Uwe Rommel"
  1684. + 
  1685. + 
  1686.   #define HIST_MEM_LIMIT  75000l  /* leave this much meme free loading history */
  1687.   
  1688.   #define ACTIVE_NUM_LEN   8      /* length of the numbers in the active file */
  1689. ***************
  1690. *** 43,63 ****
  1691.   #define TRUE     1
  1692.   #define FALSE    0
  1693.   
  1694.   
  1695.   /* this is the data we get from the UUPC .rc files */
  1696.   typedef struct {
  1697. !     char temp_name[80];           /* unbatch temp file             */
  1698. !     char news_dir[80];            /* news base directory           */
  1699. !     char incoming_dir[80];        /* incoming news spool directory */
  1700. !     char user[80];                /* current user id               */
  1701. !     char my_name[80];             /* my full name                  */
  1702. !     char my_domain[80];           /* our domain                    */
  1703. !     char my_site[80];             /* site name                     */
  1704. !     char my_organisation[80];     /* organisation                  */
  1705. !     char mail_server[80];         /* where posts are routed to     */
  1706. !     char editor[80];              /* system editor                 */
  1707. !     char home[80];                /* home mail directory           */
  1708. !     char signature[80];           /* signature file                */
  1709.   } INFO;
  1710.   
  1711.   
  1712. --- 49,73 ----
  1713.   #define TRUE     1
  1714.   #define FALSE    0
  1715.   
  1716. + #define IOBUFSIZE 32000
  1717. + extern char iobuf[IOBUFSIZE];
  1718.   
  1719. + 
  1720.   /* this is the data we get from the UUPC .rc files */
  1721.   typedef struct {
  1722. !     char temp_name[256];           /* unbatch temp file             */
  1723. !     char news_dir[256];            /* news base directory           */
  1724. !     char incoming_dir[256];        /* incoming news spool directory */
  1725. !     char spool_dir[256];           /* spool directory, log files    */
  1726. !     char user[256];                /* current user id               */
  1727. !     char my_name[256];             /* my full name                  */
  1728. !     char my_domain[256];           /* our domain                    */
  1729. !     char my_site[256];             /* site name                     */
  1730. !     char my_organisation[256];     /* organisation                  */
  1731. !     char mail_server[256];         /* where posts are routed to     */
  1732. !     char editor[256];              /* system editor                 */
  1733. !     char home[256];                /* home mail directory           */
  1734. !     char signature[256];           /* signature file                */
  1735.   } INFO;
  1736.   
  1737.   
  1738. ***************
  1739. *** 64,73 ****
  1740.   extern INFO my_stuff;
  1741.   
  1742.   
  1743.   /* NOTE - if hi_num and lo_num are the same there are no articles */
  1744.   typedef struct active {
  1745.       char   group[60];           /* group name                               */
  1746. !     char   gp_file[9];          /* name of the file that the data is in     */
  1747.       long   lo_num;              /* lowest number less one                   */
  1748.       long   hi_num;              /* highest number                           */
  1749.       long   num_pos;             /* file offset of the numbers               */
  1750. --- 74,96 ----
  1751.   extern INFO my_stuff;
  1752.   
  1753.   
  1754. + /*
  1755. +  *  This structure is a linked list of lines that make up an article. The
  1756. +  *  file is read in and the linked list is built
  1757. +  */
  1758. + typedef struct line {
  1759. +     char   *data;               /* line of text                */
  1760. +     struct line *next;          /* next line                   */
  1761. +     struct line *last;          /* last line                   */
  1762. +     int    index;               /* line number from start      */
  1763. + } LINE;
  1764. + 
  1765. + 
  1766. + 
  1767.   /* NOTE - if hi_num and lo_num are the same there are no articles */
  1768.   typedef struct active {
  1769.       char   group[60];           /* group name                               */
  1770. !     char   gp_file[60];         /* name of the file that the data is in     */
  1771.       long   lo_num;              /* lowest number less one                   */
  1772.       long   hi_num;              /* highest number                           */
  1773.       long   num_pos;             /* file offset of the numbers               */
  1774. ***************
  1775. *** 75,80 ****
  1776. --- 98,105 ----
  1777.       struct active *last;        /* last entry                               */
  1778.       int    index;               /* which number in the list, from 0         */
  1779.       char   *read_list;          /* array hi_num-lo_num long. TRUE=read it   */
  1780. +     int    groups;              /* filled in by load_active_file() in head  */
  1781. +     int    threads;             /* filled in by get_headers()               */
  1782.   } ACTIVE;
  1783.   
  1784.   
  1785. ***************
  1786. *** 85,90 ****
  1787. --- 110,116 ----
  1788.    */
  1789.   typedef struct post_groups {
  1790.       char   group[60];           /* group name                               */
  1791. +     int    local;               /* local news group                         */
  1792.       struct post_groups *next;   /* next entry                               */
  1793.   } POST_GROUPS;
  1794.   
  1795. Only in new: exe
  1796. diff -cb orig/expire.c new/expire.c
  1797. *** orig/expire.c    Thu Jun 11 22:48:14 1992
  1798. --- new/expire.c    Sun Aug 02 20:34:18 1992
  1799. ***************
  1800. *** 1,5 ****
  1801.   /*
  1802. !                               Simple NEWS
  1803.   
  1804.       EXPIRE - expire news database articles by number of days since rx'd
  1805.   
  1806. --- 1,5 ----
  1807.   /*
  1808. !     SNEWS 2.0
  1809.   
  1810.       EXPIRE - expire news database articles by number of days since rx'd
  1811.   
  1812. ***************
  1813. *** 30,36 ****
  1814.   
  1815.   INFO my_stuff;
  1816.   
  1817. - 
  1818.   /*------------------------------- main --------------------------------*/
  1819.   void main(int argc, char *argv[])
  1820.   {
  1821. --- 30,35 ----
  1822. ***************
  1823. *** 51,56 ****
  1824. --- 50,57 ----
  1825.       long   secs, i, offset;
  1826.       int    days;
  1827.       int    no_space;
  1828. +     int    cnt;
  1829. +     int    matches;
  1830.       long   art_time;
  1831.       long   where;
  1832.   
  1833. ***************
  1834. *** 59,102 ****
  1835.       FILE   *text;
  1836.       FILE   *old_text;
  1837.   
  1838. !     int    articles;
  1839. !     int    articles_deleted;
  1840. !     int    gp_art;
  1841. !     int    gp_art_deleted;
  1842.   
  1843. !     long   total_bytes;
  1844. !     long   total_bytes_deleted;
  1845.       long   gp_bytes;
  1846.       long   gp_bytes_deleted;
  1847.   
  1848.   
  1849. !     articles = 0;
  1850. !     articles_deleted = 0;
  1851.   
  1852. !     total_bytes = 0;
  1853. !     total_bytes_deleted = 0;
  1854.   
  1855.   
  1856. !     fprintf(stderr, "EXPIRE: (%s)\n\n", VERSION);
  1857.   
  1858. !     if (argc == 2) {
  1859.   
  1860.           if (!load_stuff()) {
  1861.               fprintf(stderr, "Couldn't read rc info\n");
  1862.           }
  1863.   
  1864.           head = load_active_file();
  1865. - 
  1866. -         time(¤t);
  1867. - 
  1868. -         days = atoi(argv[1]);
  1869. -         secs = days * 86400l;
  1870. - 
  1871.           gp = head;
  1872.   
  1873. !         printf("NEWSGROUP                           :      ARTICLES         DELETED\n\n");
  1874.   
  1875. !         while (gp != NULL) {
  1876.   
  1877.               no_space = FALSE;
  1878.   
  1879. --- 60,109 ----
  1880.       FILE   *text;
  1881.       FILE   *old_text;
  1882.   
  1883. !     long   articles = 0;
  1884. !     long   articles_deleted = 0;
  1885. !     long   gp_art;
  1886. !     long   gp_art_deleted;
  1887.   
  1888. !     long   total_bytes = 0;
  1889. !     long   total_bytes_deleted = 0;
  1890.       long   gp_bytes;
  1891.       long   gp_bytes_deleted;
  1892.   
  1893.   
  1894. !     fprintf(stderr, "EXPIRE: (%s)\n\n", VERSION);
  1895.   
  1896. !     if (argc < 2) {
  1897. !         fprintf(stderr, "usage: expire -<days> [group-pattern ...]\n");
  1898. !     exit(1);
  1899. !     }
  1900.   
  1901. +     argc--;
  1902. +     argv++;
  1903.   
  1904. !     time(¤t);
  1905.   
  1906. !     if ( **argv == '-' ) {
  1907. !         days = atoi(*argv + 1);
  1908. !         secs = days * 86400l;
  1909. !     argc--;
  1910. !     argv++;
  1911. !     } else {
  1912. !         fprintf(stderr, "usage: expire -<days> [group-pattern ...]\n");
  1913. !     exit(1);
  1914. !     }
  1915.   
  1916.       if (!load_stuff()) {
  1917.       fprintf(stderr, "Couldn't read rc info\n"); 
  1918. +     exit(1);
  1919.       }
  1920.   
  1921.       head = load_active_file();
  1922.       gp = head;
  1923.   
  1924. !     printf("%-40s :      ARTICLES         DELETED\n\n", "NEWSGROUP");
  1925.   
  1926. !     for (gp = head; gp != NULL; gp = gp->next) {
  1927.   
  1928.       no_space = FALSE;
  1929.   
  1930. ***************
  1931. *** 107,130 ****
  1932.   
  1933.               if ((gp->hi_num - gp->lo_num) > 0) {
  1934.   
  1935.                   /*
  1936.                    *  Open all the files.  First the old ones, then the new
  1937.                    */
  1938. -                 fn = make_news_group_name(gp->group);
  1939.   
  1940.                   stat(fn, &st);
  1941. -                 gp_bytes_deleted = st.st_size;
  1942.   
  1943. !                 if ((old_text = fopen(fn, "rb")) == NULL) crash("can't open old text", fn);
  1944. !                 setvbuf(old_text, NULL, _IOFBF, 16384);
  1945. !                 sprintf(buf, "%s.IDX", fn);
  1946. !                 if ((old_index = fopen(buf, "rb")) == NULL) crash("can't open old index", buf);
  1947.   
  1948. !                 sprintf(buf, "%s.NEW", fn);
  1949. !                 if ((text = fopen(buf, "wb")) == NULL) crash("can't create new text", buf);
  1950. !                 setvbuf(text, NULL, _IOFBF, 16384);
  1951. !                 sprintf(buf, "%s.NDX", fn);
  1952. !                 if ((index = fopen(buf, "wb")) == NULL) crash("can't create new index", buf);
  1953.   
  1954.                   /* numbers go chronologically */
  1955.                   for (i = (gp->lo_num)+1; i <= gp->hi_num; i++) {
  1956. --- 114,164 ----
  1957.   
  1958.       if ((gp->hi_num - gp->lo_num) > 0) {
  1959.   
  1960. +           printf("%-40s :  ", gp->group);
  1961. +           fflush(stdout);
  1962. +           
  1963.           /*
  1964.            *  Open all the files.  First the old ones, then the new
  1965.            */
  1966.   
  1967. +         fn = make_news_group_name(gp->group);
  1968.           stat(fn, &st);
  1969.   
  1970. !         if (argc) {
  1971. !         matches = FALSE;
  1972. !         for (cnt = 0; cnt < argc; cnt++)
  1973. !           if (amatch(argv[cnt], gp->group))
  1974. !             matches = TRUE;
  1975. !         } 
  1976. !         else
  1977. !           matches = TRUE;
  1978. ! 
  1979. !         if (!matches) {
  1980. !         gp_art = gp->hi_num - gp->lo_num;
  1981. !         printf("%4ld %5ld k\n", gp_art, (st.st_size+500)/1000);
  1982. !         articles += gp_art;
  1983. !         total_bytes += st.st_size;
  1984. !         continue;
  1985. !         }
  1986. ! 
  1987. !         gp_bytes_deleted = st.st_size;
  1988.   
  1989. !         if ((old_text = fopen(fn, "rb")) == NULL) 
  1990. !           crash("can't open old text", fn);
  1991. !         setvbuf(old_text, NULL, _IOFBF, IOBUFSIZE);
  1992. !         sprintf(buf, "%s.idx", fn);
  1993. !         if ((old_index = fopen(buf, "rb")) == NULL) 
  1994. !           crash("can't open old index", buf);
  1995. !         setvbuf(old_index, NULL, _IOFBF, IOBUFSIZE);
  1996. ! 
  1997. !         sprintf(buf, "%s.new", fn);
  1998. !         if ((text = fopen(buf, "wb")) == NULL) 
  1999. !           crash("can't create new text", buf);
  2000. !         setvbuf(text, NULL, _IOFBF, IOBUFSIZE);
  2001. !         sprintf(buf, "%s.ndx", fn);
  2002. !         if ((index = fopen(buf, "wb")) == NULL) 
  2003. !           crash("can't create new index", buf);
  2004. !         setvbuf(index, NULL, _IOFBF, IOBUFSIZE);
  2005.   
  2006.           /* numbers go chronologically */
  2007.           for (i = (gp->lo_num)+1; i <= gp->hi_num; i++) {
  2008. ***************
  2009. *** 138,143 ****
  2010. --- 172,179 ----
  2011.   
  2012.           /* get the time the article was processed */
  2013.           art_time = atol(buf+18);
  2014. +         /* and the subject */
  2015. +         strcpy(subject, buf+28);
  2016.   
  2017.           if ((current - art_time) > secs) {
  2018.   
  2019. ***************
  2020. *** 160,175 ****
  2021.                           /* copy to new file */
  2022.                           offset = atol(buf);
  2023.                           fseek(old_text, offset, SEEK_SET);
  2024. -                         while (fgets(buf, 255, old_text)) {
  2025.   
  2026. !                             if (strnicmp(buf,"Subject:",8) == 0) {
  2027. !                                 strcpy(subject, buf+8);
  2028. !                             }
  2029.   
  2030.                               if (fputs(buf, text) == EOF) {
  2031.                                   no_space = TRUE;
  2032.                                   break;
  2033.                               }
  2034.                               if (strnicmp(buf, "@@@@END", 7) == 0) break;
  2035.                           }
  2036.   
  2037. --- 196,209 ----
  2038.               /* copy to new file */
  2039.               offset = atol(buf);
  2040.               fseek(old_text, offset, SEEK_SET);
  2041.                 
  2042. !             while (fgets(buf, 255, old_text)) {
  2043.   
  2044.               if (fputs(buf, text) == EOF) {
  2045.                   no_space = TRUE;
  2046.                   break;
  2047.               }
  2048. +             
  2049.               if (strnicmp(buf, "@@@@END", 7) == 0) break;
  2050.               }
  2051.   
  2052. ***************
  2053. *** 190,198 ****
  2054.                   fclose(text);
  2055.                   fclose(index);
  2056.   
  2057. - 
  2058. -                 fn = make_news_group_name(gp->group);
  2059. - 
  2060.                   /* out of disk on expire, delete the temp files */
  2061.                   if (no_space) {
  2062.                       fprintf(stderr, "expire: no room to expire %s\n", gp->group);
  2063. --- 224,229 ----
  2064. ***************
  2065. *** 215,221 ****
  2066.   
  2067.                   /* print all groups with articles */
  2068.   
  2069. !                 gp_art = (int)(gp->hi_num - gp->lo_num);
  2070.                   gp_bytes_deleted -= gp_bytes;
  2071.   
  2072.                   articles += gp_art;
  2073. --- 246,252 ----
  2074.   
  2075.           /* print all groups with articles */
  2076.   
  2077. !         gp_art = gp->hi_num - gp->lo_num;
  2078.           gp_bytes_deleted -= gp_bytes;
  2079.   
  2080.           articles += gp_art;
  2081. ***************
  2082. *** 226,261 ****
  2083.                   if ((gp_art > 0) || (gp_art_deleted > 0)) {
  2084.   
  2085.                       if (gp_art_deleted > 0)
  2086. !                         printf("%-35s :  %4d %5ldKb     %4d %5ldKb\n",
  2087. !                             gp->group,
  2088.                               gp_art, (gp_bytes+500)/1000,
  2089.                               gp_art_deleted, (gp_bytes_deleted+500)/1000);
  2090.                       else
  2091. !                         printf("%-35s :  %4d %5ldKb\n",
  2092. !                             gp->group,
  2093.                               gp_art, (gp_bytes+500)/1000);
  2094.   
  2095.                   }
  2096.               }
  2097. !             gp = gp->next;
  2098.           }
  2099.   
  2100.           close_active_file();
  2101. - 
  2102.           expire_history(current, secs);
  2103.   
  2104. !         printf("\n%7d articles deleted\n"
  2105. !                "%7ld Kb deleted\n"
  2106. !                "%7d articles remaining\n"
  2107. !                "%7ld Kb of text remaining\n",
  2108.                  articles_deleted,
  2109.                  (total_bytes_deleted+500)/1000,
  2110.                  articles,
  2111.                  (total_bytes+500)/1000);
  2112.   
  2113. !     } else {
  2114. !         fprintf(stderr, "usage:  expire <days>\n");
  2115. !     }
  2116.   }
  2117.   
  2118.   
  2119. --- 257,287 ----
  2120.           if ((gp_art > 0) || (gp_art_deleted > 0)) {
  2121.   
  2122.           if (gp_art_deleted > 0)
  2123. !           printf("%4ld %5ld k     %4ld %5ld k\n",
  2124.                gp_art, (gp_bytes+500)/1000,
  2125.                gp_art_deleted, (gp_bytes_deleted+500)/1000);
  2126.           else
  2127. !           printf("%4ld %5ld k\n",
  2128.                gp_art, (gp_bytes+500)/1000);
  2129.   
  2130.           }
  2131.       }
  2132. ! 
  2133.       }
  2134.   
  2135.       close_active_file();
  2136.       expire_history(current, secs);
  2137.   
  2138. !     printf("\n%7ld articles deleted\n"
  2139. !        "%7ld k of text deleted\n"
  2140. !        "%7ld articles remaining\n"
  2141. !        "%7ld k of text remaining\n",
  2142.          articles_deleted,
  2143.          (total_bytes_deleted+500)/1000,
  2144.          articles,
  2145.          (total_bytes+500)/1000);
  2146.   
  2147. !     exit(0);
  2148.   }
  2149.   
  2150.   
  2151. ***************
  2152. *** 285,295 ****
  2153. --- 311,323 ----
  2154.           fprintf(stderr, "expire: cannot open file %s for input\n", buf);
  2155.           exit(1);
  2156.       }
  2157. +     setvbuf(hist_file, NULL, _IOFBF, IOBUFSIZE);
  2158.       sprintf(buf, "%shistory.new", my_stuff.news_dir);
  2159.       if ((new_hist_file = fopen(buf, "wb")) == NULL) {
  2160.           fprintf(stderr, "expire: cannot open file %s for output\n", buf);
  2161.           exit(1);
  2162.       }
  2163. +     setvbuf(new_hist_file, NULL, _IOFBF, IOBUFSIZE);
  2164.   
  2165.       while (fgets(buf, 255, hist_file) != NULL) {
  2166.           sscanf(buf, "%*s %ld", &age);
  2167. ***************
  2168. *** 309,313 ****
  2169.       rename(buf, buf2);
  2170.       sprintf(buf, "%shistory.bak", my_stuff.news_dir);
  2171.       unlink(buf);
  2172. - 
  2173.   }
  2174. --- 337,340 ----
  2175. Only in new: FILES
  2176. diff -cb orig/history.c new/history.c
  2177. *** orig/history.c    Thu Jun 11 22:48:14 1992
  2178. --- new/history.c    Sun Aug 02 20:34:18 1992
  2179. ***************
  2180. *** 1,5 ****
  2181.   /*
  2182. !     SNEWS 1.0
  2183.   
  2184.       History routines
  2185.   
  2186. --- 1,5 ----
  2187.   /*
  2188. !     SNEWS 2.0
  2189.   
  2190.       History routines
  2191.   
  2192. ***************
  2193. *** 143,149 ****
  2194.       }
  2195.   
  2196.       where = 0;
  2197. !     hlist = NULL;
  2198.   
  2199.       while (fgets(buf, 511, hist)) {
  2200.   
  2201. --- 143,149 ----
  2202.       }
  2203.   
  2204.       where = 0;
  2205. !     hlist = h = NULL;
  2206.   
  2207.       while (fgets(buf, 511, hist)) {
  2208.   
  2209. ***************
  2210. *** 160,172 ****
  2211.           h->mid = hash_msg_id(p);
  2212.           h->offset = where;
  2213.   
  2214. -         /* leave some memory for other things */
  2215. -         if (farcoreleft() < HIST_MEM_LIMIT) break;
  2216. - 
  2217. - 
  2218.           where = ftell(hist);
  2219.       }
  2220.   
  2221.           h->next = NULL;
  2222.   
  2223.       return(hlist);
  2224. --- 160,169 ----
  2225.           h->mid = hash_msg_id(p);
  2226.           h->offset = where;
  2227.   
  2228.           where = ftell(hist);
  2229.       }
  2230.   
  2231. +     if ( h )
  2232.           h->next = NULL;
  2233.   
  2234.       return(hlist);
  2235. ***************
  2236. *** 256,262 ****
  2237.   
  2238.       /* now look up the history file */
  2239.       cx = NULL;
  2240. !     if (h->mid == hid) {
  2241.           fseek(hist, h->offset, SEEK_SET);
  2242.           if (fgets(buf, 511, hist) != NULL) {
  2243.   
  2244. --- 253,259 ----
  2245.   
  2246.       /* now look up the history file */
  2247.       cx = NULL;
  2248. !     if (h && h->mid == hid) {
  2249.           fseek(hist, h->offset, SEEK_SET);
  2250.           if (fgets(buf, 511, hist) != NULL) {
  2251.   
  2252. ***************
  2253. *** 287,299 ****
  2254.                           strcpy(c->group, p);
  2255.                           p = strtok(NULL, " \t\n\r");
  2256.                           c->art_num = atol(p);
  2257.   
  2258.                       } else {
  2259.                           /* eat article number */
  2260.                           p = strtok(NULL, " \t\n\r");
  2261.                       }
  2262. - 
  2263. -                     c->next = NULL;
  2264.   
  2265.                       p = strtok(NULL, " \t\n\r");
  2266.                   }
  2267. --- 284,295 ----
  2268.                           strcpy(c->group, p);
  2269.                           p = strtok(NULL, " \t\n\r");
  2270.                           c->art_num = atol(p);
  2271. +                         c->next = NULL;
  2272.   
  2273.                       } else {
  2274.                           /* eat article number */
  2275.                           p = strtok(NULL, " \t\n\r");
  2276.                       }
  2277.   
  2278.                       p = strtok(NULL, " \t\n\r");
  2279.                   }
  2280. Only in new: lock.c
  2281. Only in new: Makefile
  2282. Only in new: os2defs.h
  2283. Only in new: os2util.c
  2284. Only in new: patches.os2
  2285. Only in new: pipe.c
  2286. diff -cb orig/post.c new/post.c
  2287. *** orig/post.c    Thu Jun 11 22:48:14 1992
  2288. --- new/post.c    Sun Aug 02 20:34:18 1992
  2289. ***************
  2290. *** 1,5 ****
  2291.   /*
  2292. !     SNEWS 1.0
  2293.   
  2294.       snews - posting stuff
  2295.   
  2296. --- 1,5 ----
  2297.   /*
  2298. !     SNEWS 2.0
  2299.   
  2300.       snews - posting stuff
  2301.   
  2302. ***************
  2303. *** 34,40 ****
  2304.   
  2305.   
  2306.   /*------------------------------- post an article --------------------------*/
  2307. ! void post(TEXT *tx, char *gx, char *subject)
  2308.   {
  2309.       /*
  2310.        *  Ask for the data we are not given in the arguments,
  2311. --- 34,40 ----
  2312.   
  2313.   
  2314.   /*------------------------------- post an article --------------------------*/
  2315. ! void post(TEXT *tx, char *gx)
  2316.   {
  2317.       /*
  2318.        *  Ask for the data we are not given in the arguments,
  2319. ***************
  2320. *** 43,62 ****
  2321.   
  2322.       FILE *article, *sig;
  2323.       LINE *ln;
  2324. !     char buf[80];
  2325. !     char newsgroups[256];
  2326.       char sig_fn[80];
  2327. !     char author[80], msg_id[80];
  2328.       int  ch;
  2329.   
  2330.       strcpy(newsgroups, gx);
  2331.   
  2332.       strcpy(author, "");
  2333.       strcpy(msg_id, "");
  2334.   
  2335. !     if ((article = fopen("post.tmp", "w+")) != NULL) {
  2336.   
  2337. -         command("");
  2338.           if (strlen(newsgroups) == 0) {
  2339.   
  2340.               /* if no groups ask for them */
  2341. --- 43,64 ----
  2342.   
  2343.       FILE *article, *sig;
  2344.       LINE *ln;
  2345. !     char buf[MAXLINE];
  2346. !     char fn[256], newsgroups[256], subject[256];
  2347.       char sig_fn[80];
  2348. !     char author[80], msg_id[256];
  2349.       int  ch;
  2350.   
  2351. +     strcpy(fn, my_stuff.news_dir);
  2352. +     strcat(fn, "article");
  2353. +     unlink(fn);
  2354.       strcpy(newsgroups, gx);
  2355.   
  2356.       strcpy(author, "");
  2357.       strcpy(msg_id, "");
  2358.   
  2359. !     if ((article = fopen(fn, "w+")) != NULL) {
  2360.   
  2361.           if (strlen(newsgroups) == 0) {
  2362.   
  2363.               /* if no groups ask for them */
  2364. ***************
  2365. *** 80,94 ****
  2366.           /* check for a valid newsgroups line */
  2367.           if (newsgroups_valid(newsgroups)) {
  2368.   
  2369. -             if (strlen(subject) == 0) {
  2370. -                 lmessage("Subject? ");
  2371. -                 gets(subject);
  2372. -             }
  2373. - 
  2374.               /* add the quoted message */
  2375.               /* are we quoting */
  2376.               if (tx != NULL) {
  2377.   
  2378.                   message("Quote article (y/n)? ");
  2379.                   while (((ch = getch()) != 'y') && (ch != 'n'));
  2380.   
  2381. --- 82,101 ----
  2382.           /* check for a valid newsgroups line */
  2383.           if (newsgroups_valid(newsgroups)) {
  2384.   
  2385.               /* add the quoted message */
  2386.               /* are we quoting */
  2387.               if (tx != NULL) {
  2388.   
  2389. +                 if (strlen(tx->subject) == 0) {
  2390. +                     lmessage("Subject? ");
  2391. +                     gets(subject);
  2392. +                 }
  2393. +                 else
  2394. +                     if ( strnicmp(tx->subject, "Re: ", 4) != 0 )
  2395. +                         sprintf(subject, "Re: %s", tx->subject);
  2396. +                     else
  2397. +                         strcpy(subject, tx->subject);
  2398. + 
  2399.                   message("Quote article (y/n)? ");
  2400.                   while (((ch = getch()) != 'y') && (ch != 'n'));
  2401.   
  2402. ***************
  2403. *** 95,108 ****
  2404.                   if (ch == 'y') {
  2405.   
  2406.                       get_his_stuff(tx, author, msg_id);
  2407. !                     fprintf(article, "\nIn article %s %s writes:\n\n", msg_id, author);
  2408.                       ln = tx->start;
  2409.                       while (ln != NULL) {
  2410. !                         fprintf(article, "  > %s", ln->data);
  2411.                           ln = ln->next;
  2412.                       }
  2413.                   }
  2414.               }
  2415.   
  2416.               /* append the signature if there is one */
  2417.               strcpy(sig_fn, my_stuff.home);
  2418. --- 102,119 ----
  2419.                   if (ch == 'y') {
  2420.   
  2421.                       get_his_stuff(tx, author, msg_id);
  2422. !                     fprintf(article, "%s writes in article %s:\n", author, msg_id);
  2423.                       ln = tx->start;
  2424.                       while (ln != NULL) {
  2425. !                         fprintf(article, "> %s", ln->data);
  2426.                           ln = ln->next;
  2427.                       }
  2428.                   }
  2429.               }
  2430. +             else {
  2431. +                 lmessage("Subject? ");
  2432. +                 gets(subject);
  2433. +             }
  2434.   
  2435.               /* append the signature if there is one */
  2436.               strcpy(sig_fn, my_stuff.home);
  2437. ***************
  2438. *** 110,127 ****
  2439.               if ((sig = fopen(sig_fn, "rt")) != NULL) {
  2440.                   while (fgets(buf, 79, sig) != NULL)
  2441.                       fputs(buf, article);
  2442.               }
  2443.   
  2444.   
  2445.               fclose(article);
  2446. !             sprintf(buf, my_stuff.editor, "post.tmp");
  2447.               system(buf);
  2448. !             article = fopen("post.tmp", "rt");
  2449.   
  2450.               sprintf(buf, "Post this article to %s (y/n)? ", newsgroups);
  2451.               message(buf);
  2452.               while (((ch = getch()) != 'y') && (ch != 'n'));
  2453. !             gotoxy(1,24);
  2454.   
  2455.               if (ch == 'y')
  2456.                   post_it(article, newsgroups, subject, "world", msg_id);
  2457. --- 121,139 ----
  2458.               if ((sig = fopen(sig_fn, "rt")) != NULL) {
  2459.                   while (fgets(buf, 79, sig) != NULL)
  2460.                       fputs(buf, article);
  2461. +                 fclose(sig);
  2462.               }
  2463.   
  2464.   
  2465.               fclose(article);
  2466. !             sprintf(buf, my_stuff.editor, fn);
  2467.               system(buf);
  2468. !             article = fopen(fn, "rt");
  2469.   
  2470.               sprintf(buf, "Post this article to %s (y/n)? ", newsgroups);
  2471.               message(buf);
  2472.               while (((ch = getch()) != 'y') && (ch != 'n'));
  2473. !             gotoxy(1,PAGE_SIZE);
  2474.   
  2475.               if (ch == 'y')
  2476.                   post_it(article, newsgroups, subject, "world", msg_id);
  2477. ***************
  2478. *** 129,135 ****
  2479.           }
  2480.   
  2481.           fclose(article);
  2482. !         unlink("post.tmp");
  2483.   
  2484.       } else {
  2485.           message("*** couldn't open temp article file - press any key ***");
  2486. --- 141,147 ----
  2487.           }
  2488.   
  2489.           fclose(article);
  2490. !         /* unlink(fn); /* keep it around like rn */
  2491.   
  2492.       } else {
  2493.           message("*** couldn't open temp article file - press any key ***");
  2494. ***************
  2495. *** 152,163 ****
  2496.   
  2497.       FILE   *tmp, *local, *log;
  2498.       char   buf[256], *p;
  2499. !     char   ng[256];
  2500.       char   d_name[20], x_name[20];
  2501.       char   short_d_name[20], short_x_name[20];
  2502.       int    ct, seq;
  2503.       time_t t;
  2504. !     struct tm *gmt;
  2505.       long   where;
  2506.       ACTIVE *gp;
  2507.   
  2508. --- 164,176 ----
  2509.   
  2510.       FILE   *tmp, *local, *log;
  2511.       char   buf[256], *p;
  2512. !     char   ng[256], timestr[64];
  2513.       char   d_name[20], x_name[20];
  2514.       char   short_d_name[20], short_x_name[20];
  2515. +     char   remotegroups[256];
  2516.       int    ct, seq;
  2517.       time_t t;
  2518. !     struct tm *gmt, *tmnow;
  2519.       long   where;
  2520.       ACTIVE *gp;
  2521.   
  2522. ***************
  2523. *** 183,189 ****
  2524.       while (fgets(buf, 255, article) != NULL)
  2525.           ct++;
  2526.   
  2527. - 
  2528.       /*
  2529.        *  Make the final article file.  This posting stuff is a horrible
  2530.        *  kludge (blush).  If you get a around to fixing this, please
  2531. --- 196,201 ----
  2532. ***************
  2533. *** 191,202 ****
  2534.        */
  2535.       if ((tmp = fopen(short_d_name, "w+b")) != NULL) {
  2536.   
  2537.           fprintf(tmp, "Path: %s!%s\n", my_stuff.my_site, my_stuff.user);
  2538.           fprintf(tmp, "From: %s@%s (%s)\n", my_stuff.user, my_stuff.my_domain,
  2539.               my_stuff.my_name);
  2540.           fprintf(tmp, "Newsgroups: %s\n", newsgroups);
  2541.           fprintf(tmp, "Subject: %s\n", subject);
  2542. !         fprintf(tmp, "Distribution: %s\n", dist);
  2543.   
  2544.           fprintf(tmp, "Message-ID: <%ldsnx@%s>\n", time(&t), my_stuff.my_domain);
  2545.   
  2546. --- 203,226 ----
  2547.        */
  2548.       if ((tmp = fopen(short_d_name, "w+b")) != NULL) {
  2549.   
  2550. +         remotegroups[0] = 0;
  2551. +         strcpy(ng, newsgroups);
  2552. +         p = strtok(ng, " ,");
  2553. +         while (p != NULL) {
  2554. +             if (!is_local_group(p)) {
  2555. +                 if (remotegroups[0])
  2556. +                     strcat(remotegroups, ",");
  2557. +                 strcat(remotegroups, p);
  2558. +             }
  2559. +             p = strtok(NULL, " ,");
  2560. +         }
  2561. + 
  2562.           fprintf(tmp, "Path: %s!%s\n", my_stuff.my_site, my_stuff.user);
  2563.           fprintf(tmp, "From: %s@%s (%s)\n", my_stuff.user, my_stuff.my_domain,
  2564.               my_stuff.my_name);
  2565.           fprintf(tmp, "Newsgroups: %s\n", newsgroups);
  2566.           fprintf(tmp, "Subject: %s\n", subject);
  2567. !         fprintf(tmp, "Distribution: %s\n", remotegroups[0] ? dist : "local");
  2568.   
  2569.           fprintf(tmp, "Message-ID: <%ldsnx@%s>\n", time(&t), my_stuff.my_domain);
  2570.   
  2571. ***************
  2572. *** 211,217 ****
  2573.                   gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
  2574.   
  2575.           fprintf(tmp, "Organization: %s\n", my_stuff.my_organisation);
  2576. !         fprintf(tmp, "Lines: %d\n\n", ct);
  2577.   
  2578.           /* copy the rest */
  2579.           rewind(article);
  2580. --- 235,251 ----
  2581.                   gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
  2582.   
  2583.           fprintf(tmp, "Organization: %s\n", my_stuff.my_organisation);
  2584. !         fprintf(tmp, "Lines: %d\n", ct);
  2585. ! 
  2586. !         strcpy(buf, my_stuff.news_dir);
  2587. !         strcat(buf, "headers");
  2588. !     if ((local = fopen(buf, "r")) != NULL) {
  2589. !             while (fgets(buf, 255, local) != NULL)
  2590. !                 fputs(buf, tmp);
  2591. !         fclose(local);
  2592. !     }
  2593. ! 
  2594. !     fputs("\n", tmp);
  2595.   
  2596.           /* copy the rest */
  2597.           rewind(article);
  2598. ***************
  2599. *** 251,259 ****
  2600.           /* finally log it */
  2601.           strcpy(buf, my_stuff.news_dir);
  2602.           strcat(buf, "post.log");
  2603. !         if ((log = fopen(buf, "at")) != NULL) {
  2604.               fprintf(log, "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
  2605.                            "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\n");
  2606.   
  2607.               fseek(tmp, 0L, SEEK_SET);
  2608.               while (fgets(buf, 255, tmp) != NULL)  {
  2609. --- 285,297 ----
  2610.           /* finally log it */
  2611.           strcpy(buf, my_stuff.news_dir);
  2612.           strcat(buf, "post.log");
  2613. !         if ((log = flockopen(buf, "at")) != NULL) {
  2614.               fprintf(log, "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
  2615.                            "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\n");
  2616. +         tmnow = localtime(&t);
  2617. +         strftime(timestr, sizeof(timestr), "%a %b %d %H:%M:%S %z %Y", gmt);
  2618. +         fprintf(log, "From %s!%s %s\n", my_stuff.my_site, my_stuff.user, 
  2619. +             timestr);
  2620.   
  2621.               fseek(tmp, 0L, SEEK_SET);
  2622.               while (fgets(buf, 255, tmp) != NULL)  {
  2623. ***************
  2624. *** 265,272 ****
  2625.   
  2626.           fclose(tmp);
  2627.   
  2628. - 
  2629.           /* now the the X... file */
  2630.               if ((tmp = fopen(short_x_name, "wb")) != NULL) {
  2631.                   fprintf(tmp, "U news %s\n", my_stuff.my_site);
  2632.                   fprintf(tmp, "Z\n");
  2633. --- 303,310 ----
  2634.   
  2635.           fclose(tmp);
  2636.   
  2637.           /* now the the X... file */
  2638. +         if (remotegroups[0])
  2639.               if ((tmp = fopen(short_x_name, "wb")) != NULL) {
  2640.                   fprintf(tmp, "U news %s\n", my_stuff.my_site);
  2641.                   fprintf(tmp, "Z\n");
  2642. ***************
  2643. *** 275,287 ****
  2644.                   fprintf(tmp, "C rnews\n");
  2645.                   fclose(tmp);
  2646.   
  2647. !             sprintf(buf, "uucp -C %s %s!%s ", short_d_name, my_stuff.mail_server,
  2648. !                         d_name);
  2649. !             gotoxy(1,24); clreol();
  2650.                   system(buf);
  2651. !             sprintf(buf, "uucp -C %s %s!%s ", short_x_name, my_stuff.mail_server,
  2652. !                         x_name);
  2653. !             gotoxy(1,24); clreol();
  2654.                   system(buf);
  2655.   
  2656.               } else {
  2657. --- 313,325 ----
  2658.                   fprintf(tmp, "C rnews\n");
  2659.                   fclose(tmp);
  2660.   
  2661. !                 sprintf(buf, "uucp -C %s %s!%s 2>nul", short_d_name, 
  2662. !             my_stuff.mail_server, d_name);
  2663. !                 gotoxy(1,PAGE_SIZE); clreol();
  2664.                   system(buf);
  2665. !                 sprintf(buf, "uucp -C %s %s!%s 2>nul", short_x_name, 
  2666. !             my_stuff.mail_server, x_name);
  2667. !                 gotoxy(1,PAGE_SIZE); clreol();
  2668.                   system(buf);
  2669.   
  2670.               } else {
  2671. ***************
  2672. *** 317,325 ****
  2673.   
  2674.       while (p != NULL) {
  2675.           if (!check_valid_post_group(p)) {
  2676. !             sprintf(msg, "** Can't post to %s **", p);
  2677.               message(msg);
  2678. -             command("-- Press any key to continue --");
  2679.               getch();
  2680.               return(FALSE);
  2681.           }
  2682. --- 355,362 ----
  2683.   
  2684.       while (p != NULL) {
  2685.           if (!check_valid_post_group(p)) {
  2686. !             sprintf(msg, "*** can't post to %s - press any key ***", p);
  2687.               message(msg);
  2688.               getch();
  2689.               return(FALSE);
  2690.           }
  2691. Only in new: pwd.c
  2692. Only in new: pwd.h
  2693. Only in new: README.OS2
  2694. diff -cb orig/rmgroup.c new/rmgroup.c
  2695. *** orig/rmgroup.c    Thu Jun 11 22:48:15 1992
  2696. --- new/rmgroup.c    Sun Aug 02 20:34:18 1992
  2697. ***************
  2698. *** 1,5 ****
  2699.   /*
  2700. !     SNEWS 1.0
  2701.   
  2702.       rmgroup - remove newsgroups from the active file, and delete the files
  2703.   
  2704. --- 1,5 ----
  2705.   /*
  2706. !     SNEWS 2.0
  2707.   
  2708.       rmgroup - remove newsgroups from the active file, and delete the files
  2709.   
  2710. ***************
  2711. *** 49,54 ****
  2712. --- 49,56 ----
  2713.       FILE   *active_file, *new_active_file;
  2714.   
  2715.   
  2716. +     fprintf(stderr, "RMGROUP: (%s)\n\n", VERSION);
  2717. + 
  2718.       if (argc > 1) {
  2719.   
  2720.           if (!load_stuff()) {
  2721. ***************
  2722. *** 68,74 ****
  2723.   
  2724.                   /* form the directory name */
  2725.                   dir = make_news_group_name(argv[i]);
  2726. !                 unlink(buf);
  2727.                   sprintf(buf, "%s.IDX", dir);
  2728.                   unlink(buf);
  2729.   
  2730. --- 70,76 ----
  2731.   
  2732.                   /* form the directory name */
  2733.                   dir = make_news_group_name(argv[i]);
  2734. !                 unlink(dir);
  2735.                   sprintf(buf, "%s.IDX", dir);
  2736.                   unlink(buf);
  2737.   
  2738. ***************
  2739. *** 113,119 ****
  2740.   
  2741.   
  2742.               } else {
  2743. !                 fprintf(stderr, "rmgroup: newsgroup %s not found\n", argv[1]);
  2744.               }
  2745.   
  2746.           }
  2747. --- 115,121 ----
  2748.   
  2749.   
  2750.               } else {
  2751. !                 fprintf(stderr, "rmgroup: newsgroup %s not found\n", argv[i]);
  2752.               }
  2753.   
  2754.           }
  2755. ***************
  2756. *** 121,127 ****
  2757.           close_active_file();
  2758.   
  2759.       } else {
  2760. !         printf("USAGE: rmgroup  newsgroup names....\n");
  2761.       }
  2762.   
  2763.   }
  2764. --- 123,129 ----
  2765.           close_active_file();
  2766.   
  2767.       } else {
  2768. !         printf("usage: rmgroup  newsgroup names....\n");
  2769.       }
  2770.   
  2771.   }
  2772. Only in new: rnews.c
  2773. Only in new: rnews.h
  2774. diff -cb orig/snews.c new/snews.c
  2775. *** orig/snews.c    Thu Jun 11 22:48:16 1992
  2776. --- new/snews.c    Sun Aug 09 01:29:29 1992
  2777. ***************
  2778. *** 1,5 ****
  2779.   /*
  2780. !     SNEWS 1.0
  2781.   
  2782.       snews - a simple threaded news reader
  2783.   
  2784. --- 1,5 ----
  2785.   /*
  2786. !     SNEWS 2.0
  2787.   
  2788.       snews - a simple threaded news reader
  2789.   
  2790. ***************
  2791. *** 27,32 ****
  2792. --- 27,34 ----
  2793.   
  2794.   
  2795.   INFO my_stuff;
  2796. + char iobuf[IOBUFSIZE];
  2797. + char search_text[256];
  2798.   
  2799.   
  2800.   /*------------------------------- main --------------------------------*/
  2801. ***************
  2802. *** 35,50 ****
  2803.       ACTIVE *gp, *head;
  2804.       int    done;
  2805.   
  2806. !     printf("loading config... ");
  2807.       if (load_stuff()) {
  2808.   
  2809. !         printf("loading active... ");
  2810.           head = load_active_file();
  2811. !         printf("loading read list... ");
  2812.           load_read_list();
  2813. !         printf("loading history... ");
  2814.           load_history_list();
  2815.   
  2816.           done = FALSE;
  2817.           gp = NULL;
  2818.   
  2819. --- 37,57 ----
  2820.       ACTIVE *gp, *head;
  2821.       int    done;
  2822.   
  2823. !     ignore_signals();
  2824. !     
  2825. !     printf("loading config...\n");
  2826.       if (load_stuff()) {
  2827.   
  2828. !         printf("loading active...\n");
  2829.           head = load_active_file();
  2830. !         printf("loading read list...\n");
  2831.           load_read_list();
  2832. !         printf("loading history...\n");
  2833.           load_history_list();
  2834.   
  2835. +         scrinit();
  2836. +         clrscr();
  2837. + 
  2838.           done = FALSE;
  2839.           gp = NULL;
  2840.   
  2841. ***************
  2842. *** 56,68 ****
  2843.               }
  2844.           }
  2845.   
  2846.           clrscr();
  2847.   
  2848.           free_hist_list();
  2849.           save_read_list();
  2850.           close_active_file();
  2851.       } else {
  2852. !         fprintf(stderr, "Couldn't fine neccessary item in the .rc files\n");
  2853.       }
  2854.   }
  2855.   
  2856. --- 63,77 ----
  2857.               }
  2858.           }
  2859.   
  2860. +         screxit();
  2861.           clrscr();
  2862.   
  2863.           free_hist_list();
  2864.           save_read_list();
  2865.           close_active_file();
  2866. + 
  2867.       } else {
  2868. !         fprintf(stderr, "Couldn't find necessary item in the .rc files\n");
  2869.       }
  2870.   }
  2871.   
  2872. ***************
  2873. *** 74,80 ****
  2874.   {
  2875.       /*
  2876.        *  Present the list of groups, and allow him to move up and down with
  2877. !      *  the arrow and PgUp and PgDn keys.  'h' for help, -/+ for searches
  2878.        */
  2879.   
  2880.       ACTIVE *top;        /* newsgroup at the top of the page */
  2881. --- 83,89 ----
  2882.   {
  2883.       /*
  2884.        *  Present the list of groups, and allow him to move up and down with
  2885. !      *  the arrow and PgUp and PgDn keys.
  2886.        */
  2887.   
  2888.       ACTIVE *top;        /* newsgroup at the top of the page */
  2889. ***************
  2890. *** 81,87 ****
  2891.       ACTIVE *this;       /* current newsgroup                */
  2892.       ACTIVE *tmp_ng;
  2893.       int    exit_code;   /* why we are exiting the loop      */
  2894. -     char   sub_tmp[80];
  2895.   
  2896.       int    ch, i, j, articles, unread;
  2897.   
  2898. --- 90,95 ----
  2899. ***************
  2900. *** 90,96 ****
  2901.       top = head;
  2902.       exit_code = 0;
  2903.   
  2904. !     show_groups(&top, this, TRUE);
  2905.   
  2906.       while (exit_code == 0) {
  2907.   
  2908. --- 98,104 ----
  2909.       top = head;
  2910.       exit_code = 0;
  2911.   
  2912. !     show_groups(&top, this, TRUE, head);
  2913.   
  2914.       while (exit_code == 0) {
  2915.   
  2916. ***************
  2917. *** 98,107 ****
  2918.           switch (ch) {
  2919.   
  2920.               case 0      :
  2921. !                 ch = getch();
  2922.               
  2923.                   switch (ch) {
  2924.   
  2925.                       case UP_ARR :
  2926.                           if (this->last != NULL) this = this->last;
  2927.                           break;
  2928. --- 106,121 ----
  2929.           switch (ch) {
  2930.   
  2931.               case 0      :
  2932. !             case 0xE0   :
  2933.               
  2934. +                 ch = getch();
  2935.                   switch (ch) {
  2936.   
  2937. +                     case F1     :
  2938. +                         show_help(HELP_GROUP);
  2939. +                         show_groups(&top, this, TRUE, head);
  2940. +                         break;
  2941. +                         
  2942.                       case UP_ARR :
  2943.                           if (this->last != NULL) this = this->last;
  2944.                           break;
  2945. ***************
  2946. *** 126,133 ****
  2947.   
  2948.                       case HOME   :
  2949.                           top = this = head;
  2950. !                         show_groups(&top, this, TRUE);
  2951.                           break;
  2952.                       case END    :
  2953.                           this = head;
  2954.                           while (this->next != NULL)
  2955. --- 140,148 ----
  2956.   
  2957.                       case HOME   :
  2958.                           top = this = head;
  2959. !                         show_groups(&top, this, TRUE, head);
  2960.                           break;
  2961. + 
  2962.                       case END    :
  2963.                           this = head;
  2964.                           while (this->next != NULL)
  2965. ***************
  2966. *** 137,156 ****
  2967.                   break;
  2968.   
  2969.               case 'p'    :
  2970. !                 strcpy(sub_tmp, "");
  2971. !                 post(NULL, this->group, sub_tmp);
  2972. !                 show_groups(&top, this, TRUE);
  2973.                   break;
  2974.   
  2975. -             case '?'    :
  2976.               case 'h'    :
  2977.                   show_help(HELP_GROUP);
  2978. !                 show_groups(&top, this, TRUE);
  2979.                   break;
  2980.   
  2981.               case 'c'    :
  2982.                   mark_group_as_read(this);
  2983. !                 show_groups(&top, this, TRUE);
  2984.                   break;
  2985.   
  2986.               case TAB    :
  2987. --- 152,172 ----
  2988.                   break;
  2989.   
  2990.               case 'p'    :
  2991. !             case 'P'    :
  2992. !                 post(NULL, this->group);
  2993. !                 show_groups(&top, this, TRUE, head);
  2994.                   break;
  2995.   
  2996.               case 'h'    :
  2997. +             case 'H'    :
  2998.                   show_help(HELP_GROUP);
  2999. !                 show_groups(&top, this, TRUE, head);
  3000.                   break;
  3001.   
  3002.               case 'c'    :
  3003. +             case 'C'    :
  3004.                   mark_group_as_read(this);
  3005. !                 show_groups(&top, this, TRUE, head);
  3006.                   break;
  3007.   
  3008.               case TAB    :
  3009. ***************
  3010. *** 181,187 ****
  3011.                   break;
  3012.           };
  3013.           if (exit_code == 0)
  3014. !             show_groups(&top, this, FALSE);
  3015.       }
  3016.   
  3017.       if (exit_code == EX_DONE)
  3018. --- 197,203 ----
  3019.                   break;
  3020.           };
  3021.           if (exit_code == 0)
  3022. !             show_groups(&top, this, FALSE, head);
  3023.       }
  3024.   
  3025.       if (exit_code == EX_DONE)
  3026. ***************
  3027. *** 194,247 ****
  3028.   
  3029.   
  3030.   /*---------------------------- help screen ----------------------------------*/
  3031. ! void show_help(int h)
  3032.   {
  3033.   
  3034. !     char *type[] = {"New Group",  "Thread",  "Article"};
  3035.   
  3036. !     clrscr();
  3037.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  3038.       clreol();
  3039. -     cprintf("                      %s Help  (%s)\r\n", type[h], VERSION);
  3040. -     clreol();
  3041.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  3042.   
  3043. !     printf("\n\n");
  3044. !     printf("          PgUp  - move display up one page\n");
  3045. !     printf("          PgDn  - move display down one page\n");
  3046. !     printf("          Home  - move to top of list/article\n");
  3047. !     printf("          End   - move to bottom of list/article\n");
  3048. !     printf("          \x18     - move up one line\n");
  3049. !     printf("          \x19     - move down one line\n\n");
  3050.   
  3051.       switch (h) {
  3052.           case HELP_GROUP   :
  3053. !             printf("          TAB   - go to next newgroup with unread articles\n");
  3054. !             printf("          ENTER - enter selected newsgroup\n\n");
  3055. !             printf("          p     - post article in selected newsgroup\n");
  3056. !             printf("          c     - mark all articles in this newsgroup as read\n");
  3057.               break;
  3058.   
  3059.           case HELP_THREAD  :
  3060. !             printf("          TAB   - go to next unread article\n");
  3061. !             printf("          ENTER - read the selected thread from the begining\n\n");
  3062. !             printf("          p     - post article in selected newsgroup\n");
  3063. !             printf("          c     - mark all articles in this newsgroup as read\n");
  3064. !             printf("          s     - save thread to disk\n");
  3065.               break;
  3066.   
  3067.           case HELP_ARTICLES:
  3068. !             printf("          TAB   - go to next unread article\n");
  3069. !             printf("          ENTER - go to next article in thread\n\n");
  3070. !             printf("          p     - Post article in selected newsgroup\n");
  3071. !             printf("          f     - post Followup to this article\n\n");
  3072. !             printf("          r     - mail a Reply to this article\n\n");
  3073. !             printf("          m     - mail this article to someone\n\n");
  3074. !             printf("          c     - mark all articles in this newsgroup as read\n");
  3075. !             printf("          s     - save article to disk\n");
  3076.               break;
  3077.       };
  3078.   
  3079.       message("-- Press any key to continue --");
  3080.       getch();
  3081.   
  3082. --- 210,291 ----
  3083.   
  3084.   
  3085.   /*---------------------------- help screen ----------------------------------*/
  3086. ! 
  3087. ! void help(char *text)
  3088.   {
  3089. +     printf("%*s", _columns / 2 - 40, "");
  3090.   
  3091. !     while (*text) {
  3092. !         if (*text == '\n')
  3093. !             clreol(), _line++;
  3094. !         putch(*text++);
  3095. !     }
  3096. ! }
  3097.   
  3098. ! void show_help(int h)
  3099. ! {
  3100. !     char *type[] = {"Group Help",  "Thread Help",  "Article Help"};
  3101. !     char *msg = COPYRIGHT;
  3102. !     int x;
  3103. ! 
  3104. !     gotoxy(1,1);
  3105.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  3106. +     printf("%-18s %*s", type[h], _columns - 19, VERSION);
  3107. +     gotoxy(1,2);
  3108. +     x = _columns / 2 - strlen(msg) / 2;
  3109. +     printf("%*s%s", x, "", msg);
  3110.       clreol();
  3111.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  3112. +     putch('\n');
  3113.   
  3114. !     help("\n");
  3115. !     help("         PageUp - move display up one page\n");
  3116. !     help("         PageDn - move display down one page\n");
  3117. !     help("           Home - move to top of list/article\n");
  3118. !     help("            End - move to bottom of list/article\n");
  3119. !     help("             Up - move up one line\n");
  3120. !     help("           Down - move down one line\n");
  3121.   
  3122.       switch (h) {
  3123.           case HELP_GROUP   :
  3124. !             help("\n");
  3125. !             help("            Tab - go to next newgroup with unread articles\n");
  3126. !             help("          Enter - enter selected newsgroup\n\n");
  3127. !             help("              c - mark all articles in selected group as read\n");
  3128. !             help("              p - post article to selected group\n");
  3129.               break;
  3130.   
  3131.           case HELP_THREAD  :
  3132. !             help("\n");
  3133. !             help("            Tab - go to next thread with unread articles or\n");
  3134. !             help("                  enter this thread if it is already selected\n");
  3135. !             help("                  and move to the first unread article in the thread\n");
  3136. !             help("          Enter - read the selected thread from the beginning\n");
  3137. !             help("      Backspace - go to the last article in the selected thread\n\n");
  3138. !             help("              c - mark all articles in selected thread as read\n");
  3139. !             help("              s - save selected thread to disk\n");
  3140. !             help("              p - post article to this group\n\n");
  3141. !         help("              + - search for text in subjects\n");
  3142. !         help("              / - search for text in article bodies\n");
  3143.               break;
  3144.   
  3145.           case HELP_ARTICLES:
  3146. !             help("           Left - scroll right\n");
  3147. !             help("          Right - scroll left\n\n");
  3148. !             help("            Tab - go to next unread article\n");
  3149. !             help("          Enter - go to next article in thread\n");
  3150. !             help("      Backspace - go to previous article in thread\n\n");
  3151. !             help("              s - save this article to disk\n");
  3152. !             help("              p - post new article to current group\n");
  3153. !             help("              f - post follow-up to this article\n");
  3154. !             help("              r - reply to sender of this article via e-mail\n");
  3155. !             help("              m - mail this article to someone\n");
  3156. !         help("            + / - search for text in following articles\n");
  3157. !         help("            - ? - search for text in preceding articles\n");
  3158.               break;
  3159.       };
  3160.   
  3161. +     clreos();
  3162.       message("-- Press any key to continue --");
  3163.       getch();
  3164.   
  3165. ***************
  3166. *** 251,257 ****
  3167.   
  3168.   
  3169.   /*-------------------- show the list of active groups -----------------------*/
  3170. ! void show_groups(ACTIVE **top, ACTIVE *this, int force)
  3171.   {
  3172.       /*
  3173.        *  This routine takes 'top', a pointer to the first line on the screen
  3174. --- 295,301 ----
  3175.   
  3176.   
  3177.   /*-------------------- show the list of active groups -----------------------*/
  3178. ! void show_groups(ACTIVE **top, ACTIVE *this, int force, ACTIVE *head)
  3179.   {
  3180.       /*
  3181.        *  This routine takes 'top', a pointer to the first line on the screen
  3182. ***************
  3183. *** 264,269 ****
  3184. --- 308,314 ----
  3185.       static last_index;
  3186.       int    i, ur;
  3187.       ACTIVE *that;
  3188. +     char buf[32];
  3189.   
  3190.       /*
  3191.        *  If 'this' is above the 'top' or it is more than a screen length below,
  3192. ***************
  3193. *** 276,289 ****
  3194.           ((*top)->index > this->index) ||
  3195.           (this->index - (*top)->index) > PAGE_LENGTH-1) {
  3196.   
  3197. !         clrscr();
  3198.           textbackground(LIGHTGRAY);  textcolor(BLACK);
  3199. !         clreol();
  3200. !         cprintf("                         Select Newsgroup  (%s)  [%ldk]\r\n",
  3201. !                VERSION,  farcoreleft()/1000);
  3202.           clreol();
  3203. -         cprintf("\r\n");
  3204. -         clreol();
  3205.           textbackground(BLACK);  textcolor(LIGHTGRAY);
  3206.   
  3207.           /* now adjust the top */
  3208. --- 321,332 ----
  3209.           ((*top)->index > this->index) ||
  3210.           (this->index - (*top)->index) > PAGE_LENGTH-1) {
  3211.   
  3212. !         gotoxy(1,1);
  3213.           textbackground(LIGHTGRAY);  textcolor(BLACK);
  3214. !         sprintf(buf, "Group %d of %d", last_index + 1, head->groups);
  3215. !         printf("Select Group %*s", _columns - 13, buf);
  3216. !     gotoxy(1,2);
  3217.           clreol();
  3218.           textbackground(BLACK);  textcolor(LIGHTGRAY);
  3219.   
  3220.           /* now adjust the top */
  3221. ***************
  3222. *** 294,333 ****
  3223.           }
  3224.   
  3225.           that = *top;
  3226. !         for (i = 0; i < PAGE_LENGTH; i++) {
  3227.               ur = count_unread_in_group(that);
  3228. !             gotoxy(7, i+4);
  3229. !             printf("%4d. %-50s", ((*top)->index)+i, that->group);
  3230. !             if (ur == 0)
  3231. !                 printf("     ", ur);
  3232.               else
  3233. !                 printf(" %4d", ur);
  3234. !             printf(" (%d)\n", that->hi_num - that->lo_num);
  3235.               that = that->next;
  3236. -             if (that == NULL) break;
  3237.           }
  3238.   
  3239.           last_y = this->index - (*top)->index;
  3240. !         gotoxy(5, last_y + PAGE_HEADER);
  3241. !         putch('>');
  3242.           last_index = this->index;
  3243.   
  3244.       } else {
  3245.   
  3246. !         gotoxy(5, last_y + PAGE_HEADER);
  3247. !         putch(' ');
  3248.   
  3249.           last_y += (this->index - last_index);
  3250. !         gotoxy(5, last_y + PAGE_HEADER);
  3251. !         putch('>');
  3252.           last_index = this->index;
  3253.   
  3254.       }
  3255.   
  3256. !     command("ESC=quit   TAB=next unread group   ENTER=read group   '?'=help");
  3257. ! }
  3258. ! 
  3259.   
  3260.   
  3261.   
  3262.   /*--------------------------- process message -------------------------------*/
  3263. --- 337,382 ----
  3264.           }
  3265.   
  3266.           that = *top;
  3267. !         for (i = 0; i < PAGE_LENGTH+1; i++) {
  3268. !             gotoxy(1, i+PAGE_HEADER);
  3269. !             if (that == NULL) break;
  3270.               ur = count_unread_in_group(that);
  3271. !             if (ur > 0)
  3272. !                 printf("    %4d %4ld %s", ur,
  3273. !                        that->hi_num - that->lo_num, that->group);
  3274.               else
  3275. !                 printf("         %4ld %s",
  3276. !                        that->hi_num - that->lo_num, that->group);
  3277. !             clreol();
  3278.               that = that->next;
  3279.           }
  3280.   
  3281. +         clreos();
  3282.           last_y = this->index - (*top)->index;
  3283. !         gotoxy(2, last_y + PAGE_HEADER);
  3284. !         puts("->");
  3285.           last_index = this->index;
  3286.   
  3287.       } else {
  3288.   
  3289. !         gotoxy(2, last_y + PAGE_HEADER);
  3290. !         puts("  ");
  3291.   
  3292.           last_y += (this->index - last_index);
  3293. !         gotoxy(2, last_y + PAGE_HEADER);
  3294. !         puts("->");
  3295.           last_index = this->index;
  3296.   
  3297.       }
  3298.   
  3299. !     gotoxy(_columns - 16,1);
  3300. !     textbackground(LIGHTGRAY);  textcolor(BLACK);
  3301. !     sprintf(buf, "Group %d of %d", last_index + 1, head->groups);
  3302. !     printf("%17s", buf);
  3303. !     textbackground(BLACK);  textcolor(LIGHTGRAY);
  3304.   
  3305. +     message("ESC=quit   TAB=next unread group   ENTER=read group   F1=help");
  3306. + }
  3307.   
  3308.   
  3309.   /*--------------------------- process message -------------------------------*/
  3310. ***************
  3311. *** 341,356 ****
  3312.       ARTICLE *start;
  3313.   
  3314.       if (gp->lo_num < gp->hi_num) {
  3315. - 
  3316. -         clrscr();
  3317. -         printf("                   Select Thread  (%s)  [%ldk]\n", VERSION,
  3318. -                farcoreleft()/1000);
  3319. -         printf("Group: %s ", gp->group);
  3320. - 
  3321.           start = get_headers(gp);
  3322. - 
  3323.           select_thread(gp, start);
  3324. - 
  3325.           free_header(start);
  3326.       }
  3327.   
  3328. --- 390,397 ----
  3329. ***************
  3330. *** 359,365 ****
  3331.   
  3332.   
  3333.   /*-------------------- show the list of active groups -----------------------*/
  3334. ! void show_threads(ACTIVE *gp, ARTICLE **top, ARTICLE *this, int force)
  3335.   {
  3336.       /*
  3337.        *  This routine takes 'top', a pointer to the first line on the screen
  3338. --- 400,407 ----
  3339.   
  3340.   
  3341.   /*-------------------- show the list of active groups -----------------------*/
  3342. ! void show_threads(ACTIVE *gp, ARTICLE **top, ARTICLE *this, int force,
  3343. !                   ARTICLE *head)
  3344.   {
  3345.       /*
  3346.        *  This routine takes 'top', a pointer to the first line on the screen
  3347. ***************
  3348. *** 372,378 ****
  3349.       static last_index;
  3350.       int    i;
  3351.       ARTICLE *that;
  3352. !     int    unread;
  3353.   
  3354.       /*
  3355.        *  If 'this' is above the 'top' or it is more than a screen length below,
  3356. --- 414,421 ----
  3357.       static last_index;
  3358.       int    i;
  3359.       ARTICLE *that;
  3360. !     int    ur;
  3361. !     char buf[32];
  3362.   
  3363.       /*
  3364.        *  If 'this' is above the 'top' or it is more than a screen length below,
  3365. ***************
  3366. *** 385,398 ****
  3367.           ((*top)->index > this->index) ||
  3368.           (this->index - (*top)->index) > PAGE_LENGTH-1) {
  3369.   
  3370. !         clrscr();
  3371.           textbackground(LIGHTGRAY);  textcolor(BLACK);
  3372. !         clreol();
  3373. !         cprintf("                  Select Thread  (%s) [%ldk]\r\n", VERSION,
  3374. !                farcoreleft()/1000);
  3375. !         clreol();
  3376. !         cprintf("Group: %s\r\n", gp->group);
  3377. !         clreol();
  3378.           textbackground(BLACK);  textcolor(LIGHTGRAY);
  3379.   
  3380.           /* now adjust the top */
  3381. --- 428,445 ----
  3382.           ((*top)->index > this->index) ||
  3383.           (this->index - (*top)->index) > PAGE_LENGTH-1) {
  3384.   
  3385. !         for (that = head, ur = 0; that; that = that->next)
  3386. !             ur += count_unread_in_thread(gp, that);
  3387. ! 
  3388. !         gotoxy(1,1);
  3389.           textbackground(LIGHTGRAY);  textcolor(BLACK);
  3390. !         sprintf(buf, "Thread %d of %d", last_index + 1, gp->threads);
  3391. !         printf("Select Thread %*s", _columns - 14, buf);
  3392. !     gotoxy(1,2);
  3393. !         sprintf(buf, "%ld Articles, %d unread",
  3394. !                 gp->hi_num - gp->lo_num, ur);
  3395. !         printf("Group: %-*.*s %26s", _columns - 34, _columns - 34,
  3396. !                gp->group, buf);
  3397.           textbackground(BLACK);  textcolor(LIGHTGRAY);
  3398.   
  3399.           /* now adjust the top */
  3400. ***************
  3401. *** 403,452 ****
  3402.           }
  3403.   
  3404.           that = *top;
  3405. !         for (i = 0; i < PAGE_LENGTH; i++) {
  3406. !             unread = count_unread_in_thread(gp, that),
  3407. !             gotoxy(7, i+4);
  3408. !             if (unread > 0) {
  3409. !                 printf("%4d. %4d %4d %s", ((*top)->index)+i,
  3410. !                        unread,
  3411.                          that->num_articles, that->header);
  3412. !             } else {
  3413. !                 printf("%4d.      %4d %s", ((*top)->index)+i,
  3414.                          that->num_articles, that->header);
  3415. !             }
  3416.               that = that->next;
  3417. -             if (that == NULL) break;
  3418.           }
  3419.   
  3420.           last_y = this->index - (*top)->index;
  3421. !         gotoxy(5, last_y + PAGE_HEADER);
  3422. !         putch('>');
  3423.           last_index = this->index;
  3424.   
  3425.       } else {
  3426.   
  3427. !         gotoxy(5, last_y + PAGE_HEADER);
  3428. !         putch(' ');
  3429.   
  3430.           last_y += (this->index - last_index);
  3431. !         gotoxy(5, last_y + PAGE_HEADER);
  3432. !         putch('>');
  3433.           last_index = this->index;
  3434.   
  3435.       }
  3436.   
  3437. !     command("ESC=select group   TAB=next unread   ENTER=next article   '?'=help");
  3438.   }
  3439.   
  3440.   
  3441.   
  3442.   
  3443. ! /*-------------------------- find which group to read -----------------------*/
  3444.   void select_thread(ACTIVE *gp, ARTICLE *head)
  3445.   {
  3446.       /*
  3447.        *  Present the list of threads, and allow him to move up and down with
  3448. !      *  the arrow and PgUp and PgDn keys.  'h' for help, -/+ for searches
  3449.        */
  3450.   
  3451.       ARTICLE *top;        /* thread at the top of the page    */
  3452. --- 450,589 ----
  3453.           }
  3454.   
  3455.           that = *top;
  3456. !         for (i = 0; i < PAGE_LENGTH+1; i++) {
  3457. !             gotoxy(1, i+PAGE_HEADER);
  3458. !             if (that == NULL) break;
  3459. !             ur = count_unread_in_thread(gp, that);
  3460. !             if (ur > 0)
  3461. !                 printf("    %4d %4d  %s", ur,
  3462.                          that->num_articles, that->header);
  3463. !             else
  3464. !                 printf("         %4d  %s",
  3465.                          that->num_articles, that->header);
  3466. !             clreol();
  3467.               that = that->next;
  3468.           }
  3469.   
  3470. +         clreos();
  3471. + 
  3472.           last_y = this->index - (*top)->index;
  3473. !         gotoxy(2, last_y + PAGE_HEADER);
  3474. !         puts("->");
  3475.           last_index = this->index;
  3476.   
  3477.       } else {
  3478.   
  3479. !         gotoxy(2, last_y + PAGE_HEADER);
  3480. !         puts("  ");
  3481.   
  3482.           last_y += (this->index - last_index);
  3483. !         gotoxy(2, last_y + PAGE_HEADER);
  3484. !         puts("->");
  3485.           last_index = this->index;
  3486.   
  3487. +         gotoxy(_columns - 17,1);
  3488. +         textbackground(LIGHTGRAY);  textcolor(BLACK);
  3489. +         sprintf(buf, "Thread %d of %d", last_index + 1, gp->threads);
  3490. +         printf("%18s", buf);
  3491. +         textbackground(BLACK);  textcolor(LIGHTGRAY);
  3492. + 
  3493.       }
  3494.   
  3495. !     message("ESC=select group   TAB=next unread   ENTER=next article   F1=help");
  3496.   }
  3497.   
  3498.   
  3499.   
  3500. + /*--------------- search through threads ------------------------------------*/
  3501. + ARTICLE *search_thread(ACTIVE *gp, ARTICLE *head, int search_body)
  3502. + {
  3503. +     int offset = 0, found = FALSE, irq = FALSE;
  3504. +     ARTICLE *this;
  3505. +     ART_ID *art;
  3506. +     TEXT *tx;
  3507. +     LINE *text;
  3508. +     char *fn;
  3509. +     char prompt[128], pattern[128];
  3510. + 
  3511. +     if (head == NULL || head->next == NULL)
  3512. +       return head;
  3513.   
  3514. !     sprintf(prompt, "Search %s for? [%s] ",
  3515. !         search_body ? "articles" : "subjects", search_text);
  3516. !     lmessage(prompt);
  3517. !     if (gets(pattern) == NULL)
  3518. !       return head;
  3519. ! 
  3520. !     if (strlen(pattern) > 0)
  3521. !       strcpy(search_text, pattern);
  3522. !     else
  3523. !       strcpy(pattern, search_text);
  3524. ! 
  3525. !     strlwr(pattern);
  3526. ! 
  3527. !     if (search_body) {
  3528. ! 
  3529. !     message("*** searching - please wait (press ESC to abort) ***");
  3530. !     tflush();
  3531. ! 
  3532. !     for (this = head->next; this != NULL; this = this->next) {
  3533. ! 
  3534. !         /* for each article */
  3535. !         for (art = this->art_num; art != NULL; art = art->next_art) {
  3536. !         
  3537. !         fn = make_news_group_name(gp->group);
  3538. !         tx = load_article(fn, art->art_off);
  3539. ! 
  3540. !         for (text = tx->start; !found && text != NULL; 
  3541. !              text = text->next) {
  3542. !             strlwr(text->data);
  3543. !             found = (strstr(text->data, pattern) != NULL);
  3544. !         }
  3545. !     
  3546. !         free_article(tx);
  3547. ! 
  3548. !         if (kbhit())
  3549. !           irq = (getch() == 27);
  3550. ! 
  3551. !         if (found || irq)
  3552. !           break;
  3553. !         }
  3554. ! 
  3555. !         if (found || irq) 
  3556. !           break;
  3557. !     }
  3558. ! 
  3559. !     } else {
  3560. ! 
  3561. !     for (this = head->next; this != NULL; this = this->next) {
  3562. ! 
  3563. !         strcpy(prompt, this->header);
  3564. !         strlwr(prompt);
  3565. !         found = (strstr(prompt, pattern) != NULL);
  3566. ! 
  3567. !         if (found)
  3568. !           break;
  3569. !     }
  3570. ! 
  3571. !     }
  3572. ! 
  3573. !     if (!found && !irq) {
  3574. !     sprintf(prompt, "*** '%s' not found - press any key  ***", pattern);
  3575. !     message(prompt);
  3576. !     getch();
  3577. !     }
  3578. ! 
  3579. !     return found ? this : head;
  3580. ! }
  3581. ! 
  3582. ! 
  3583. ! 
  3584. ! /*-------------------------- find which thread to read ----------------------*/
  3585.   void select_thread(ACTIVE *gp, ARTICLE *head)
  3586.   {
  3587.       /*
  3588.        *  Present the list of threads, and allow him to move up and down with
  3589. !      *  the arrow and PgUp and PgDn keys.
  3590.        */
  3591.   
  3592.       ARTICLE *top;        /* thread at the top of the page    */
  3593. ***************
  3594. *** 454,469 ****
  3595.       ARTICLE *th;
  3596.       ART_ID  *art;
  3597.       int    exit_code;    /* why we are exiting the loop      */
  3598. -     char   sub_tmp[80];
  3599.   
  3600.       int    ch, i, idx, hit, a_ct;
  3601.   
  3602.       this = head;
  3603. - 
  3604.       top = head;
  3605.       exit_code = 0;
  3606.   
  3607. !     show_threads(gp, &top, this, TRUE);
  3608.   
  3609.       while (exit_code == 0) {
  3610.   
  3611. --- 591,604 ----
  3612.       ARTICLE *th;
  3613.       ART_ID  *art;
  3614.       int    exit_code;    /* why we are exiting the loop      */
  3615.   
  3616.       int    ch, i, idx, hit, a_ct;
  3617.   
  3618.       this = head;
  3619.       top = head;
  3620.       exit_code = 0;
  3621.   
  3622. !     show_threads(gp, &top, this, TRUE, head);
  3623.   
  3624.       while (exit_code == 0) {
  3625.   
  3626. ***************
  3627. *** 471,480 ****
  3628. --- 606,621 ----
  3629.           switch (ch) {
  3630.   
  3631.               case 0      :
  3632. +             case 0xE0   :
  3633.                   ch = getch();
  3634.   
  3635.                   switch (ch) {
  3636.   
  3637. +                     case F1     :
  3638. +                     show_help(HELP_THREAD);
  3639. +                     show_threads(gp, &top, this, TRUE, head);
  3640. +                         break;
  3641. +                         
  3642.                       case UP_ARR :
  3643.                           if (this->last != NULL) this = this->last;
  3644.                           break;
  3645. ***************
  3646. *** 499,505 ****
  3647.   
  3648.                       case HOME   :
  3649.                           top = this = head;
  3650. !                         show_threads(gp, &top, this, TRUE);
  3651.                           break;
  3652.                       case END    :
  3653.                           this = head;
  3654. --- 640,646 ----
  3655.   
  3656.                       case HOME   :
  3657.                           top = this = head;
  3658. !                         show_threads(gp, &top, this, TRUE, head);
  3659.                           break;
  3660.                       case END    :
  3661.                           this = head;
  3662. ***************
  3663. *** 510,527 ****
  3664.                   break;
  3665.   
  3666.               case 's'    :
  3667.                   save_thread_to_disk(gp, this);
  3668.                   break;
  3669.   
  3670.               case 'p'    :
  3671. !                 strcpy(sub_tmp, "");
  3672. !                 post(NULL, gp->group, sub_tmp);
  3673. !                 show_threads(gp, &top, this, TRUE);
  3674.                   break;
  3675.   
  3676. -             case '?'    :
  3677.               case 'h'    :
  3678.                   show_help(HELP_THREAD);
  3679.                   break;
  3680.   
  3681.               case TAB    :
  3682. --- 651,670 ----
  3683.                   break;
  3684.   
  3685.               case 's'    :
  3686. +             case 'S'    :
  3687.                   save_thread_to_disk(gp, this);
  3688.                   break;
  3689.   
  3690.               case 'p'    :
  3691. !             case 'P'    :
  3692. !                 post(NULL, gp->group);
  3693. !                 show_threads(gp, &top, this, TRUE, head);
  3694.                   break;
  3695.   
  3696.               case 'h'    :
  3697. +             case 'H'    :
  3698.                   show_help(HELP_THREAD);
  3699. +                 show_threads(gp, &top, this, TRUE, head);
  3700.                   break;
  3701.   
  3702.               case TAB    :
  3703. ***************
  3704. *** 554,575 ****
  3705.                   }
  3706.   
  3707.                   if (hit) {
  3708. !                     this = th;
  3709.                       read_thread(gp, this, art, a_ct);
  3710. !                     show_threads(gp, &top, this, TRUE);
  3711. !                 } else {
  3712. !                     message("-- No more articles to read --");
  3713.                   }
  3714.                   break;
  3715.   
  3716.               case 'c'    :
  3717. !                 mark_group_as_read(gp);
  3718. !                 show_threads(gp, &top, this, TRUE);
  3719.                   break;
  3720.   
  3721.               case ENTER  :
  3722.                   read_thread(gp, this, this->art_num, 1);
  3723. !                 show_threads(gp, &top, this, TRUE);
  3724.                   break;
  3725.   
  3726.               case ESCAPE :
  3727. --- 697,735 ----
  3728.                   }
  3729.   
  3730.                   if (hit) {
  3731. !                     if (this == th )
  3732.                           read_thread(gp, this, art, a_ct);
  3733. !                     this = th;
  3734. !                     show_threads(gp, &top, this, TRUE, head);
  3735.                   }
  3736.                   break;
  3737.   
  3738.               case 'c'    :
  3739. !             case 'C'    :
  3740. !                 mark_thread_as_read(gp, this);
  3741. !                 show_threads(gp, &top, this, TRUE, head);
  3742.                   break;
  3743.   
  3744.               case ENTER  :
  3745.                   read_thread(gp, this, this->art_num, 1);
  3746. !                 show_threads(gp, &top, this, TRUE, head);
  3747. !                 break;
  3748. ! 
  3749. !             case BACKSP :
  3750. !             art = this->art_num;
  3751. !         a_ct = 1;
  3752. !         while (art->next_art != NULL) {
  3753. !             a_ct++;
  3754. !             art = art->next_art;
  3755. !         }
  3756. !                 read_thread(gp, this, art, a_ct);
  3757. !                 show_threads(gp, &top, this, TRUE, head);
  3758. !                 break;
  3759. ! 
  3760. !         case '+'    :
  3761. !         case '/'    :
  3762. !             this = search_thread(gp, this, ch == '/');
  3763. !                 show_threads(gp, &top, this, TRUE, head);
  3764.                   break;
  3765.   
  3766.               case ESCAPE :
  3767. ***************
  3768. *** 577,583 ****
  3769.                   break;
  3770.           };
  3771.           if (exit_code == 0)
  3772. !             show_threads(gp, &top, this, FALSE);
  3773.       }
  3774.   
  3775.   
  3776. --- 737,743 ----
  3777.                   break;
  3778.           };
  3779.           if (exit_code == 0)
  3780. !             show_threads(gp, &top, this, FALSE, head);
  3781.       }
  3782.   
  3783.   
  3784. ***************
  3785. *** 586,592 ****
  3786.   
  3787.   
  3788.   
  3789. ! /*------------------------ read a thread ------------------------------*/
  3790.   void save_thread_to_disk(ACTIVE *gp, ARTICLE *this)
  3791.   {
  3792.       ART_ID *id;
  3793. --- 746,761 ----
  3794.   
  3795.   
  3796.   
  3797. ! /*------------------------ save a thread ------------------------------*/
  3798. ! 
  3799. ! int cmp(TEXT **art1, TEXT **art2)
  3800. ! {
  3801. !     char *subj1 = (*art1) -> subject, *subj2 = (*art2) -> subject;
  3802. !     while (isspace(*subj1)) subj1++;
  3803. !     while (isspace(*subj2)) subj2++;
  3804. !     return strcmp(subj1, subj2);
  3805. ! }
  3806. ! 
  3807.   void save_thread_to_disk(ACTIVE *gp, ARTICLE *this)
  3808.   {
  3809.       ART_ID *id;
  3810. ***************
  3811. *** 593,607 ****
  3812.       char   *fn;
  3813.       TEXT   *tx;
  3814.       LINE   *ln;
  3815. !     int    a_ct;
  3816. !     char   fnx[80];
  3817. !     int    ch;
  3818. !     FILE   *tmp;
  3819.       
  3820. !     message("Enter filename? ");
  3821.       gets(fnx);
  3822.   
  3823. -     tmp = NULL;
  3824.       if (access(fnx, 0) == 0) {
  3825.   
  3826.           message("File exists - append(y/n)? ");
  3827. --- 762,778 ----
  3828.       char   *fn;
  3829.       TEXT   *tx;
  3830.       LINE   *ln;
  3831. !     char   fnx[256];
  3832. !     int    ch, art, idx;
  3833. !     TEXT   *text[MAXART];
  3834. !     FILE   *tmp = NULL;
  3835. !     time_t now;
  3836. !     struct tm *tmnow;
  3837. !     char timestr[64];
  3838.       
  3839. !     lmessage("Enter filename? ");
  3840.       gets(fnx);
  3841.   
  3842.       if (access(fnx, 0) == 0) {
  3843.   
  3844.           message("File exists - append(y/n)? ");
  3845. ***************
  3846. *** 608,615 ****
  3847.           while (((ch = getch()) != 'y') && (ch != 'n'));
  3848.           if (ch == 'y') {
  3849.               if ((tmp = fopen(fnx, "at")) == NULL) {
  3850. !                 message("*** Cannot open file for appending - "
  3851. !                         "please any key to continue ***");
  3852.                   getch();
  3853.               }
  3854.           }
  3855. --- 779,786 ----
  3856.           while (((ch = getch()) != 'y') && (ch != 'n'));
  3857.           if (ch == 'y') {
  3858.               if ((tmp = fopen(fnx, "at")) == NULL) {
  3859. !                 message("*** cannot open file for appending - "
  3860. !                         "please any key ***");
  3861.                   getch();
  3862.               }
  3863.           }
  3864. ***************
  3865. *** 617,641 ****
  3866.       } else {
  3867.   
  3868.           if ((tmp = fopen(fnx, "wt")) == NULL) {
  3869. !             message("*** Cannot open file for output - press a key to continue ***");
  3870.               getch();
  3871.           }
  3872.   
  3873.       }
  3874.   
  3875. - 
  3876. - 
  3877. - 
  3878.       if (tmp != NULL) {
  3879.   
  3880.           fn = make_news_group_name(gp->group);
  3881.   
  3882.           id = this->art_num;
  3883. !         a_ct = 0;
  3884.       
  3885. !         while (id != NULL) {
  3886.   
  3887. !             tx = load_article(fn, id->art_off);
  3888.           
  3889.               ln = tx->top;
  3890.               while (ln != NULL) {
  3891. --- 788,830 ----
  3892.       } else {
  3893.   
  3894.           if ((tmp = fopen(fnx, "wt")) == NULL) {
  3895. !             message("*** cannot open file for output - press any key ***");
  3896.               getch();
  3897.           }
  3898.       
  3899. +     setvbuf(tmp, iobuf, _IOFBF, IOBUFSIZE);
  3900.       }
  3901.   
  3902.       if (tmp != NULL) {
  3903.   
  3904.           fn = make_news_group_name(gp->group);
  3905.   
  3906.           id = this->art_num;
  3907. !     idx = 0;
  3908.       
  3909. !         while (id != NULL && idx < MAXART) {
  3910. !         text[idx++] = load_article(fn, id->art_off);
  3911. !             id = id->next_art;
  3912. !         }
  3913.   
  3914. !     qsort(text, idx, sizeof(TEXT *), cmp);
  3915. !     
  3916. !         time(&now);
  3917. !     tmnow = localtime(&now);
  3918. !     strftime(timestr, sizeof(timestr), "%a %b %d %H:%M:%S %z %Y", tmnow);
  3919. ! 
  3920. !     for ( art = 0; art < idx; art++ ) {
  3921. !         
  3922. !             tx = text[art];
  3923. ! 
  3924. !         ln = tx->top;
  3925. !         while (ln != NULL && strncmp(ln->data, "Path: ", 6)) {
  3926. !              ln = ln->next;
  3927. !         }
  3928. !         strcpy(fn, ln->data + 6);
  3929. !         for ( ch = strlen(fn); fn[ch - 1] == '\n' || fn[ch - 1] == '\r'; ch--)
  3930. !             fn[ch - 1] = 0;
  3931. !         fprintf(tmp, "From %s %s\n", fn, timestr);
  3932.   
  3933.               ln = tx->top;
  3934.               while (ln != NULL) {
  3935. ***************
  3936. *** 642,664 ****
  3937.                   fputs(ln->data, tmp);
  3938.                   ln = ln->next;
  3939.               }
  3940.               fputs("\n\n", tmp);
  3941.   
  3942. !             a_ct++;
  3943. !             id = id->next_art;
  3944.   
  3945.               free_article(tx);
  3946.   
  3947.       }
  3948.       
  3949. !         fclose(tmp);
  3950.       }
  3951.   
  3952. !     message("");
  3953.   }
  3954.   
  3955.   
  3956. - 
  3957.   /*------------------------ read a thread ------------------------------*/
  3958.   int read_thread(ACTIVE *gp, ARTICLE *this, ART_ID *first, int a_ct)
  3959.   {
  3960. --- 831,898 ----
  3961.                   fputs(ln->data, tmp);
  3962.                   ln = ln->next;
  3963.               }
  3964. + 
  3965.               fputs("\n\n", tmp);
  3966. +             free_article(tx);
  3967. +     }
  3968.       
  3969. !         fclose(tmp);
  3970. !     }
  3971. ! }
  3972. ! 
  3973. ! 
  3974.   
  3975. + /*------------------------ search through articles --------------------*/
  3976. + int search_message(char *fn, ART_ID *current, int forward)
  3977. + {
  3978. +     int offset = 0, found = FALSE;
  3979. +     TEXT *tx;
  3980. +     LINE *text;
  3981. +     char prompt[128], pattern[128];
  3982. + 
  3983. +     sprintf(prompt, "Search %s for? [%s] ",
  3984. +         forward ? "forward" : "backward", search_text);
  3985. +     lmessage(prompt);
  3986. +     if (gets(pattern) == NULL)
  3987. +       return 0;
  3988. + 
  3989. +     if (strlen(pattern) > 0)
  3990. +       strcpy(search_text, pattern);
  3991. +     else
  3992. +       strcpy(pattern, search_text);
  3993. + 
  3994. +     strlwr(pattern);
  3995. + 
  3996. +     for (;;) {
  3997. + 
  3998. +     current = forward ? current->next_art : current->last_art;
  3999. +     if (current == NULL)
  4000. +       break;
  4001. + 
  4002. +     offset++;
  4003. +         tx = load_article(fn, current->art_off);
  4004. + 
  4005. +     for (text = tx->start; !found && text != NULL; text = text->next) {
  4006. +         strlwr(text->data);
  4007. +         found = (strstr(text->data, pattern) != NULL);
  4008. +     }
  4009. +     
  4010.           free_article(tx);
  4011.   
  4012. +     if (found)
  4013. +       break;
  4014.       }
  4015.   
  4016. !     if (!found) {
  4017. !     sprintf(prompt, "*** '%s' not found - press any key  ***", pattern);
  4018. !     message(prompt);
  4019. !     getch();
  4020.       }
  4021.   
  4022. !     return found ? offset : 0;
  4023.   }
  4024.   
  4025.   
  4026.   /*------------------------ read a thread ------------------------------*/
  4027.   int read_thread(ACTIVE *gp, ARTICLE *this, ART_ID *first, int a_ct)
  4028.   {
  4029. ***************
  4030. *** 679,689 ****
  4031.   
  4032.           tx = load_article(fn, id->art_off);
  4033.   
  4034. !         res = read_article(gp, tx, this->header, a_ct, this->num_articles);
  4035.   
  4036.           /* mark this article as read */
  4037.           idx = (int) ((id->id) - gp->lo_num - 1);
  4038. !         *((gp->read_list)+idx) = TRUE;
  4039.   
  4040.           /* mark the crossposts */
  4041.           get_his_stuff(tx, author, msg_id);
  4042. --- 913,923 ----
  4043.   
  4044.           tx = load_article(fn, id->art_off);
  4045.   
  4046. !         res = read_article(gp, tx, a_ct, this->num_articles);
  4047.   
  4048.           /* mark this article as read */
  4049.           idx = (int) ((id->id) - gp->lo_num - 1);
  4050. !         (gp->read_list)[idx] = TRUE;
  4051.   
  4052.           /* mark the crossposts */
  4053.           get_his_stuff(tx, author, msg_id);
  4054. ***************
  4055. *** 693,699 ****
  4056.               while (h != NULL) {
  4057.                   gx = find_news_group(h->group);
  4058.                   idx = (int) ((h->art_num) - gx->lo_num - 1);
  4059. !                 *((gx->read_list)+idx) = TRUE;
  4060.                   h = h->next;
  4061.               }
  4062.   
  4063. --- 927,934 ----
  4064.               while (h != NULL) {
  4065.                   gx = find_news_group(h->group);
  4066.                   idx = (int) ((h->art_num) - gx->lo_num - 1);
  4067. !                 if ( 0 <= idx && idx < gx->hi_num )
  4068. !                   (gx->read_list)[idx] = TRUE;
  4069.                   h = h->next;
  4070.               }
  4071.   
  4072. ***************
  4073. *** 700,705 ****
  4074. --- 935,942 ----
  4075.               free_cross_post_list(h0);
  4076.           }
  4077.   
  4078. +         free_article(tx);
  4079. + 
  4080.           if (res == EX_QUIT) break;
  4081.   
  4082.           if (res == EX_NEXT_UNREAD) {
  4083. ***************
  4084. *** 713,728 ****
  4085.                   id = id->next_art;
  4086.               }
  4087.   
  4088. !             if (id == NULL)
  4089. !                 message("-- No more articles in thread --");
  4090. ! 
  4091.           } else {
  4092.               a_ct++;
  4093.               id = id->next_art;
  4094.           }
  4095. - 
  4096. -         free_article(tx);
  4097. - 
  4098.       }
  4099.   
  4100.       return(res);
  4101. --- 950,974 ----
  4102.                   id = id->next_art;
  4103.               }
  4104.   
  4105. !         } else if (res == EX_SEARCH_FORW) {
  4106. !         res = search_message(fn, id, 1);
  4107. !         while (res--) {
  4108. !         a_ct++;
  4109. !                 id = id->next_art;
  4110. !         }
  4111. !         } else if (res == EX_SEARCH_BACKW) {
  4112. !         res = search_message(fn, id, 0);
  4113. !         while (res--) {
  4114. !         a_ct--;
  4115. !         id = id->last_art;
  4116. !         }
  4117. !         } else if (res == EX_PREVIOUS) {
  4118. !             a_ct--;
  4119. !             id = id->last_art;
  4120.           } else {
  4121.               a_ct++;
  4122.               id = id->next_art;
  4123.           }
  4124.       }
  4125.   
  4126.       return(res);
  4127. ***************
  4128. *** 732,737 ****
  4129. --- 978,1114 ----
  4130.   
  4131.   
  4132.   /*------------------------- read the headers --------------------------*/
  4133. + 
  4134. + int strip_off_part(char *str)
  4135. + {
  4136. +   char *ptr = str + strlen(str);
  4137. + 
  4138. +   /* strip off (case-insensitive) things like:
  4139. +      - "Part01/10"
  4140. +      - "Part 01/10"
  4141. +      - "Part 01 of 10"
  4142. +      - "[1/10]"
  4143. +      - "(1 of 10)"
  4144. +      - "1 of 10"
  4145. +      - "Patch02a/04"
  4146. +      - "Patch20"
  4147. +    */
  4148. + 
  4149. +   while ( ptr > str && ptr[-1] == ' ' )
  4150. +     ptr--;
  4151. + 
  4152. +   if ( ptr > str && (ptr[-1] == ')' || ptr[-1] == ']') )
  4153. +     ptr--;
  4154. + 
  4155. +   while ( ptr > str && isdigit(ptr[-1]) )
  4156. +     ptr--;
  4157. + 
  4158. +   if ( !isdigit(*ptr) )
  4159. +     return 0;
  4160. + 
  4161. +   if ( ptr > str && ptr[-1] == '/' )
  4162. +     ptr--;
  4163. +   else if ( ptr > str + 3 && strnicmp(ptr - 4, " of ", 4) == 0 )
  4164. +     ptr -= 4;
  4165. +   else if ( ptr > str + 4 && strnicmp(ptr - 5, "Patch", 5) == 0 )
  4166. +   {
  4167. +     ptr -= 5;
  4168. +     goto label;
  4169. +   }
  4170. +   else if ( ptr > str + 5 && strnicmp(ptr - 6, "Patch ", 6) == 0 )
  4171. +   {
  4172. +     ptr -= 6;
  4173. +     goto label;
  4174. +   }
  4175. +   else
  4176. +     return 0;
  4177. + 
  4178. +   if ( ptr > str && 'a' <= ptr[-1] && ptr[-1] <= 'z' )
  4179. +     ptr--;
  4180. + 
  4181. +   while ( ptr > str && isdigit(ptr[-1]) )
  4182. +     ptr--;
  4183. + 
  4184. +   if ( !isdigit(*ptr) )
  4185. +     return 0;
  4186. + 
  4187. +   if ( ptr > str && (ptr[-1] == '(' || ptr[-1] == '[') )
  4188. +     ptr--;
  4189. + 
  4190. +   while ( ptr > str && ptr[-1] == ' ' )
  4191. +     ptr--;
  4192. + 
  4193. +   if ( ptr > str + 3 && strnicmp(ptr - 4, "Part", 4) == 0 )
  4194. +     ptr -= 4;
  4195. + 
  4196. + label:    
  4197. +   while ( ptr > str && ptr[-1] == ' ' )
  4198. +     ptr--;
  4199. + 
  4200. +   if ( ptr > str && ptr[-1] == ',' )
  4201. +     ptr--;
  4202. +   else if ( ptr > str && ptr[-1] == ':' )
  4203. +     ptr--;
  4204. + 
  4205. +   *ptr = 0;
  4206. +   return 1;
  4207. + }
  4208. + 
  4209. + char *skip_vi(char *str)
  4210. + {
  4211. +   char *ptr = str;
  4212. + 
  4213. +   /* skip things like "v02i0027: " */
  4214. + 
  4215. +   while ( isspace(*ptr) )
  4216. +     ptr++;
  4217. + 
  4218. +   if ( *ptr++ != 'v' )
  4219. +     return str;
  4220. + 
  4221. +   if ( !isdigit(*ptr) )
  4222. +     return str;
  4223. + 
  4224. +   while ( isdigit(*ptr) )
  4225. +     ptr++;
  4226. + 
  4227. +   if ( *ptr++ != 'i' )
  4228. +     return str;
  4229. + 
  4230. +   if ( !isdigit(*ptr) )
  4231. +     return str;
  4232. + 
  4233. +   while ( isdigit(*ptr) )
  4234. +     ptr++;
  4235. + 
  4236. +   if ( *ptr++ != ':' )
  4237. +     return str;
  4238. + 
  4239. +   if ( *ptr++ != ' ' )
  4240. +     return str;
  4241. + 
  4242. +   while ( isspace(*ptr) )
  4243. +     ptr++;
  4244. + 
  4245. +   return ptr;
  4246. + }
  4247. + 
  4248. + int smartcmp(char *str1, char *str2)
  4249. + {
  4250. +   char s1[256], s2[256];
  4251. + 
  4252. +   strcpy(s1, str1);
  4253. +   strcpy(s2, str2);
  4254. + 
  4255. +   if ( strip_off_part(s1) && strip_off_part(s2) )
  4256. +   {
  4257. +     str1 = skip_vi(s1);
  4258. +     str2 = skip_vi(s2);
  4259. +   }
  4260. + 
  4261. +   return stricmp(str1, str2);
  4262. + }
  4263. + 
  4264.   ARTICLE *get_headers(ACTIVE *gp)
  4265.   {
  4266.       /*
  4267. ***************
  4268. *** 739,751 ****
  4269.        */
  4270.   
  4271.       char *fn;
  4272. !     char buf[256], fnx[256], *buf_p;
  4273.       long g, n_read;
  4274.       FILE *tmp_file;
  4275.   
  4276.       ARTICLE *start, *that, *tmp;
  4277.       ART_ID  *art_this, *new;
  4278. !     int     ct_art;
  4279.   
  4280.       n_read = 0;
  4281.       ct_art = 0;
  4282. --- 1116,1129 ----
  4283.        */
  4284.   
  4285.       char *fn;
  4286. !     char buf[MAXLINE], fnx[256], *buf_p;
  4287.       long g, n_read;
  4288.       FILE *tmp_file;
  4289.   
  4290.       ARTICLE *start, *that, *tmp;
  4291. +     ARTICLE **ptr;
  4292.       ART_ID  *art_this, *new;
  4293. !     int     ct_art, cmp;
  4294.   
  4295.       n_read = 0;
  4296.       ct_art = 0;
  4297. ***************
  4298. *** 754,766 ****
  4299.       fn = make_news_group_name(gp->group);
  4300.       sprintf(fnx, "%s.IDX", fn);
  4301.   
  4302. !     if ((tmp_file = fopen(fnx, "rb")) != NULL) {
  4303.   
  4304.           for (g = gp->lo_num+1; g <= gp->hi_num; g++) {
  4305.   
  4306. !             if ((n_read++ %10) == 0) {
  4307. !                 gotoxy(1,25);
  4308.                   printf("%d articles processed", n_read-1);
  4309.               }
  4310.   
  4311.               /*
  4312. --- 1132,1150 ----
  4313.       fn = make_news_group_name(gp->group);
  4314.       sprintf(fnx, "%s.IDX", fn);
  4315.   
  4316. !     if ((tmp_file = flockopen(fnx, "rb")) != NULL) {
  4317.   
  4318. +         setvbuf(tmp_file, iobuf, _IOFBF, IOBUFSIZE);
  4319. + 
  4320.           for (g = gp->lo_num+1; g <= gp->hi_num; g++) {
  4321.   
  4322. !             if ((n_read++ % 100) == 0) {
  4323. !                 gotoxy(1,PAGE_SIZE);
  4324. !                 textbackground(LIGHTGRAY);  textcolor(BLACK);
  4325.                   printf("%d articles processed", n_read-1);
  4326. +                 clreol();
  4327. +                 textbackground(BLACK);  textcolor(LIGHTGRAY);
  4328. +                 tflush();
  4329.               }
  4330.   
  4331.               /*
  4332. ***************
  4333. *** 770,777 ****
  4334.                *    - add to the existing list
  4335.                */
  4336.   
  4337. !             if (fgets(buf, 255, tmp_file) == NULL) {
  4338. !                 gotoxy(1,25);
  4339.                   fprintf(stderr, "\nsnews: index file is corrupt\n");
  4340.                   exit(1);
  4341.               }
  4342. --- 1154,1161 ----
  4343.                *    - add to the existing list
  4344.                */
  4345.   
  4346. !             if (fgets(buf, sizeof(buf), tmp_file) == NULL) {
  4347. !                 gotoxy(1,PAGE_SIZE);
  4348.                   fprintf(stderr, "\nsnews: index file is corrupt\n");
  4349.                   exit(1);
  4350.               }
  4351. ***************
  4352. *** 778,784 ****
  4353.   
  4354.               /* check all is in sync */
  4355.               if (g != atol(buf+9)) {
  4356. !                 gotoxy(1,25);
  4357.                   fprintf(stderr, "\nsnews: article %ld found when %ld"
  4358.                       "expected\n", atol(buf+9), g);
  4359.                   exit(1);
  4360. --- 1162,1168 ----
  4361.   
  4362.               /* check all is in sync */
  4363.               if (g != atol(buf+9)) {
  4364. !                 gotoxy(1,PAGE_SIZE);
  4365.                   fprintf(stderr, "\nsnews: article %ld found when %ld"
  4366.                       "expected\n", atol(buf+9), g);
  4367.                   exit(1);
  4368. ***************
  4369. *** 786,808 ****
  4370.   
  4371.               /* skip the two eight digit numbers and the 9 and the spaces */
  4372.               buf_p = buf+28;
  4373. - 
  4374.               eat_gunk(buf_p);
  4375. !             tmp = start;
  4376. !             while (tmp != NULL) {
  4377. !                 if (stricmp(buf_p, tmp->header) == 0)
  4378.               break;
  4379. -                 tmp = tmp->next;
  4380.               }
  4381. ! 
  4382. !             if (tmp != NULL) {
  4383.           
  4384.               /* allocate new article number */
  4385.               new = xmalloc(sizeof (ART_ID));
  4386.               new->id = g;
  4387.               new->art_off = atol(buf);
  4388. -                 new->next_art = NULL;
  4389. -                 tmp->num_articles++;
  4390.   
  4391.               /* place it at the end */
  4392.               art_this = tmp->art_num;
  4393. --- 1170,1207 ----
  4394.   
  4395.               /* skip the two eight digit numbers and the 9 and the spaces */
  4396.               buf_p = buf+28;
  4397.               eat_gunk(buf_p);
  4398. ! 
  4399. !             for ( tmp = start; tmp != NULL; ) {
  4400. ! 
  4401. !         cmp = smartcmp(buf_p, tmp->header);
  4402. ! 
  4403. !                 if (cmp > 0) {
  4404. !             if (tmp->left)
  4405. !                 tmp = tmp->left;
  4406. !             else {
  4407. !             ptr = &(tmp->left);
  4408. !             tmp = NULL;
  4409.               break;
  4410.               }
  4411. !         }
  4412. !         else if (cmp < 0) {
  4413. !             if (tmp->right)
  4414. !                 tmp = tmp->right;
  4415. !             else {
  4416. !             ptr = &(tmp->right);
  4417. !             tmp = NULL;
  4418. !             break;
  4419. !             }
  4420. !         }
  4421. !         else {
  4422. !             /* found this subject */
  4423. !              tmp->num_articles++;
  4424.   
  4425.               /* allocate new article number */
  4426.               new = xmalloc(sizeof (ART_ID));
  4427.               new->id = g;
  4428.               new->art_off = atol(buf);
  4429.   
  4430.               /* place it at the end */
  4431.               art_this = tmp->art_num;
  4432. ***************
  4433. *** 809,858 ****
  4434.               while (art_this->next_art != NULL) {
  4435.               art_this = art_this->next_art;
  4436.               }
  4437. - 
  4438.               art_this->next_art = new;
  4439.               
  4440. !             } else {
  4441.   
  4442.                   /* not found - allocate new thread */
  4443.                   if (start == NULL) {
  4444. !                     start = that = xmalloc(sizeof (ARTICLE));
  4445. !                     start->last = NULL;
  4446. !                     start->next = NULL;
  4447. !                     start->index = ct_art;
  4448.                   } else {
  4449.                       ct_art++;
  4450.                       that->next = xmalloc(sizeof (ARTICLE));
  4451.                       that->next->last = that;
  4452.                       that = that->next;
  4453.           that->next = NULL;
  4454.           that->index = ct_art;
  4455. !                 }
  4456.   
  4457.                   /* store article data */
  4458.                   strcpy(that->header, buf_p);
  4459.                   that->num_articles = 1;
  4460.                   that->art_num = xmalloc(sizeof (ART_ID));
  4461.                   that->art_num->next_art = NULL;
  4462.                   that->art_num->id = g;
  4463.                   that->art_num->art_off = atol(buf);
  4464.   
  4465.               }
  4466. - 
  4467. -             that->next = NULL;
  4468. - 
  4469.           }
  4470.   
  4471.           fclose(tmp_file);
  4472.   
  4473.       } else {
  4474. !         gotoxy(1,25);
  4475.           fprintf(stderr, "\nsnews: can't open index file %s\n", fnx);
  4476.           exit(1);
  4477.       }
  4478.   
  4479. !     return(start);
  4480.   
  4481.   }
  4482.   
  4483.   
  4484. --- 1208,1267 ----
  4485.               while (art_this->next_art != NULL) {
  4486.               art_this = art_this->next_art;
  4487.               }
  4488.               art_this->next_art = new;
  4489.   
  4490. !             new->last_art = art_this;
  4491. !             new->next_art = NULL;
  4492. ! 
  4493. !             break;
  4494. !         }
  4495.   
  4496. +             }
  4497. + 
  4498. +             if (tmp == NULL) {
  4499.                   /* not found - allocate new thread */
  4500. + 
  4501.                   if (start == NULL) {
  4502. !                     start = xmalloc(sizeof (ARTICLE));
  4503. !             that = start;
  4504. !                     that->last = NULL;
  4505.                   } else {
  4506.                       ct_art++;
  4507.                       that->next = xmalloc(sizeof (ARTICLE));
  4508.                       that->next->last = that;
  4509.                       that = that->next;
  4510. +             *ptr = that;
  4511. +                 }
  4512. + 
  4513.           that->next = NULL;
  4514.           that->index = ct_art;
  4515. !         that->left = that->right = NULL;
  4516.   
  4517.                   /* store article data */
  4518. +                 that->header = xmalloc(strlen(buf_p) + 1);
  4519.                   strcpy(that->header, buf_p);
  4520.                   that->num_articles = 1;
  4521. + 
  4522.                   that->art_num = xmalloc(sizeof (ART_ID));
  4523. +                 that->art_num->last_art = NULL;
  4524.                   that->art_num->next_art = NULL;
  4525.                   that->art_num->id = g;
  4526.                   that->art_num->art_off = atol(buf);
  4527.   
  4528.               }
  4529.           }
  4530.   
  4531.           fclose(tmp_file);
  4532.   
  4533.       } else {
  4534. !         gotoxy(1,PAGE_SIZE);
  4535.           fprintf(stderr, "\nsnews: can't open index file %s\n", fnx);
  4536.           exit(1);
  4537.       }
  4538.   
  4539. !     gp->threads = ct_art + 1;
  4540.   
  4541. +     return(start);
  4542.   }
  4543.   
  4544.   
  4545. ***************
  4546. *** 862,877 ****
  4547.   {
  4548.       /*
  4549.        *  This routine take the header line, and strips the
  4550. !      *  word header word, 'Re:', and any extra blanks, trim to 59 chars
  4551.        */
  4552.   
  4553. !     char *p, tmp[256];
  4554. ! 
  4555. !     buf[58] = 0;
  4556.   
  4557. - 
  4558.       /* strip the Subject: etc off the front */
  4559. !     while ((strstr(buf, "Re:") != NULL) ||
  4560.           (strnicmp(buf, "From:", 5) == 0) ||
  4561.           (strnicmp(buf, "Path:", 5) == 0) ||
  4562.           (strnicmp(buf, "Subject:", 8) == 0) ||
  4563. --- 1271,1283 ----
  4564.   {
  4565.       /*
  4566.        *  This routine take the header line, and strips the
  4567. !      *  word header word, 'Re:', and any extra blanks
  4568.        */
  4569.   
  4570. !     char *p, tmp[MAXLINE];
  4571.   
  4572.       /* strip the Subject: etc off the front */
  4573. !     while ( /*(strstr(buf, "Re:") != NULL) ||*/
  4574.           (strnicmp(buf, "From:", 5) == 0) ||
  4575.           (strnicmp(buf, "Path:", 5) == 0) ||
  4576.           (strnicmp(buf, "Subject:", 8) == 0) ||
  4577. ***************
  4578. *** 878,884 ****
  4579.           (strnicmp(buf, "Organization:", 13) == 0) ||
  4580.           (strnicmp(buf, "Organisation:", 13) == 0) ||
  4581.           (strnicmp(buf, "Followup-To:", 12) == 0)) {
  4582. !         p = strstr(buf, ":");
  4583.           strcpy(buf, p+1);
  4584.       }
  4585.   
  4586. --- 1284,1290 ----
  4587.           (strnicmp(buf, "Organization:", 13) == 0) ||
  4588.           (strnicmp(buf, "Organisation:", 13) == 0) ||
  4589.           (strnicmp(buf, "Followup-To:", 12) == 0)) {
  4590. !         p = strchr(buf, ':');
  4591.           strcpy(buf, p+1);
  4592.       }
  4593.   
  4594. ***************
  4595. *** 925,930 ****
  4596. --- 1331,1337 ----
  4597.           }
  4598.   
  4599.           t = a->next;
  4600. +         free(a->header);
  4601.           free(a);
  4602.           a = t;
  4603.       }
  4604. ***************
  4605. *** 970,975 ****
  4606. --- 1377,1383 ----
  4607.       ct = 0;
  4608.       articles = (int)(gp->hi_num - gp->lo_num);
  4609.   
  4610. +     if (gp->read_list)
  4611.           for (i = 0; i < articles; i++) {
  4612.               if (*((gp->read_list)+i) == FALSE)
  4613.                   ct++;
  4614. ***************
  4615. *** 980,986 ****
  4616.   
  4617.   
  4618.   
  4619. ! /*------------------- count unread articles in a group --------------------*/
  4620.   void mark_group_as_read(ACTIVE *gp)
  4621.   {
  4622.       /*
  4623. --- 1388,1394 ----
  4624.   
  4625.   
  4626.   
  4627. ! /*------------------- mark articles as read ---------------------------------*/
  4628.   void mark_group_as_read(ACTIVE *gp)
  4629.   {
  4630.       /*
  4631. ***************
  4632. *** 990,996 ****
  4633.   
  4634.       int articles, i, ch;
  4635.   
  4636. !     message("Mark all articles as read (y/n)? ");
  4637.       while (((ch = getch()) != 'y') && (ch != 'n') && (ch != ESCAPE));
  4638.   
  4639.       if (ch == 'y') {
  4640. --- 1398,1404 ----
  4641.   
  4642.       int articles, i, ch;
  4643.   
  4644. !     message("Mark all articles in this group as read (y/n)? ");
  4645.       while (((ch = getch()) != 'y') && (ch != 'n') && (ch != ESCAPE));
  4646.   
  4647.       if (ch == 'y') {
  4648. ***************
  4649. *** 1005,1050 ****
  4650.   }
  4651.   
  4652.   
  4653. ! 
  4654. ! /*-------------------------- status message ---------------------------------*/
  4655. ! void message(char *msg)
  4656.   {
  4657. !     int x;
  4658.   
  4659. !     x = 40 - (strlen(msg)/2);
  4660.   
  4661. !     gotoxy(1,24);
  4662. !     textbackground(LIGHTGRAY);  textcolor(BLACK);
  4663. !     clreol();
  4664. !     gotoxy(x,24);
  4665. !     cprintf("%s", msg);
  4666. !     textbackground(BLACK);  textcolor(LIGHTGRAY);
  4667.   }
  4668.   
  4669.   
  4670.   /*-------------------------- status message ---------------------------------*/
  4671. ! void lmessage(char *msg)
  4672.   {
  4673. !     gotoxy(1,24);
  4674.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  4675.       clreol();
  4676. -     cprintf("%s", msg);
  4677.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  4678.   }
  4679.   
  4680.   
  4681.   /*-------------------------- status message ---------------------------------*/
  4682. ! void command(char *msg)
  4683.   {
  4684. !     int x;
  4685. ! 
  4686. !     x = 40 - (strlen(msg)/2);
  4687. !     gotoxy(1,25);
  4688.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  4689.       clreol();
  4690. - 
  4691. -     gotoxy(x,25);
  4692. -     cprintf(msg);
  4693. - 
  4694.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  4695.   }
  4696. --- 1413,1465 ----
  4697.   }
  4698.   
  4699.   
  4700. ! void mark_thread_as_read(ACTIVE *gp, ARTICLE *a)
  4701.   {
  4702. !     /*
  4703. !      *  Take the thread 'a' for the given group 'gp' and return the number
  4704. !      *  of unread articles
  4705. !      */
  4706.   
  4707. !     ART_ID *id;
  4708. !     int idx, ch;
  4709.   
  4710. !     message("Mark all articles in this thread as read (y/n)? ");
  4711. !     while (((ch = getch()) != 'y') && (ch != 'n') && (ch != ESCAPE));
  4712. ! 
  4713. !     if (ch == 'y') {
  4714. ! 
  4715. !         id = a->art_num;
  4716. ! 
  4717. !         while (id != NULL) {
  4718. !             idx = (int)(id->id - gp->lo_num - 1);
  4719. !             *((gp->read_list)+idx) = TRUE;
  4720. !             id = id->next_art;
  4721. !         }
  4722. !     }
  4723. ! 
  4724.   }
  4725.   
  4726.   
  4727.   /*-------------------------- status message ---------------------------------*/
  4728. ! void message(char *msg)
  4729.   {
  4730. !     int x;
  4731. ! 
  4732. !     x = _columns / 2 - (strlen(msg)/2);
  4733. !     gotoxy(1,PAGE_SIZE);
  4734.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  4735. +     printf("%*s%s", x, "", msg);
  4736.       clreol();
  4737.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  4738.   }
  4739.   
  4740.   
  4741.   /*-------------------------- status message ---------------------------------*/
  4742. ! void lmessage(char *msg)
  4743.   {
  4744. !     gotoxy(1,PAGE_SIZE);
  4745.       textbackground(LIGHTGRAY);  textcolor(BLACK);
  4746. +     printf("%s", msg);
  4747.       clreol();
  4748.       textbackground(BLACK);  textcolor(LIGHTGRAY);
  4749.   }
  4750. Only in new: snews.def
  4751. diff -cb orig/snews.doc new/snews.doc
  4752. *** orig/snews.doc    Fri Nov 08 06:50:18 1991
  4753. --- new/snews.doc    Sun Aug 02 18:28:08 1992
  4754. ***************
  4755. *** 1,4 ****
  4756. --- 1,7 ----
  4757. + NOTE: This documentation is somewhat out of date. Read README.OS2 for
  4758. + changes in the OS/2 (SNEWS /2) releases.
  4759.   
  4760. + -----------
  4761.                               Simple NEWS 1.0
  4762.                               ===============
  4763.   
  4764. diff -cb orig/snews.h new/snews.h
  4765. *** orig/snews.h    Thu Jun 11 22:48:16 1992
  4766. --- new/snews.h    Sun Aug 02 20:34:18 1992
  4767. ***************
  4768. *** 1,5 ****
  4769.   /*
  4770. !     SNEWS 1.0
  4771.   
  4772.       Private decls the SNEWS news reader
  4773.   
  4774. --- 1,5 ----
  4775.   /*
  4776. !     SNEWS 2.0
  4777.   
  4778.       Private decls the SNEWS news reader
  4779.   
  4780. ***************
  4781. *** 22,41 ****
  4782.   
  4783.    */
  4784.   
  4785. - #include <alloc.h>
  4786. - #include <process.h>
  4787. - #include <io.h>
  4788.   
  4789. ! 
  4790. ! /* #define INCLUDE_SIG */   /* enable this to have the reply function put */
  4791.                               /* your sig on the reply - mail ususally does */
  4792.                               /* this                                       */
  4793.   
  4794. ! 
  4795.   
  4796.   #define ENTER               0x0D
  4797.   #define ESCAPE              0x1B
  4798.   #define TAB                 0x09
  4799.   
  4800.   #define EX_DONE             1
  4801.   #define EX_QUIT             2
  4802. --- 22,39 ----
  4803.   
  4804.    */
  4805.   
  4806.   
  4807. ! #define INCLUDE_SIG        /* enable this to have the reply function put */
  4808.                               /* your sig on the reply - mail ususally does */
  4809.                               /* this                                       */
  4810.   
  4811. ! #define MAXLINE             1024
  4812. ! #define MAXART              256
  4813.   
  4814.   #define ENTER               0x0D
  4815.   #define ESCAPE              0x1B
  4816.   #define TAB                 0x09
  4817. + #define BACKSP              0x08
  4818.   
  4819.   #define EX_DONE             1
  4820.   #define EX_QUIT             2
  4821. ***************
  4822. *** 44,56 ****
  4823.   #define EX_NEXT_UNREAD      5
  4824.   #define EX_ROT13            6
  4825.   #define EX_DUMMY            7
  4826.   
  4827. - #define TEXT_LINE           5
  4828.   
  4829.   
  4830. ! #define PAGE_HEADER         4
  4831. ! #define PAGE_LENGTH         19
  4832.   
  4833.   /* if you change these see show_help */
  4834.   #define HELP_GROUP          0
  4835.   #define HELP_THREAD         1
  4836. --- 42,60 ----
  4837.   #define EX_NEXT_UNREAD      5
  4838.   #define EX_ROT13            6
  4839.   #define EX_DUMMY            7
  4840. + #define EX_PREVIOUS         8
  4841. + #define EX_SEARCH_FORW      9
  4842. + #define EX_SEARCH_BACKW     10
  4843.   
  4844.   
  4845. + /* screen size */
  4846. + #define TEXT_LINE           4
  4847. + #define PAGE_HEADER         3
  4848.   
  4849. ! #define PAGE_LENGTH         (_lines - 4)
  4850. ! #define PAGE_SIZE           _lines
  4851.   
  4852. + 
  4853.   /* if you change these see show_help */
  4854.   #define HELP_GROUP          0
  4855.   #define HELP_THREAD         1
  4856. ***************
  4857. *** 58,67 ****
  4858. --- 62,76 ----
  4859.   
  4860.   #define  UP_ARR             'H'
  4861.   #define  DN_ARR             'P'
  4862. + #define  L_ARR              'K'
  4863. + #define  R_ARR              'M'
  4864. + #define  C_L_ARR            's'
  4865. + #define  C_R_ARR            't'
  4866.   #define  PGUP               'I'
  4867.   #define  PGDN               'Q'
  4868.   #define  HOME               'G'
  4869.   #define  END                'O'
  4870. + #define  F1                 ';'
  4871.   
  4872.   
  4873.   
  4874. ***************
  4875. *** 72,79 ****
  4876. --- 81,90 ----
  4877.       long   id;                  /* article number                 */
  4878.       long   art_off;             /* offset of the article          */
  4879.       struct art_id *next_art;    /* pointer to next article number */
  4880. +     struct art_id *last_art;    /* pointer to previous article number */
  4881.   } ART_ID;
  4882.   
  4883. + 
  4884.   /*
  4885.    *  This structure is a doubly linked list of the unique article headers.  The
  4886.    *  linked list of article numbers is built on 'art_num'.  This system
  4887. ***************
  4888. *** 82,139 ****
  4889.    *  But hey, it's simple
  4890.    */
  4891.   typedef struct article {
  4892. !     char   header[60];          /* article header              */
  4893.       int    num_articles;        /* number with this header     */
  4894.       ART_ID *art_num;            /* pointer to list of articles */
  4895.       struct article *next;       /* next topic                  */
  4896.       struct article *last;       /* last topic                  */
  4897.       int    index;               /* topic number from start     */
  4898.   } ARTICLE;
  4899.   
  4900.   
  4901. - 
  4902. - 
  4903. - 
  4904.   /*
  4905. -  *  This structure is a linked list of lines that make up an article. The
  4906. -  *  file is read in and the linked list is built
  4907. -  */
  4908. - typedef struct line {
  4909. -     char   data[80];            /* line of text                */
  4910. -     struct line *next;          /* next line                   */
  4911. -     struct line *last;          /* last line                   */
  4912. -     int    index;               /* line number from start      */
  4913. - } LINE;
  4914. - 
  4915. - 
  4916. - /*
  4917.    *  This structure is the handle for an article in ram.  The file
  4918.    *  is read in and the linked list built.
  4919.    */
  4920. - #define WHO_LENGTH 35
  4921.   typedef struct {
  4922. !     char  author[WHO_LENGTH];           /* truncated author              */
  4923. !     char  organisation[WHO_LENGTH];     /* truncated organisation        */
  4924. !     char  follow_up[80];      /* group for follow-up article             */
  4925. !     int   lines;              /* total lines in file                     */
  4926.       LINE  *top;               /* points to start of article, incl header */
  4927. !     LINE  *start;             /* ponts to start of text                  */
  4928.   } TEXT;
  4929.   
  4930.   
  4931. - 
  4932. - 
  4933. - 
  4934.   ACTIVE *select_group(ACTIVE *head, ACTIVE *current);
  4935.   void show_help(int h);
  4936.   int read_group(ACTIVE *gp);
  4937. ! void show_groups(ACTIVE **top, ACTIVE *this, int force);
  4938.   ARTICLE *get_headers(ACTIVE *gp);
  4939.   void eat_gunk(char *buf);
  4940.   void free_header(ARTICLE *start);
  4941.   
  4942.   
  4943. ! void show_threads(ACTIVE *gp, ARTICLE **top, ARTICLE *this, int force);
  4944.   void select_thread(ACTIVE *gp, ARTICLE *head);
  4945.   int read_thread(ACTIVE *gp, ARTICLE *this, ART_ID *first, int a_ct);
  4946.   
  4947. --- 93,135 ----
  4948.    *  But hey, it's simple
  4949.    */
  4950.   typedef struct article {
  4951. !     char   *header;             /* article header              */
  4952.       int    num_articles;        /* number with this header     */
  4953.       ART_ID *art_num;            /* pointer to list of articles */
  4954.       struct article *next;       /* next topic                  */
  4955.       struct article *last;       /* last topic                  */
  4956.       int    index;               /* topic number from start     */
  4957. +     struct article *left;       /* for tree structure          */
  4958. +     struct article *right;
  4959.   } ARTICLE;
  4960.   
  4961.   
  4962.   /*
  4963.    *  This structure is the handle for an article in ram.  The file
  4964.    *  is read in and the linked list built.
  4965.    */
  4966.   typedef struct {
  4967. !     char  *subject;           /* header              */
  4968. !     char  *author;            /* author              */
  4969. !     char  *organisation;      /* organisation        */
  4970. !     char  *follow_up;         /* group for follow-up article             */
  4971. !     int   lines;              /* total lines in article                  */
  4972. !     int   startline;          /* first text line in article              */
  4973.       LINE  *top;               /* points to start of article, incl header */
  4974. !     LINE  *start;             /* points to start of text                 */
  4975.   } TEXT;
  4976.   
  4977.   
  4978.   ACTIVE *select_group(ACTIVE *head, ACTIVE *current);
  4979.   void show_help(int h);
  4980.   int read_group(ACTIVE *gp);
  4981. ! void show_groups(ACTIVE **top, ACTIVE *this, int force, ACTIVE *head);
  4982.   ARTICLE *get_headers(ACTIVE *gp);
  4983.   void eat_gunk(char *buf);
  4984.   void free_header(ARTICLE *start);
  4985.   
  4986.   
  4987. ! void show_threads(ACTIVE *gp, ARTICLE **top, ARTICLE *this, int force, ARTICLE *head);
  4988.   void select_thread(ACTIVE *gp, ARTICLE *head);
  4989.   int read_thread(ACTIVE *gp, ARTICLE *this, ART_ID *first, int a_ct);
  4990.   
  4991. ***************
  4992. *** 140,145 ****
  4993. --- 136,142 ----
  4994.   int count_unread_in_thread(ACTIVE *gp, ARTICLE *a);
  4995.   int count_unread_in_group(ACTIVE *gp);
  4996.   void mark_group_as_read(ACTIVE *gp);
  4997. + void mark_thread_as_read(ACTIVE *gp, ARTICLE *a);
  4998.   
  4999.   void command(char *msg);
  5000.   void message(char *msg);
  5001. ***************
  5002. *** 149,165 ****
  5003.   void free_article(TEXT *t);
  5004.   
  5005.   
  5006. ! int read_article(ACTIVE *gp, TEXT *tx, char *subject, int a_ct, int of_ct);
  5007. ! void show_article(ACTIVE *gp, TEXT *tx, char *subject, LINE *this, int a_ct,
  5008. !                   int of_ct);
  5009.   
  5010.   
  5011.   void save_to_disk(TEXT *tx);
  5012. ! void reply_to_article(TEXT *tx, char *subject);
  5013.   void get_his_stuff(TEXT *tx, char *author, char *msg_id);
  5014.   
  5015.   
  5016. ! void post(TEXT *tx, char *newsgroups, char *subject);
  5017.   void post_it(FILE *article, char *newsgroups, char *subject, char *dist,
  5018.                     char *msg_id);
  5019.   
  5020. --- 146,162 ----
  5021.   void free_article(TEXT *t);
  5022.   
  5023.   
  5024. ! int read_article(ACTIVE *gp, TEXT *tx, int a_ct, int of_ct);
  5025. ! void show_article(ACTIVE *gp, TEXT *tx, LINE *this, int a_ct,
  5026. !                   int of_ct, int margin);
  5027.   
  5028.   
  5029.   void save_to_disk(TEXT *tx);
  5030. ! void reply_to_article(TEXT *tx);
  5031.   void get_his_stuff(TEXT *tx, char *author, char *msg_id);
  5032.   
  5033.   
  5034. ! void post(TEXT *tx, char *newsgroups);
  5035.   void post_it(FILE *article, char *newsgroups, char *subject, char *dist,
  5036.                     char *msg_id);
  5037.   
  5038. Only in new: termcap.c
  5039. Only in new: termcap.dat
  5040. Only in new: termcap.h
  5041. diff -cb orig/unbatch.c new/unbatch.c
  5042. *** orig/unbatch.c    Thu Jun 11 22:48:16 1992
  5043. --- new/unbatch.c    Sun Aug 02 20:34:18 1992
  5044. ***************
  5045. *** 1,5 ****
  5046.   /*
  5047. !     SNEWS 1.0
  5048.   
  5049.       unbatch - quick and dirty news toss, no feeding of other sites
  5050.   
  5051. --- 1,5 ----
  5052.   /*
  5053. !     SNEWS 2.0
  5054.   
  5055.       unbatch - quick and dirty news toss, no feeding of other sites
  5056.   
  5057. ***************
  5058. *** 35,42 ****
  5059. --- 35,47 ----
  5060.   unsigned _stklen = 16384;
  5061.   
  5062.   INFO my_stuff;
  5063. + char iobuf[IOBUFSIZE];
  5064.   
  5065. + #ifdef system
  5066. + #undef system
  5067. + #endif
  5068.   
  5069. + 
  5070.   /*------------------------------- main --------------------------------*/
  5071.   void main(int argc, char *argv[])
  5072.   {
  5073. ***************
  5074. *** 70,88 ****
  5075.           printf("unbatch: processing %s\n", name);
  5076.   
  5077.           /*
  5078. !          *  Check for enough room.  We need:
  5079. !          *
  5080. !          *     - more than twice the size of the batch for uncompressed
  5081. !          *       batch, say 2.8
  5082. !          *
  5083. !          *     - space for the articles.
  5084. !          *
  5085. !          *       For example a 100k batch may require 280kb for the uncompressed
  5086. !          *       batch, then another 280 kb for the articles.
  5087.            */
  5088.           stat(name, &st);
  5089.   
  5090. !         required_disk = (st.st_size*2.8) * 2;
  5091.   
  5092.           drive = getdisk();
  5093.           getdfree(drive+1, &df);
  5094. --- 75,94 ----
  5095.           printf("unbatch: processing %s\n", name);
  5096.   
  5097.           /*
  5098. !          Check for enough room. First, the batch in copied without
  5099. !          the header. Thus, the same space is needed again. Then,
  5100. !          the copied batch is uncompressed and read in over a pipe
  5101. !          which doesn't need extra space. Only space for the
  5102. !          articles is needed, slightly more than the uncompressed
  5103. !          size of the batch, say 3 times as much. We need a total
  5104. !          space of about four times the size of the original batch.
  5105. !      And this is only if no different device is used for the 
  5106. !      temp files.
  5107.            */
  5108. + 
  5109.           stat(name, &st);
  5110.   
  5111. !         required_disk = st.st_size * 4L;
  5112.   
  5113.           drive = getdisk();
  5114.           getdfree(drive+1, &df);
  5115. ***************
  5116. *** 93,112 ****
  5117.               exit(1);
  5118.           }
  5119.   
  5120.   
  5121. -         /* uncompress the news batch and return a pointer to the temp file */
  5122. -         if ((tmp_file = decode_batches(name, no_toss)) != NULL) {
  5123. - 
  5124.               open_hist_file();
  5125.               toss(tmp_file);
  5126.               close_hist_file();
  5127.               fclose(tmp_file);
  5128.   
  5129.               unlink(name);
  5130. -             sprintf(name, "%s", my_stuff.temp_name);
  5131. -             unlink(name);
  5132.   
  5133. !         } else {
  5134.               printf("could not unpack compressed news batch %s\n", name);
  5135.               exit(1);
  5136.           }
  5137. --- 99,121 ----
  5138.               exit(1);
  5139.           }
  5140.   
  5141. +         /* uncompress the news batch and return a pointer to the pipe */
  5142. +         if ((tmp_file = decode_batch(name, in_name, no_toss)) != NULL) {
  5143.   
  5144.               open_hist_file();
  5145.               toss(tmp_file);
  5146.               close_hist_file();
  5147. + 
  5148. +             if (in_name[0]) {
  5149. +           pclose(tmp_file);
  5150. +               unlink(in_name);
  5151. +         } 
  5152. +         else 
  5153.                 fclose(tmp_file);
  5154.   
  5155.               unlink(name);
  5156.   
  5157. !         } else if (!no_toss) {
  5158.               printf("could not unpack compressed news batch %s\n", name);
  5159.               exit(1);
  5160.           }
  5161. ***************
  5162. *** 119,206 ****
  5163.   }
  5164.   
  5165.   
  5166. - 
  5167. - 
  5168. - 
  5169. - 
  5170. - 
  5171.   /*--------------------------- unpack the batch ------------------------*/
  5172. ! void toss(FILE *tmp_file)
  5173.   {
  5174.       /*
  5175. !      *  Toss it into the appropriate files.
  5176. !      *
  5177. !      *  TODO:
  5178. !      *    - badly structured, sort it out
  5179.        */
  5180. ! 
  5181.       FILE *out_file = NULL;
  5182. !     FILE *spool_file = NULL;
  5183. !     char buf[512], msg[256], subject[256], msg_id[256], *p;
  5184. !     char newsgroups[256], nglist[256];
  5185. !     long where;
  5186.       ACTIVE *gp;
  5187.       time_t t;
  5188. !     int  already_junked, in_header;
  5189. ! 
  5190. !     strcpy(msg_id, "");
  5191. !     strcpy(subject, "-- no subject --\n");
  5192. !     strcpy(newsgroups, "");
  5193.   
  5194. -     rewind(tmp_file);
  5195.       time(&t);
  5196. !     in_header = TRUE;
  5197. ! 
  5198. !     /* read the file */
  5199. !     while (fgets(buf, 511, tmp_file) != NULL) {
  5200. ! 
  5201. !         if (strstr(buf, "#! rnews") != NULL) {
  5202.   
  5203. -             if (strlen(newsgroups) != 0) {
  5204. -                 strcpy(nglist,  newsgroups+11);
  5205.                   p = strtok(newsgroups, " \r\n,:");
  5206.                   p = strtok(NULL, " \r\n,:");
  5207.   
  5208. !                 /*
  5209. !                  *  For each newsgroup
  5210. !                  *    - open the text file
  5211. !                  *    - save the file pointer
  5212. !                  *    - append the message to it
  5213. !                  *    - close the file
  5214. !                  *    - open the index file
  5215. !                  *    - save the file pointer and the subject line
  5216. !                  */
  5217.   
  5218. !                 while (p != '\x00') {
  5219.   
  5220. !                     out_file = open_out_file(p);
  5221.   
  5222.                       where = ftell(out_file);
  5223. !                     rewind(spool_file);
  5224. !                     while (fgets(buf, 511, spool_file) != NULL)
  5225. !                         fputs(buf, out_file);
  5226.                       fprintf(out_file, "\n@@@@END\n");
  5227.                       fclose(out_file);
  5228.   
  5229. !                     out_file = open_index_file(p);
  5230. !                     gp = find_news_group(p);
  5231.                       fprintf(out_file,"%08ld %08ld %09ld %s", where,
  5232.                           gp->hi_num, t, subject);
  5233.                       fclose(out_file);
  5234.   
  5235. !                     p = strtok(NULL, " \r\n,:");
  5236.                   }
  5237. !                 add_hist_record(msg_id, nglist);
  5238. !                 fclose(spool_file);
  5239.               }
  5240.   
  5241.               strcpy(subject, "-- no subject --\n");
  5242.               in_header = TRUE;
  5243.   
  5244. !             if ((spool_file = fopen("$$item", "w+b")) == NULL) {
  5245. !                 fprintf(stderr, "can't open temp article file %s\n", "$$item");
  5246. !                 exit(1);
  5247. !             }
  5248.   
  5249.           } else {
  5250.               /* flag the end of the header */
  5251. --- 128,235 ----
  5252.   }
  5253.   
  5254.   
  5255.   /*--------------------------- unpack the batch ------------------------*/
  5256. ! void save_message(LINE *spool, char *newsgroups, 
  5257. !           char *subject, char *msg_id)
  5258.   {
  5259.       /*
  5260. !      *  For each newsgroup
  5261. !      *    - open the text file
  5262. !      *    - save the file pointer
  5263. !      *    - append the message to it
  5264. !      *    - close the file
  5265. !      *    - open the index file
  5266. !      *    - save the file pointer and the subject line
  5267.        */
  5268. !     char buf[512], nglist[256], *group, *p;
  5269.       FILE *out_file = NULL;
  5270. !     LINE *help;
  5271.       ACTIVE *gp;
  5272. +     long where;
  5273.       time_t t;
  5274. !     int saved = FALSE;
  5275.   
  5276.       time(&t);
  5277. !     nglist[0] = 0;
  5278.   
  5279.       p = strtok(newsgroups, " \r\n,:");
  5280.       p = strtok(NULL, " \r\n,:");
  5281.   
  5282. !     while (p != NULL) {
  5283.   
  5284. !     group = p;
  5285. !     p = strtok(NULL, " \r\n,:");
  5286.   
  5287. !     gp = find_news_group(group);
  5288. !     if (stricmp(gp->group, "junk") == 0 && (p != NULL || saved))
  5289. !       continue;
  5290.   
  5291. +     out_file = open_out_file(group);
  5292.       where = ftell(out_file);
  5293. !     help = spool;
  5294. ! 
  5295. !     setvbuf(out_file, iobuf, _IOFBF, IOBUFSIZE);
  5296. ! 
  5297. !     for (help = spool; help != NULL; help = help->next)
  5298. !         fputs(help->data, out_file);
  5299. ! 
  5300.       fprintf(out_file, "\n@@@@END\n");
  5301.       fclose(out_file);
  5302.     
  5303. !     out_file = open_index_file(group);
  5304.       fprintf(out_file,"%08ld %08ld %09ld %s", where,
  5305.           gp->hi_num, t, subject);
  5306.       fclose(out_file);
  5307.   
  5308. !     saved = TRUE;
  5309. !         if ( nglist[0] )
  5310. !           strcat(nglist, ",");
  5311. !         strcat(nglist, group);
  5312.       }
  5313. ! 
  5314. !     while (spool) {
  5315. !         help = spool;
  5316. !     spool = spool->next;
  5317. !     free(help->data);
  5318. !     free(help);
  5319.       }
  5320.   
  5321. +     add_hist_record(msg_id, nglist);
  5322. + }
  5323. + 
  5324. + void toss(FILE *tmp_file)
  5325. + {
  5326. +     /*
  5327. +      *  Toss it into the appropriate files.
  5328. +      */
  5329. +     LINE *spool = NULL, *help;
  5330. +     char buf[512], buf2[512], *p;
  5331. +     char newsgroups[256], subject[256], msg_id[256];
  5332. +     int  in_header, control;
  5333. + 
  5334. +     strcpy(msg_id, "");
  5335.       strcpy(subject, "-- no subject --\n");
  5336. +     strcpy(newsgroups, "");
  5337. + 
  5338. +     rewind(tmp_file);
  5339.       in_header = TRUE;
  5340. +     control = FALSE;
  5341.   
  5342. !     /* read the file */
  5343. !     while (fgets(buf, 511, tmp_file) != NULL) {
  5344. ! 
  5345. !         if (strstr(buf, "#! rnews") != NULL) {
  5346. ! 
  5347. !             if (control)
  5348. !                 strcpy(newsgroups, "Newsgroups: control"); /* kludge */
  5349. ! 
  5350. !         if (spool != NULL)
  5351. !             save_message(spool, newsgroups, subject, msg_id);
  5352. ! 
  5353. !             strcpy(subject, "-- no subject --\n");
  5354. !             in_header = TRUE;
  5355. !             control = FALSE;
  5356. !         spool = NULL;
  5357.   
  5358.           } else {
  5359.               /* flag the end of the header */
  5360. ***************
  5361. *** 210,262 ****
  5362.               /* save the newsgroups line */
  5363.               if (in_header) {
  5364.                   if (strnicmp(buf,"Message-ID:",11) == 0) {
  5365. !                     strcpy(msg, buf);
  5366. !                     p = strtok(msg, " \t\r\n");  p = strtok(NULL, " \t\r\n");
  5367.                       strcpy(msg_id, p);
  5368.                   }
  5369. !                 if (strnicmp(buf,"Newsgroups:",11) == 0) strcpy(newsgroups,buf);
  5370. !                 if (strnicmp(buf,"Subject:",8) == 0) {
  5371.                       strcpy(subject, buf+8);
  5372. !             }
  5373. !             }
  5374.               /* add our system name to the path list */
  5375.               if (strnicmp(buf, "Path:", 5) == 0) {
  5376.                   p = strtok(buf, " \t");
  5377.                   p = strtok(NULL, " \t");
  5378. !                 fprintf(spool_file, "Path: %s!%s", my_stuff.my_site, p);
  5379. !             } else {
  5380. !                 fprintf(spool_file, "%s", buf);
  5381.               }
  5382.           }
  5383.   
  5384.       }
  5385.   
  5386. !     /* process the last one */
  5387. !     if (strlen(newsgroups) != 0) {
  5388. !         strcpy(nglist, newsgroups+11);
  5389. !         p = strtok(newsgroups, " \r\n,:");
  5390. !         p = strtok(NULL, " \r\n,:");
  5391. !         while (p != '\x00') {
  5392.   
  5393. !             out_file = open_out_file(p);
  5394. !             where = ftell(out_file);
  5395. !             rewind(spool_file);
  5396. !             while (fgets(buf, 511, spool_file) != NULL)
  5397. !                 fputs(buf, out_file);
  5398. !             fprintf(out_file, "\n@@@@END\n");
  5399. !             fclose(out_file);
  5400.   
  5401. !             out_file = open_index_file(p);
  5402. !             gp = find_news_group(p);
  5403. !             fprintf(out_file,"%08ld %08ld %09ld %s", where, gp->hi_num, t, subject);
  5404. !             fclose(out_file);
  5405.   
  5406. !             p = strtok(NULL, " \r\n,:");
  5407. !         }
  5408. !         add_hist_record(msg_id, nglist);
  5409. !         fclose(spool_file);
  5410. !         unlink("$$item");
  5411. !     }
  5412.   }
  5413.   
  5414.   
  5415. --- 239,283 ----
  5416.               /* save the newsgroups line */
  5417.               if (in_header) {
  5418.                   if (strnicmp(buf,"Message-ID:",11) == 0) {
  5419. !                     strcpy(buf2, buf);
  5420. !                     p = strtok(buf2, " \t\r\n");  p = strtok(NULL, " \t\r\n");
  5421.                       strcpy(msg_id, p);
  5422.                   }
  5423. !                 if (strnicmp(buf,"Newsgroups:",11) == 0)
  5424. !                     strcpy(newsgroups,buf);
  5425. !                 if (strnicmp(buf,"Subject:",8) == 0)
  5426.                       strcpy(subject, buf+8);
  5427. !                 if (strnicmp(buf,"Control:",8) == 0)
  5428. !                     control = TRUE;
  5429.                   /* add our system name to the path list */
  5430.                   if (strnicmp(buf, "Path:", 5) == 0) {
  5431.                       p = strtok(buf, " \t");
  5432.                       p = strtok(NULL, " \t");
  5433. !             strcpy(buf2, p);
  5434. !                     sprintf(buf, "Path: %s!%s", my_stuff.my_site, buf2);
  5435.                   }
  5436.               }
  5437.   
  5438. +         if (spool == NULL)
  5439. +         spool = help = (LINE *) xmalloc(sizeof(LINE));
  5440. +         else {
  5441. +             help->next = (LINE *) xmalloc(sizeof(LINE));
  5442. +         help = help->next;
  5443.           }
  5444. +         help->next = NULL;
  5445. +         help->data = (char *) xmalloc(strlen(buf) + 1);
  5446. +         strcpy(help->data, buf);
  5447. +         }
  5448.   
  5449. !     }
  5450.   
  5451. !     /* process the last one */
  5452.   
  5453. !     if (control)
  5454. !         strcpy(newsgroups, "Newsgroups: control"); /* kludge */
  5455.   
  5456. !     if (spool != NULL)
  5457. !     save_message(spool, newsgroups, subject, msg_id);
  5458.   }
  5459.   
  5460.   
  5461. ***************
  5462. *** 264,270 ****
  5463.   
  5464.   
  5465.   /*--------------------------- unpack the batch ------------------------*/
  5466. ! FILE *decode_batches(char *fn, int no_toss)
  5467.   {
  5468.       /*
  5469.        *  take the batch, strip off the !cunbatch, and feed the file to
  5470. --- 285,291 ----
  5471.   
  5472.   
  5473.   /*--------------------------- unpack the batch ------------------------*/
  5474. ! FILE *decode_batch(char *fn, char *tn, int no_toss)
  5475.   {
  5476.       /*
  5477.        *  take the batch, strip off the !cunbatch, and feed the file to
  5478. ***************
  5479. *** 272,300 ****
  5480.        */
  5481.   
  5482.       FILE *in_file, *out_file;
  5483. !     int res, buf_cnt;
  5484. !     char buf[1025];
  5485. !     char name[128];
  5486.   
  5487.       buf_cnt = 0;
  5488.   
  5489.       /* open the batch file */
  5490. !     strcpy(name, fn);
  5491. !     if ((in_file = fopen(name, "rb")) == NULL) {
  5492. !         printf("batchfile %s could not be opened\n", name);
  5493.           return(NULL);
  5494.       }
  5495.   
  5496.       /* open the compressed */
  5497. !     sprintf(name, "%s.z", my_stuff.temp_name);
  5498. !     if ((out_file = fopen(name, "wb")) == NULL) {
  5499. !         printf("cannot open output file %s\n", name);
  5500.           return(NULL);
  5501.       }
  5502.   
  5503.       while ((res = fread(buf, 1, 1024, in_file)) > 0) {
  5504. !         fwrite(buf_cnt == 0 ? buf+12 : buf, 1,
  5505. !                buf_cnt == 0 ? res-12 : res, out_file);
  5506.           buf_cnt++;
  5507.       }
  5508.   
  5509. --- 293,354 ----
  5510.        */
  5511.   
  5512.       FILE *in_file, *out_file;
  5513. !     int res, buf_cnt, header;
  5514. !     char buf[1025], out[256];
  5515. !     char compr[16];
  5516. !     long pos;
  5517. !     short magic;
  5518.   
  5519.       buf_cnt = 0;
  5520. +     header = FALSE;
  5521. +     *tn = 0;
  5522.   
  5523.       /* open the batch file */
  5524. !     if ((in_file = fopen(fn, "rb")) == NULL) {
  5525. !         printf("batchfile %s could not be opened\n", fn);
  5526. !         return(NULL);
  5527. !     }
  5528. ! 
  5529. !     if (fread(buf, 1, 12, in_file) == 0) {
  5530. !         printf("batch %s is inexplicably too small\n", fn);
  5531. !         return(NULL);
  5532. !     }
  5533. ! 
  5534. !     if (memcmp(buf, "#! rnews ", 9) == 0) {
  5535. !         rewind(in_file);
  5536. !     return(in_file);
  5537. !     }
  5538. ! 
  5539. !     if (memcmp(buf, "#! cunbatch\n", 12) == 0)
  5540. !         header = TRUE;
  5541. !     else if (memcmp(buf, "#! funbatch\n", 12) == 0)
  5542. !         header = TRUE;
  5543. !     else
  5544. !         rewind(in_file);
  5545. ! 
  5546. !     pos = ftell(in_file);
  5547. !     fread(&magic, 1, sizeof(short), in_file);
  5548. !     fseek(in_file, pos, SEEK_SET);
  5549. ! 
  5550. !     if (magic == COMPRESS)
  5551. !         strcpy(compr, "compress");
  5552. !     else if (magic == FREEZE)
  5553. !         strcpy(compr, "freeze");
  5554. !     else {
  5555. !         printf("batch %s has unknown compression type\n", fn);
  5556.       return(NULL);
  5557.       }
  5558.   
  5559. +     if (header) {
  5560.       /* open the compressed */
  5561. !     sprintf(tn, "%s\\unbatch.tmp", my_stuff.temp_name);
  5562. !     if ((out_file = fopen(tn, "wb")) == NULL) {
  5563. !         printf("cannot open output file %s\n", buf);
  5564.           return(NULL);
  5565.       }
  5566.   
  5567.       while ((res = fread(buf, 1, 1024, in_file)) > 0) {
  5568. !         fwrite(buf, 1, res, out_file);
  5569.           buf_cnt++;
  5570.       }
  5571.   
  5572. ***************
  5573. *** 301,320 ****
  5574.       fclose(in_file);
  5575.       fclose(out_file);
  5576.   
  5577. !     unlink(my_stuff.temp_name);
  5578. !     sprintf(name, "compress -d %s.z", my_stuff.temp_name);
  5579. !     /* printf("unbatch: decompressing batch (%s)\n", name); */
  5580. !     system(name);
  5581.         
  5582. !     if (no_toss) return(NULL);
  5583.   
  5584.       /* open the uncompressed */
  5585. !     sprintf(name, "%s", my_stuff.temp_name);
  5586. !     if ((out_file = fopen(name, "rb")) == NULL) {
  5587. !         printf("cannot open uncompressed file %s\n", name);
  5588.           return(NULL);
  5589.       }
  5590.   
  5591.       return(out_file);
  5592. - 
  5593.   }
  5594. --- 355,395 ----
  5595.       fclose(in_file);
  5596.       fclose(out_file);
  5597.   
  5598. !     if (no_toss) {
  5599. !         sprintf(out, "%s\\n_XXXXXX", my_stuff.temp_name);
  5600. !         mktemp(out);
  5601. !         sprintf(buf, "%s -d <%s >%s", compr, tn, out);
  5602. !         system(buf);
  5603. !         unlink(tn);
  5604. !         return(NULL);
  5605. !     }
  5606. ! 
  5607. !     /* open the uncompressed */
  5608. !     sprintf(buf, "%s -d <%s", compr, tn);
  5609. !     if ((out_file = popen(buf, "rb")) == NULL) {
  5610. !         printf("cannot open pipe to \"%s\"\n", buf);
  5611. !         return(NULL);
  5612. !     }
  5613. !     }
  5614. !     else {
  5615. !         fclose(in_file);
  5616. !     *tn = 0;
  5617.         
  5618. !     if (no_toss) {
  5619. !         sprintf(out, "%s\\n_XXXXXX", my_stuff.temp_name);
  5620. !         mktemp(out);
  5621. !         sprintf(buf, "%s -d <%s >%s", compr, fn, out);
  5622. !         system(buf);
  5623. !         return(NULL);
  5624. !     }
  5625.   
  5626.       /* open the uncompressed */
  5627. !     sprintf(buf, "%s -d <%s", compr, fn);
  5628. !     if ((out_file = popen(buf, "rb")) == NULL) {
  5629. !         printf("cannot open pipe to \"%s\"\n", buf);
  5630.           return(NULL);
  5631.       }
  5632. +     }
  5633.   
  5634.       return(out_file);
  5635.   }
  5636. diff -cb orig/unbatch.h new/unbatch.h
  5637. *** orig/unbatch.h    Thu Jun 11 22:48:17 1992
  5638. --- new/unbatch.h    Sun Aug 02 20:34:18 1992
  5639. ***************
  5640. *** 1,5 ****
  5641.   /*
  5642. !     SNEWS 1.0
  5643.   
  5644.       Unbatch private decls
  5645.   
  5646. --- 1,5 ----
  5647.   /*
  5648. !     SNEWS 2.0
  5649.   
  5650.       Unbatch private decls
  5651.   
  5652. ***************
  5653. *** 27,31 ****
  5654.   
  5655.   
  5656.   /*----------------------------- prototypes --------------------------------*/
  5657. ! FILE *decode_batches(char *fn, int no_toss);
  5658.   void toss(FILE *tmp_file);
  5659. --- 27,34 ----
  5660.   
  5661.   
  5662.   /*----------------------------- prototypes --------------------------------*/
  5663. ! FILE *decode_batch(char *fn, char *tn, int no_toss);
  5664.   void toss(FILE *tmp_file);
  5665. + 
  5666. + #define COMPRESS     0x9D1F
  5667. + #define FREEZE       0x9F1F
  5668.