"Fossies" - the Fresh Open Source Software Archive

Member "tin-2.6.1/src/newsrc.c" (22 Dec 2021, 40501 Bytes) of package /linux/misc/tin-2.6.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "newsrc.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 2.6.0_vs_2.6.1.

    1 /*
    2  *  Project   : tin - a Usenet reader
    3  *  Module    : newsrc.c
    4  *  Author    : I. Lea & R. Skrenta
    5  *  Created   : 1991-04-01
    6  *  Updated   : 2021-08-27
    7  *  Notes     : ArtCount = (ArtMax - ArtMin) + 1  [could have holes]
    8  *
    9  * Copyright (c) 1991-2022 Iain Lea <iain@bricbrac.de>, Rich Skrenta <skrenta@pbm.com>
   10  * All rights reserved.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  *
   16  * 1. Redistributions of source code must retain the above copyright notice,
   17  *    this list of conditions and the following disclaimer.
   18  *
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  *
   23  * 3. Neither the name of the copyright holder nor the names of its
   24  *    contributors may be used to endorse or promote products derived from
   25  *    this software without specific prior written permission.
   26  *
   27  * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   28  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   30  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   39 
   40 
   41 #ifndef TIN_H
   42 #   include "tin.h"
   43 #endif /* !TIN_H */
   44 #ifndef TCURSES_H
   45 #   include "tcurses.h"
   46 #endif /* !TCURSES_H */
   47 #ifndef TNNTP_H
   48 #   include "tnntp.h"
   49 #endif /* !TNNTP_H */
   50 #ifndef NEWSRC_H
   51 #   include "newsrc.h"
   52 #endif /* !NEWSRC_H */
   53 
   54 static mode_t newsrc_mode = 0;
   55 
   56 /*
   57  * Local prototypes
   58  */
   59 static FILE *open_subscription_fp(void);
   60 static char *parse_newsrc_line(char *line, int *sub);
   61 static char *parse_subseq(struct t_group *group, char *seq, t_artnum *low, t_artnum *high, t_artnum *sum);
   62 static char *parse_get_seq(char *seq, t_artnum *low, t_artnum *high);
   63 static int write_newsrc_line(FILE *fp, char *line);
   64 static t_bool create_newsrc(char *newsrc_file);
   65 static void auto_subscribe_groups(char *newsrc_file);
   66 static void get_subscribe_info(struct t_group *grp);
   67 static void parse_bitmap_seq(struct t_group *group, char *seq);
   68 static void print_bitmap_seq(FILE *fp, struct t_group *group);
   69 
   70 
   71 /*
   72  * Read .newsrc into my_group[]. my_group[] ints point to active[] entries.
   73  * If allgroups is set, then my_group[] is completely overwritten,
   74  * otherwise, groups are appended. Any bogus groups will be handled
   75  * accordingly. Bogus groups will _not_ be subscribed to as a design
   76  * principle.
   77  *
   78  * Returns the number of lines read(useful for a check newsrc >= oldnewsrc)
   79  *  < 0 error
   80  *  >=0 number of lines read
   81  */
   82 signed long int
   83 read_newsrc(
   84     char *newsrc_file,
   85     t_bool allgroups)
   86 {
   87     FILE *fp;
   88     char *grp, *seq;
   89     int sub, i;
   90     signed long line_count = 0;
   91     struct stat statbuf;
   92 
   93     if (allgroups)
   94         selmenu.max = skip_newgroups();
   95 
   96     /*
   97      * make a .newsrc if none exist & auto subscribe to set groups
   98      */
   99     if (stat(newsrc_file, &statbuf) == -1) {
  100         if (!create_newsrc(newsrc_file))
  101             return -1L; /* ouch */
  102         auto_subscribe_groups(newsrc_file);
  103     } else
  104         newsrc_mode = statbuf.st_mode;
  105 
  106     if ((fp = fopen(newsrc_file, "r")) != NULL) {
  107         if (!batch_mode || verbose)
  108             wait_message(0, _(txt_reading_newsrc));
  109 
  110         while ((grp = tin_fgets(fp, FALSE)) != NULL) {
  111             strip_line(grp);
  112             if (*grp == '#' || *grp == '\0')    /* skip comments and empty lines */
  113                 continue;
  114 
  115             line_count++;   /* but count all other lines (incl. bogous ones) */
  116             seq = parse_newsrc_line(grp, &sub);
  117 
  118             if (sub == SUBSCRIBED) {
  119                 if ((i = my_group_add(grp, FALSE)) >= 0) {
  120                     if (!active[my_group[i]].bogus) {
  121                         active[my_group[i]].subscribed = SUB_BOOL(sub);
  122                         parse_bitmap_seq(&active[my_group[i]], seq);
  123                     }
  124                 } else
  125                     process_bogus(grp);
  126             }
  127         }
  128         fclose(fp);
  129         /* If you aborted with 'q', then you get what you get. */
  130 
  131         if (!batch_mode || verbose)
  132             my_fputc('\n', stdout);
  133 
  134         if (!cmd_line && !batch_mode)
  135             clear_message();
  136     }
  137     return line_count;
  138 }
  139 
  140 
  141 /*
  142  * Parse a line from the newsrc file and write it back out with updated
  143  * sequence information. Return number of lines written (ie, 0 or 1)
  144  */
  145 static int
  146 write_newsrc_line(
  147     FILE *fp,
  148     char *line)
  149 {
  150     char *seq;
  151     int sub;
  152     struct t_group *group;
  153 
  154     seq = parse_newsrc_line(line, &sub);
  155 
  156     if (line[0] == '\0' || sub == 0)        /* Insurance against blank line */
  157         return 0;
  158 
  159     if (seq == NULL) {      /* line has no ':' or '!' in it */
  160         if (tinrc.strip_bogus == BOGUS_REMOVE)
  161             wait_message(2, _(txt_remove_bogus), line);
  162         return 0;
  163     }
  164 
  165     /*
  166      * Find the group in active. If we cannot, then junk it if bogus groups
  167      * are set to auto removal. Also check for bogus flag just in case
  168      * strip_bogus was changed since tin started
  169      */
  170     group = group_find(line, FALSE);
  171 
  172     if (tinrc.strip_bogus == BOGUS_REMOVE) {
  173         if (group == NULL || group->bogus) { /* group doesn't exist */
  174             wait_message(2, _(txt_remove_bogus), line);
  175             return 0;
  176         }
  177     }
  178 
  179     if ((group && group->newsrc.present) && (group->subscribed || !tinrc.strip_newsrc)) {
  180         fprintf(fp, "%s%c ", group->name, SUB_CHAR(group->subscribed));
  181         print_bitmap_seq(fp, group);
  182         return 1;
  183     } else {
  184         if (sub == SUBSCRIBED || !tinrc.strip_newsrc) {
  185             fprintf(fp, "%s%c %s\n", line, sub, seq);
  186             return 1;
  187         }
  188     }
  189     return 0;
  190 }
  191 
  192 
  193 /*
  194  * Read in the users newsrc file and write a new file with all the changes
  195  * changes from the current session. If this works, replace the original
  196  * newsrc file.
  197  * Returns < 0 on error
  198  *         >=0 number of lines written
  199  */
  200 signed long int
  201 write_newsrc(
  202     void)
  203 {
  204     FILE *fp_ip;
  205     FILE *fp_op;
  206     char *line;
  207     signed long int tot = 0L;
  208     struct stat note_stat_newsrc;
  209     t_bool write_ok = FALSE;
  210     int err;
  211 
  212     if (no_write)
  213         return 0L;
  214 
  215     if ((fp_ip = fopen(newsrc, "r")) == NULL)
  216         return -1L; /* can't open newsrc */
  217 
  218     /* get size of original newsrc */
  219     if (fstat(fileno(fp_ip), &note_stat_newsrc) != 0) {
  220         fclose(fp_ip);
  221         return -1L; /* can't access newsrc */
  222     }
  223 
  224     if (!note_stat_newsrc.st_size) {
  225         fclose(fp_ip);
  226         return 0L; /* newsrc is empty */
  227     }
  228 
  229     if ((fp_op = fopen(newnewsrc, "w")) != NULL) {
  230         if (newsrc_mode)
  231 #ifdef HAVE_FCHMOD
  232             fchmod(fileno(fp_op), newsrc_mode);
  233 #else
  234 #   ifdef HAVE_CHMOD
  235             chmod(newnewsrc, newsrc_mode);
  236 #   endif /* HAVE_CHMOD */
  237 #endif /* HAVE_FCHMOD */
  238 
  239         while ((line = tin_fgets(fp_ip, FALSE)) != NULL)
  240             tot += write_newsrc_line(fp_op, line);
  241 
  242         /*
  243          * Don't rename if either fclose() fails or ferror() is set
  244          */
  245         if ((err = ferror(fp_op)) || fclose(fp_op)) {
  246             error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  247             unlink(newnewsrc);
  248             if (err) {
  249                 clearerr(fp_op);
  250                 fclose(fp_op);
  251             }
  252         } else
  253             write_ok = TRUE;
  254     }
  255 
  256     fclose(fp_ip);
  257 
  258     if (tot < 1) {
  259         error_message(2, _(txt_newsrc_nogroups));
  260         unlink(newnewsrc);
  261         return 0L;      /* So we don't get prompted to try again */
  262     }
  263 
  264     if (write_ok)
  265         rename_file(newnewsrc, newsrc);
  266 
  267     return tot;
  268 }
  269 
  270 
  271 /*
  272  * Create a newsrc from active[] groups. Subscribe to all groups.
  273  */
  274 static t_bool
  275 create_newsrc(
  276     char *newsrc_file)
  277 {
  278     FILE *fp;
  279     int i;
  280 
  281     if ((fp = fopen(newsrc_file, "w")) != NULL) {
  282         wait_message(0, _(txt_creating_newsrc));
  283 
  284         for_each_group(i)
  285             fprintf(fp, "%s!\n", active[i].name);
  286 
  287         if ((i = ferror(fp)) || fclose(fp)) {
  288             error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  289             if (i) {
  290                 clearerr(fp);
  291                 fclose(fp);
  292             }
  293             return FALSE;
  294         }
  295         return TRUE; /* newsrc created */
  296     }
  297     return FALSE;
  298 }
  299 
  300 
  301 /*
  302  * Get a list of default groups to subscribe to
  303  */
  304 static FILE *
  305 open_subscription_fp(
  306     void)
  307 {
  308     if (!read_saved_news) {
  309 #ifdef NNTP_ABLE
  310         if (read_news_via_nntp) {
  311             /* RFC 6048 2.6 */
  312             if (nntp_caps.type == CAPABILITIES && !nntp_caps.list_subscriptions)
  313                 return NULL;
  314             else
  315                 return (nntp_command("LIST SUBSCRIPTIONS", OK_GROUPS, NULL, 0));
  316         } else
  317 #endif /* NNTP_ABLE */
  318             return (fopen(subscriptions_file, "r"));
  319     } else
  320         return NULL;
  321 }
  322 
  323 
  324 /*
  325  * Automatically subscribe user to newsgroups specified in
  326  * NEWSLIBDIR/subscriptions (locally) or same file but from NNTP
  327  * server (LIST SUBSCRIPTIONS) and create .newsrc
  328  */
  329 static void
  330 auto_subscribe_groups(
  331     char *newsrc_file)
  332 {
  333     FILE *fp_newsrc;
  334     FILE *fp_subs;
  335     char *ptr;
  336     int err;
  337 
  338     /*
  339      * If subscription file exists then first unsubscribe to all groups
  340      * and then subscribe to just the auto specified groups.
  341      */
  342     if ((fp_subs = open_subscription_fp()) == NULL)
  343         return;
  344 
  345     if (!batch_mode)
  346         wait_message(0, _(txt_autosubscribing_groups));
  347 
  348     if ((fp_newsrc = fopen(newsrc_file, "w")) == NULL) {
  349         TIN_FCLOSE(fp_subs);
  350         return;
  351     }
  352 
  353     if (newsrc_mode)
  354 #ifdef HAVE_FCHMOD
  355         fchmod(fileno(fp_newsrc), newsrc_mode);
  356 #else
  357 #   ifdef HAVE_CHMOD
  358         chmod(newsrc_file, newsrc_mode);
  359 #   endif /* HAVE_CHMOD */
  360 #endif /* HAVE_FCHMOD */
  361 
  362     /* TODO: test me! */
  363     while ((ptr = tin_fgets(fp_subs, FALSE)) != NULL) {
  364         if (ptr[0] != '#') {
  365             if (group_find(ptr, FALSE) != NULL)
  366                 fprintf(fp_newsrc, "%s:\n", ptr);
  367         }
  368     }
  369 
  370     /* We ignore user 'q'uits here. They will get them next time in any case */
  371 
  372     if ((err = ferror(fp_newsrc)) || fclose(fp_newsrc)) {
  373         error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  374         if (err) {
  375             clearerr(fp_newsrc);
  376             fclose(fp_newsrc);
  377         }
  378     }
  379 
  380     TIN_FCLOSE(fp_subs);
  381 }
  382 
  383 
  384 /*
  385  * make a backup of users .newsrc in case of the bogie man
  386  */
  387 void
  388 backup_newsrc(
  389     void)
  390 {
  391     char dirbuf[PATH_LEN];
  392     char filebuf[PATH_LEN];
  393     struct stat statbuf;
  394 
  395 #ifdef NNTP_ABLE
  396     if (read_news_via_nntp && !read_saved_news && nntp_tcp_port != IPPORT_NNTP)
  397         snprintf(filebuf, sizeof(filebuf), "%s:%u", nntp_server, nntp_tcp_port);
  398     else
  399 #endif /* NNTP_ABLE */
  400     {
  401         STRCPY(filebuf, quote_space_to_dash(nntp_server));
  402     }
  403     joinpath(dirbuf, sizeof(dirbuf), rcdir, filebuf);
  404     joinpath(filebuf, sizeof(filebuf), dirbuf, OLDNEWSRC_FILE);
  405 
  406     if (stat(dirbuf, &statbuf) == -1) {
  407         if (my_mkdir(dirbuf, (mode_t) (S_IRWXU)) == -1)
  408             /* Can't create directory: Fall back on Homedir */
  409             joinpath(filebuf, sizeof(filebuf), homedir, OLDNEWSRC_FILE);
  410     }
  411 
  412     if (!backup_file(newsrc, filebuf))
  413         error_message(2, _(txt_filesystem_full_backup), NEWSRC_FILE);
  414 }
  415 
  416 
  417 /*
  418  * Find the total, max & min articles number for specified group
  419  * Use nntp GROUP command or read local spool
  420  * Return 0, or -error
  421  */
  422 int
  423 group_get_art_info(
  424     char *tin_spooldir,
  425     char *groupname,
  426     int grouptype,
  427     t_artnum *art_count,
  428     t_artnum *art_max,
  429     t_artnum *art_min)
  430 {
  431     DIR *dir;
  432     DIR_BUF *direntry;
  433     t_artnum artnum;
  434 
  435     if (read_news_via_nntp && grouptype == GROUP_TYPE_NEWS) {
  436 #ifdef NNTP_ABLE
  437         char line[NNTP_STRLEN];
  438 
  439         snprintf(line, sizeof(line), "GROUP %s", groupname);
  440 #   ifdef DEBUG
  441         if ((debug & DEBUG_NNTP) && verbose > 1)
  442             debug_print_file("NNTP", "group_get_art_info %s", line);
  443 #   endif /* DEBUG */
  444         put_server(line);
  445 
  446         switch (get_respcode(line, sizeof(line))) {
  447             case OK_GROUP:
  448                 if (sscanf(line, "%"T_ARTNUM_SFMT" %"T_ARTNUM_SFMT" %"T_ARTNUM_SFMT, art_count, art_min, art_max) != 3) {
  449 #   ifdef DEBUG
  450                     if ((debug & DEBUG_NNTP) && verbose > 1)
  451                         debug_print_file("NNTP", "Invalid response to GROUP command, %s", line);
  452 #   endif /* DEBUG */
  453                 }
  454                 break;
  455 
  456             case ERR_NOGROUP:
  457                 *art_count = T_ARTNUM_CONST(0);
  458                 *art_min = T_ARTNUM_CONST(1);
  459                 *art_max = T_ARTNUM_CONST(0);
  460                 return -ERR_NOGROUP;
  461 
  462             case ERR_ACCESS:
  463                 tin_done(NNTP_ERROR_EXIT, "%s", line);
  464                 /* keep lint quiet: */
  465                 /* NOTREACHED */
  466                 break;
  467 
  468             default:
  469 #   ifdef DEBUG
  470                 if ((debug & DEBUG_NNTP) && verbose > 1)
  471                     debug_print_file("NNTP", "NOT_OK %s", line);
  472 #   endif /* DEBUG */
  473                 return -1;
  474         }
  475 #else
  476         my_fprintf(stderr, _("Unreachable?\n")); /* TODO: -> lang.c */
  477         return 0;
  478 #endif /* NNTP_ABLE */
  479     } else {
  480         char group_path[PATH_LEN];
  481         *art_count = T_ARTNUM_CONST(0);
  482         *art_min = T_ARTNUM_CONST(0);
  483         *art_max = T_ARTNUM_CONST(0);
  484 
  485         make_base_group_path(tin_spooldir, groupname, group_path, sizeof(group_path));
  486 
  487         if ((dir = opendir(group_path)) != NULL) {
  488             while ((direntry = readdir(dir)) != NULL) {
  489                 artnum = atoartnum(direntry->d_name); /* should be '\0' terminated... */
  490                 if (artnum >= T_ARTNUM_CONST(1)) {
  491                     if (artnum > *art_max) {
  492                         *art_max = artnum;
  493                         if (*art_min == T_ARTNUM_CONST(0))
  494                             *art_min = artnum;
  495                     } else if (artnum < *art_min)
  496                         *art_min = artnum;
  497                     (*art_count)++;
  498                 }
  499             }
  500             CLOSEDIR(dir);
  501             if (*art_min == T_ARTNUM_CONST(0))
  502                 *art_min = T_ARTNUM_CONST(1);
  503         } else {
  504             *art_min = T_ARTNUM_CONST(1);
  505             return -1;
  506         }
  507     }
  508 
  509     return 0;
  510 }
  511 
  512 
  513 /*
  514  * Get and fixup (if needed) the counters for a newly subscribed group
  515  */
  516 static void
  517 get_subscribe_info(
  518     struct t_group *grp)
  519 {
  520     t_artnum oldmin = grp->xmin;
  521     t_artnum oldmax = grp->xmax;
  522 
  523     group_get_art_info(grp->spooldir, grp->name, grp->type, &grp->count, &grp->xmax, &grp->xmin);
  524 
  525     if (grp->newsrc.num_unread > grp->count) {
  526 #ifdef DEBUG
  527         if (debug & DEBUG_NEWSRC) { /* TODO: is this the right debug-level? */
  528             my_printf(cCRLF "Unread WRONG %s unread=[%"T_ARTNUM_PFMT"] count=[%"T_ARTNUM_PFMT"]", grp->name, grp->newsrc.num_unread, grp->count);
  529             my_flush();
  530         }
  531 #endif /* DEBUG */
  532         grp->newsrc.num_unread = grp->count;
  533     }
  534 
  535     if (grp->xmin != oldmin || grp->xmax != oldmax) {
  536         expand_bitmap(grp, 0);
  537 #ifdef DEBUG
  538         if (debug & DEBUG_NEWSRC) { /* TODO: is this the right debug-level? */
  539             my_printf(cCRLF "Min/Max DIFF %s old=[%"T_ARTNUM_PFMT"-%"T_ARTNUM_PFMT"] new=[%"T_ARTNUM_PFMT"-%"T_ARTNUM_PFMT"]", grp->name, oldmin, oldmax, grp->xmin, grp->xmax);
  540             my_flush();
  541         }
  542 #endif /* DEBUG */
  543     }
  544 }
  545 
  546 
  547 /*
  548  * Subscribe/unsubscribe to a group in .newsrc.
  549  * This involves rewriting the .newsrc with the new info
  550  * If get_info is set we are allowed to issue NNTP commands if needed
  551  */
  552 void
  553 subscribe(
  554     struct t_group *group,
  555     int sub_state,
  556     t_bool get_info)
  557 {
  558     FILE *fp;
  559     FILE *newfp;
  560     char *line;
  561     char *seq;
  562     int sub;
  563     t_bool found = FALSE;
  564 
  565     if (no_write)
  566         return;
  567 
  568     if ((newfp = fopen(newnewsrc, "w")) == NULL)
  569         return;
  570 
  571     if (newsrc_mode)
  572 #ifdef HAVE_FCHMOD
  573         fchmod(fileno(newfp), newsrc_mode);
  574 #else
  575 #   ifdef HAVE_CHMOD
  576         chmod(newnewsrc, newsrc_mode);
  577 #   endif /* HAVE_CHMOD */
  578 #endif /* HAVE_FCHMOD */
  579 
  580     if ((fp = fopen(newsrc, "r")) != NULL) {
  581         while ((line = tin_fgets(fp, FALSE)) != NULL) {
  582             if ((seq = parse_newsrc_line(line, &sub))) {
  583                 if (STRCMPEQ(line, group->name)) {
  584                     fprintf(newfp, "%s%c %s\n", line, sub_state, seq);
  585                     group->subscribed = SUB_BOOL(sub_state);
  586 
  587                     /* If previously subscribed to in .newsrc, load up any existing information */
  588                     if (sub_state == SUBSCRIBED)
  589                         parse_bitmap_seq(group, seq);
  590 
  591                     found = TRUE;
  592                 } else
  593                     fprintf(newfp, "%s%c %s\n", line, sub, seq);
  594             }
  595         }
  596 
  597         fclose(fp);
  598 
  599         if (!found) {
  600             wait_message(0, _(txt_subscribing));
  601             group->subscribed = SUB_BOOL(sub_state);
  602             if (sub_state == SUBSCRIBED) {
  603                 fprintf(newfp, "%s%c ", group->name, sub_state);
  604                 if (get_info) {
  605                     get_subscribe_info(group);
  606                     print_bitmap_seq(newfp, group);
  607                 } else /* we are not allowed to issue NNTP cmds during AUTOSUBSCRIBE loop */
  608                     fprintf(newfp, "1\n");
  609             } else
  610                 fprintf(newfp, "%s%c\n", group->name, sub_state);
  611         }
  612     }
  613 
  614     if ((sub = ferror(newfp)) || fclose(newfp)) {
  615         error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  616         if (sub) {
  617             clearerr(newfp);
  618             fclose(newfp);
  619         }
  620         unlink(newnewsrc);
  621     } else
  622         rename_file(newnewsrc, newsrc);
  623 }
  624 
  625 
  626 void
  627 reset_newsrc(
  628     void)
  629 {
  630     FILE *fp;
  631     FILE *newfp;
  632     char *line;
  633     int sub, i;
  634 
  635     if (!no_write && (newfp = fopen(newnewsrc, "w")) != NULL) {
  636         if (newsrc_mode)
  637 #ifdef HAVE_FCHMOD
  638             fchmod(fileno(newfp), newsrc_mode);
  639 #else
  640 #   ifdef HAVE_CHMOD
  641             chmod(newnewsrc, newsrc_mode);
  642 #   endif /* HAVE_CHMOD */
  643 #endif /* HAVE_FCHMOD */
  644 
  645         if ((fp = fopen(newsrc, "r")) != NULL) {
  646             while ((line = tin_fgets(fp, FALSE)) != NULL) {
  647                 (void) parse_newsrc_line(line, &sub);
  648                 fprintf(newfp, "%s%c\n", line, sub);
  649             }
  650             fclose(fp);
  651         }
  652         if ((sub = ferror(newfp)) || fclose(newfp)) {
  653             error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  654             if (sub) {
  655                 clearerr(newfp);
  656                 fclose(newfp);
  657             }
  658             unlink(newnewsrc);
  659         } else
  660             rename_file(newnewsrc, newsrc);
  661     }
  662 
  663     for (i = 0; i < selmenu.max; i++)
  664         set_default_bitmap(&active[my_group[i]]);
  665 }
  666 
  667 
  668 /*
  669  * Rewrite the newsrc file, without the specified group
  670  */
  671 void
  672 delete_group(
  673     char *group)
  674 {
  675     FILE *fp;
  676     FILE *newfp;
  677     char *line;
  678     char *seq;
  679     int sub;
  680 
  681     if (no_write)
  682         return;
  683 
  684     if ((newfp = fopen(newnewsrc, "w")) != NULL) {
  685         if (newsrc_mode)
  686 #ifdef HAVE_FCHMOD
  687             fchmod(fileno(newfp), newsrc_mode);
  688 #else
  689 #   ifdef HAVE_CHMOD
  690             chmod(newnewsrc, newsrc_mode);
  691 #   endif /* HAVE_CHMOD */
  692 #endif /* HAVE_FCHMOD */
  693 
  694         if ((fp = fopen(newsrc, "r")) != NULL) {
  695             while ((line = tin_fgets(fp, FALSE)) != NULL) {
  696                 if ((seq = parse_newsrc_line(line, &sub))) {
  697                     if (!STRCMPEQ(line, group))
  698                         fprintf(newfp, "%s%c %s\n", line, sub, seq);
  699                 }
  700             }
  701             fclose(fp);
  702         }
  703 
  704         if ((sub = ferror(newfp)) || fclose(newfp)) {
  705             error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
  706             if (sub) {
  707                 clearerr(newfp);
  708                 fclose(newfp);
  709             }
  710             unlink(newnewsrc);
  711         } else
  712             rename_file(newnewsrc, newsrc);
  713     }
  714 }
  715 
  716 
  717 /*
  718  * Mark a group as read
  719  * If art != NULL then we explicitly process each article thus
  720  * catching crossposts as well, otherwise we simply scrub the
  721  * bitmap and adjust the highwater mark.
  722  */
  723 void
  724 grp_mark_read(
  725     struct t_group *group,
  726     struct t_article *art)
  727 {
  728     int i;
  729 
  730 #ifdef DEBUG
  731     if (debug & DEBUG_NEWSRC)
  732         debug_print_comment("c/C command");
  733 #endif /* DEBUG */
  734 
  735     if (art != NULL) {
  736         for_each_art(i)
  737             art_mark(group, &art[i], ART_READ);
  738     } else {
  739         FreeAndNull(group->newsrc.xbitmap);
  740         group->newsrc.xbitlen = 0;
  741         if (group->xmax > group->newsrc.xmax)
  742             group->newsrc.xmax = group->xmax;
  743         group->newsrc.xmin = group->newsrc.xmax + 1;
  744         group->newsrc.num_unread = 0;
  745     }
  746 }
  747 
  748 
  749 void
  750 grp_mark_unread(
  751     struct t_group *group)
  752 {
  753     t_artnum bitlength;
  754     t_bitmap *newbitmap = (t_bitmap *) 0;
  755 
  756 #ifdef DEBUG
  757     if (debug & DEBUG_NEWSRC)
  758         debug_print_comment("Z command");
  759 #endif /* DEBUG */
  760 
  761     group_get_art_info(group->spooldir, group->name, group->type, &group->count, &group->xmax, &group->xmin);
  762 
  763     group->newsrc.num_unread = group->count;
  764     if (group->xmax > group->newsrc.xmax)
  765         group->newsrc.xmax = group->xmax;
  766     if (group->xmin > 0)
  767         group->newsrc.xmin = group->xmin;
  768 
  769     bitlength = MAX(0, group->newsrc.xmax - group->newsrc.xmin + 1);
  770 
  771     if (bitlength > 0)
  772         newbitmap = my_malloc(BITS_TO_BYTES(bitlength));
  773 
  774     FreeIfNeeded(group->newsrc.xbitmap);
  775     group->newsrc.xbitmap = newbitmap;
  776     group->newsrc.xbitlen = bitlength;
  777 
  778     if (bitlength)
  779         NSETRNG1(group->newsrc.xbitmap, T_ARTNUM_CONST(0), bitlength - T_ARTNUM_CONST(1));
  780 
  781 #ifdef DEBUG
  782     if (debug & DEBUG_NEWSRC)
  783         debug_print_bitmap(group, NULL);
  784 #endif /* DEBUG */
  785 }
  786 
  787 
  788 void
  789 thd_mark_read(
  790     struct t_group *group,
  791     long thread)
  792 {
  793     int i;
  794 
  795 #ifdef DEBUG
  796     if (debug & DEBUG_NEWSRC)
  797         debug_print_comment("Mark thread read K command");
  798 #endif /* DEBUG */
  799 
  800     for (i = (int) thread; i >= 0; i = arts[i].thread)
  801         art_mark(group, &arts[i], ART_READ);
  802 }
  803 
  804 
  805 void
  806 thd_mark_unread(
  807     struct t_group *group,
  808     long thread)
  809 {
  810     int i;
  811 
  812 #ifdef DEBUG
  813     if (debug & DEBUG_NEWSRC)
  814         debug_print_comment("Mark thread unread Z command");
  815 #endif /* DEBUG */
  816 
  817     for (i = (int) thread; i >= 0; i = arts[i].thread)
  818         art_mark(group, &arts[i], ART_WILL_RETURN);
  819 }
  820 
  821 
  822 /*
  823  * Parse the newsrc sequence for the specified group
  824  */
  825 static void
  826 parse_bitmap_seq(
  827     struct t_group *group,
  828     char *seq)
  829 {
  830     char *ptr;
  831     t_artnum sum = T_ARTNUM_CONST(0);
  832     t_artnum low = T_ARTNUM_CONST(0);
  833     t_artnum high = T_ARTNUM_CONST(0);
  834     t_artnum min, max;
  835     t_bool gotseq = FALSE;
  836 
  837     /*
  838      * Skip possible non-numeric prefix
  839      */
  840     ptr = seq;
  841     while (ptr && *ptr && (*ptr < '0' || *ptr > '9'))
  842         ptr++;
  843 
  844 #ifdef DEBUG
  845     if (debug & DEBUG_NEWSRC) {
  846         char buf[NEWSRC_LINE];
  847 
  848         snprintf(buf, sizeof(buf), "Parsing [%s%c %.*s]", group->name, SUB_CHAR(group->subscribed), (int) (NEWSRC_LINE - strlen(group->name) - 14), BlankIfNull(ptr));
  849         debug_print_comment(buf);
  850         debug_print_bitmap(group, NULL);
  851     }
  852 #endif /* DEBUG */
  853 
  854     if (ptr) {
  855         gotseq = TRUE;
  856         ptr = parse_get_seq(ptr, &low, &high);
  857 
  858         if (high < group->xmin - 1)
  859             high = group->xmin - 1;
  860 
  861         min = ((low <= 1) ? (high + 1) : 1);
  862 
  863         if (group->xmin > min)
  864             min = group->xmin;
  865 
  866         if (group->xmax > high)
  867             max = group->xmax;
  868         else
  869             max = high;     /* trust newsrc's max */
  870 
  871         FreeAndNull(group->newsrc.xbitmap);
  872         group->newsrc.xmax = max;
  873         group->newsrc.xmin = min;
  874         group->newsrc.xbitlen = (max - min) + 1;
  875         if (group->newsrc.xbitlen > 0) {
  876             group->newsrc.xbitmap = my_malloc(BITS_TO_BYTES(group->newsrc.xbitlen));
  877             NSETRNG1(group->newsrc.xbitmap, T_ARTNUM_CONST(0), group->newsrc.xbitlen - T_ARTNUM_CONST(1));
  878         }
  879 
  880         if (min <= high) {
  881             if (low > min)
  882                 sum = low - min;
  883             else
  884                 low = min;
  885             NSETRNG0(group->newsrc.xbitmap, low - min, high - min);
  886         }
  887 
  888         /*
  889          * Pick up any additional articles/ranges after the first
  890          */
  891         while (*ptr)
  892             ptr = parse_subseq(group, ptr, &low, &high, &sum);
  893     } else {
  894         FreeAndNull(group->newsrc.xbitmap);
  895         group->newsrc.xmax = group->xmax;
  896         if (group->xmin > 0)
  897             group->newsrc.xmin = group->xmin;
  898         else
  899             group->newsrc.xmin = 1;
  900         group->newsrc.xbitlen = (group->newsrc.xmax - group->newsrc.xmin) + 1;
  901         if (group->newsrc.xbitlen > 0) {
  902             group->newsrc.xbitmap = my_malloc(BITS_TO_BYTES(group->newsrc.xbitlen));
  903             NSETRNG1(group->newsrc.xbitmap, T_ARTNUM_CONST(0), group->newsrc.xbitlen - T_ARTNUM_CONST(1));
  904         }
  905 /*
  906 wait_message(2, "BITMAP Grp=[%s] MinMax=[%"T_ARTNUM_PFMT"-%"T_ARTNUM_PFMT"] Len=[%"T_ARTNUM_PFMT"]\n",
  907     group->name, group->xmin, group->xmax, group->newsrc.xbitlen);
  908 */
  909     }
  910 
  911     group->newsrc.present = TRUE;
  912 
  913     if (gotseq) {
  914         if (group->newsrc.xmax > high)
  915             sum += group->newsrc.xmax - high;
  916     } else
  917         sum = (group->count >= 0) ? group->count : ((group->newsrc.xmax - group->newsrc.xmin) + 1);
  918 
  919     group->newsrc.num_unread = sum;
  920 #ifdef DEBUG
  921     if (debug & DEBUG_NEWSRC)
  922         debug_print_bitmap(group, NULL);
  923 #endif /* DEBUG */
  924 }
  925 
  926 
  927 /*
  928  * Parse a subsection of the newsrc sequencer ie., 1-34,23-90,93,97-99
  929  * would parse the sequence if called in a loop in the following way:
  930  *   1st call would parse  1-34 and return 23-90,93,97-99
  931  *   2nd call would parse 23-90 and return 93,97-99
  932  *   3rd call would parse    93 and return 97-99
  933  *   4th call would parse 97-99 and return NULL
  934  */
  935 static char *
  936 parse_subseq(
  937     struct t_group *group,
  938     char *seq,
  939     t_artnum *low,
  940     t_artnum *high,
  941     t_artnum *sum)
  942 {
  943     t_artnum bitmin;
  944     t_artnum bitmax;
  945     t_artnum last_high = *high;
  946 
  947     seq = parse_get_seq(seq, low, high);
  948 
  949     /*
  950      * Bitmap index
  951      */
  952     bitmin = *low - group->newsrc.xmin;
  953 
  954     /*
  955      * check that seq is not out of order
  956      */
  957     if (*low > last_high)
  958         *sum += (*low - last_high) - 1;
  959 
  960     if (*high == *low) {
  961         if (bitmin >= 0) {
  962             if (*high > group->newsrc.xmax) {
  963                 /* We trust .newsrc's max. */
  964                 t_artnum bitlen;
  965                 t_bitmap *newbitmap;
  966 
  967                 group->newsrc.xmax = *high;
  968                 bitlen = group->newsrc.xmax - group->newsrc.xmin + 1;
  969                 newbitmap = my_malloc(BITS_TO_BYTES(bitlen));
  970 
  971                 /* Copy over old bitmap */
  972                 memcpy(newbitmap, group->newsrc.xbitmap, BITS_TO_BYTES(group->newsrc.xbitlen));
  973 
  974                 /* Mark high numbered articles as unread */
  975                 NSETRNG1(newbitmap, group->newsrc.xbitlen, bitlen - 1);
  976 
  977                 free(group->newsrc.xbitmap);
  978                 group->newsrc.xbitmap = newbitmap;
  979                 group->newsrc.xbitlen = bitlen;
  980             }
  981             NSET0(group->newsrc.xbitmap, bitmin);
  982         }
  983     } else if ((*low < *high) && (*high >= group->newsrc.xmin)) {
  984         /*
  985          * Restrict the range to min..max
  986          */
  987         if (bitmin < 0)
  988             bitmin = 0;
  989 
  990         bitmax = *high;
  991 
  992         if (bitmax > group->newsrc.xmax) {
  993             /* We trust .newsrc's max. */
  994             t_artnum bitlen;
  995             t_bitmap *newbitmap;
  996 
  997             group->newsrc.xmax = bitmax;
  998             bitlen = group->newsrc.xmax - group->newsrc.xmin + 1;
  999             newbitmap = my_malloc(BITS_TO_BYTES(bitlen));
 1000 
 1001             /* Copy over old bitmap */
 1002             memcpy(newbitmap, group->newsrc.xbitmap, BITS_TO_BYTES(group->newsrc.xbitlen));
 1003 
 1004             /* Mark high numbered articles as unread */
 1005             NSETRNG1(newbitmap, group->newsrc.xbitlen, bitlen - 1);
 1006 
 1007             free(group->newsrc.xbitmap);
 1008             group->newsrc.xbitmap = newbitmap;
 1009             group->newsrc.xbitlen = bitlen;
 1010         }
 1011 
 1012         bitmax -= group->newsrc.xmin;
 1013 
 1014         /*
 1015          * Fill in the whole range as read
 1016          */
 1017         NSETRNG0(group->newsrc.xbitmap, bitmin, bitmax);
 1018     }
 1019     return seq;
 1020 }
 1021 
 1022 
 1023 static char *
 1024 parse_get_seq(
 1025     char *seq,
 1026     t_artnum *low,
 1027     t_artnum *high)
 1028 {
 1029     *low = strtoartnum(seq, &seq, 10);
 1030 
 1031     if (*seq == '-') {  /* Range of articles */
 1032         seq++;
 1033         *high = strtoartnum(seq, &seq, 10);
 1034     } else  /* Single article */
 1035         *high = *low;
 1036 
 1037     while (*seq && (*seq < '0' || *seq > '9'))
 1038         seq++;
 1039 
 1040     return seq;
 1041 }
 1042 
 1043 
 1044 /*
 1045  * Loop through arts[] array marking state of each article READ/UNREAD
 1046  */
 1047 void
 1048 parse_unread_arts(
 1049     struct t_group *group,
 1050     t_artnum min)
 1051 {
 1052     int i;
 1053     t_artnum unread = T_ARTNUM_CONST(0);
 1054     t_artnum bitmin, bitmax;
 1055     t_bitmap *newbitmap = (t_bitmap *) 0;
 1056 
 1057     bitmin = group->newsrc.xmin;
 1058     bitmax = group->newsrc.xmax;
 1059 
 1060     /*
 1061      * TODO
 1062      * what about group->newsrc.xmax > group->xmax?
 1063      * that should indicate an artnum 'reset' on the server
 1064      * (or using the "wrong" newsrc for that server)
 1065      */
 1066 
 1067     if (group->xmax > group->newsrc.xmax)
 1068         group->newsrc.xmax = group->xmax;
 1069 
 1070     if (group->newsrc.xmax >= bitmin) {
 1071         newbitmap = my_malloc(BITS_TO_BYTES(group->newsrc.xmax - bitmin + 1));
 1072         NSETRNG0(newbitmap, T_ARTNUM_CONST(0), group->newsrc.xmax - bitmin);
 1073     }
 1074 
 1075     /*
 1076      * if getart_limit > 0 preserve read/unread state
 1077      * of all articles below the new minimum
 1078      */
 1079     if (min > 0 && newbitmap) {
 1080         t_artnum j, tmp_bitmax;
 1081 
 1082         tmp_bitmax = (bitmax < min) ? bitmax : min;
 1083         for (j = bitmin; j < tmp_bitmax; j++) {
 1084             if (NTEST(group->newsrc.xbitmap, j - bitmin) != ART_READ)
 1085                 NSET1(newbitmap, j - bitmin);
 1086         }
 1087         while (j < min) {
 1088             NSET1(newbitmap, j - bitmin);
 1089             j++;
 1090         }
 1091     }
 1092 
 1093     for_each_art(i) {
 1094         if (arts[i].artnum < bitmin)
 1095             arts[i].status = ART_READ;
 1096         else if (arts[i].artnum > bitmax)
 1097             arts[i].status = ART_UNREAD;
 1098         else if (NTEST(group->newsrc.xbitmap, arts[i].artnum - bitmin) == ART_READ)
 1099             arts[i].status = ART_READ;
 1100         else
 1101             arts[i].status = ART_UNREAD;
 1102 
 1103         /* TODO: logic correct? */
 1104         if (newbitmap != NULL && arts[i].status == ART_UNREAD && arts[i].artnum >= bitmin) {
 1105 #if 0
 1106         /*
 1107          * check for wrong article numbers in the overview
 1108          *
 1109          * TODO: check disabled as we currently catch the artnum > high_mark
 1110          *       case in read_overview() where we might be able to
 1111          *       fix the broken artnum (via xref:-parsing). currently
 1112          *       we just skip the art there.
 1113          */
 1114             if (arts[i].artnum <= group->xmax)
 1115 #endif /* 0 */
 1116                 NSET1(newbitmap, arts[i].artnum - bitmin);
 1117             unread++;
 1118         }
 1119     }
 1120 
 1121     group->newsrc.xbitlen = group->newsrc.xmax - bitmin + 1;
 1122 
 1123     FreeIfNeeded(group->newsrc.xbitmap);
 1124 
 1125     group->newsrc.xbitmap = newbitmap;
 1126     group->newsrc.num_unread = unread;
 1127 }
 1128 
 1129 
 1130 static void
 1131 print_bitmap_seq(
 1132     FILE *fp,
 1133     struct t_group *group)
 1134 {
 1135     t_artnum artnum;
 1136     t_artnum i;
 1137     t_bool flag = FALSE;
 1138 
 1139 #ifdef DEBUG
 1140     if (debug & DEBUG_NEWSRC) {
 1141         debug_print_comment("print_bitmap_seq()");
 1142         debug_print_bitmap(group, NULL);
 1143     }
 1144 #endif /* DEBUG */
 1145 
 1146     if (group->count == 0 || group->xmin > group->xmax) {
 1147         if (group->newsrc.xmax > 1)
 1148             fprintf(fp, "1-%"T_ARTNUM_PFMT, group->newsrc.xmax);
 1149 
 1150         fprintf(fp, "\n");
 1151         fflush(fp);
 1152 #ifdef DEBUG
 1153         if (debug & DEBUG_NEWSRC)
 1154             debug_print_comment("print_bitmap_seq(): group->count == 0");
 1155 #endif /* DEBUG */
 1156         return;
 1157     }
 1158 
 1159     i = group->newsrc.xmin;
 1160     if (i <= group->newsrc.xmax) {
 1161         forever {
 1162             if (group->newsrc.xbitmap && NTEST(group->newsrc.xbitmap, i - group->newsrc.xmin) == ART_READ) {
 1163                 if (flag) {
 1164                     artnum = i;
 1165                     fprintf(fp, ",%"T_ARTNUM_PFMT, i);
 1166                 } else {
 1167                     artnum = 1;
 1168                     flag = TRUE;
 1169                     fprintf(fp, "1");
 1170                 }
 1171                 while (i < group->newsrc.xmax && NTEST(group->newsrc.xbitmap, (i + 1) - group->newsrc.xmin) == ART_READ)
 1172                     i++;
 1173 
 1174                 if (artnum != i)
 1175                     fprintf(fp, "-%"T_ARTNUM_PFMT, i);
 1176 
 1177             } else if (!flag) {
 1178                 flag = TRUE;
 1179                 if (group->newsrc.xmin > 1) {
 1180                     fprintf(fp, "1");
 1181 
 1182                     if (group->newsrc.xmin > 2)
 1183                         fprintf(fp, "-%"T_ARTNUM_PFMT, group->newsrc.xmin - 1);
 1184 
 1185                 }
 1186             }
 1187             if (group->newsrc.xmax == i)
 1188                 break;
 1189 
 1190             i++;
 1191         }
 1192     }
 1193 
 1194     if (!flag && group->newsrc.xmin > 1) {
 1195         fprintf(fp, "1");
 1196 
 1197         if (group->newsrc.xmin > 2)
 1198             fprintf(fp, "-%"T_ARTNUM_PFMT, group->newsrc.xmin - 1);
 1199 
 1200 #ifdef DEBUG
 1201         if (debug & DEBUG_NEWSRC)
 1202             debug_print_comment("print_bitmap_seq(): !flag && group->newsrc.xmin > 1");
 1203 #endif /* DEBUG */
 1204     }
 1205 
 1206     fprintf(fp, "\n");
 1207     fflush(fp);
 1208 }
 1209 
 1210 
 1211 /*
 1212  * rewrite .newsrc and position group at specified position
 1213  */
 1214 t_bool
 1215 pos_group_in_newsrc(
 1216     struct t_group *group,
 1217     int pos)
 1218 {
 1219     FILE *fp_in = NULL, *fp_out = NULL;
 1220     FILE *fp_sub = NULL, *fp_unsub = NULL;
 1221     char *newsgroup = NULL;
 1222     char *line;
 1223     char filename[PATH_LEN];
 1224     char sub[PATH_LEN];
 1225     char unsub[PATH_LEN];
 1226     int subscribed_pos = 1;
 1227     int err;
 1228     size_t group_len;
 1229     t_bool found = FALSE;
 1230     t_bool newnewsrc_created = FALSE;
 1231     t_bool option_line = FALSE;
 1232     t_bool repositioned = FALSE;
 1233     t_bool ret_code = FALSE;
 1234     t_bool sub_created = FALSE;
 1235     t_bool unsub_created = FALSE;
 1236     t_bool fs_error = FALSE;
 1237 
 1238     if (no_write)
 1239         goto rewrite_group_done;
 1240 
 1241     if ((fp_in = fopen(newsrc, "r")) == NULL)
 1242         goto rewrite_group_done;
 1243 
 1244     if ((fp_out = fopen(newnewsrc, "w")) == NULL)
 1245         goto rewrite_group_done;
 1246 
 1247     newnewsrc_created = TRUE;
 1248 
 1249     if (newsrc_mode)
 1250 #ifdef HAVE_FCHMOD
 1251         fchmod(fileno(fp_out), newsrc_mode);
 1252 #else
 1253 #   ifdef HAVE_CHMOD
 1254         chmod(newnewsrc, newsrc_mode);
 1255 #   endif /* HAVE_CHMOD */
 1256 #endif /* HAVE_FCHMOD */
 1257 
 1258     joinpath(filename, sizeof(filename), TMPDIR, ".subrc");
 1259     snprintf(sub, sizeof(sub), "%s.%ld", filename, (long) process_id);
 1260 
 1261     joinpath(filename, sizeof(filename), TMPDIR, ".unsubrc");
 1262     snprintf(unsub, sizeof(unsub), "%s.%ld", filename, (long) process_id);
 1263 
 1264     if ((fp_sub = fopen(sub, "w")) == NULL)
 1265         goto rewrite_group_done;
 1266 
 1267     sub_created = TRUE;
 1268 
 1269     if ((fp_unsub = fopen(unsub, "w")) == NULL)
 1270         goto rewrite_group_done;
 1271 
 1272     unsub_created = TRUE;
 1273 
 1274     /*
 1275      * split newsrc into subscribed and unsubscribed to files
 1276      */
 1277     group_len = strlen(group->name);
 1278 
 1279     while ((line = tin_fgets(fp_in, FALSE)) != NULL) {
 1280         if (STRNCMPEQ(group->name, line, group_len) && line[group_len] == SUBSCRIBED) {
 1281             FreeIfNeeded(newsgroup);
 1282             newsgroup = my_strdup(line);        /* Take a copy of this line */
 1283             found = TRUE;
 1284             continue;
 1285         } else if (strchr(line, SUBSCRIBED) != NULL) {
 1286             write_newsrc_line(fp_sub, line);
 1287         } else if (strchr(line, UNSUBSCRIBED) != NULL) {
 1288             write_newsrc_line(fp_unsub, line);
 1289         } else {                                /* options line at beginning of .newsrc */
 1290             fprintf(fp_sub, "%s\n", line);
 1291             option_line = TRUE;
 1292         }
 1293     }
 1294 
 1295     if ((err = ferror(fp_sub)) || fclose(fp_sub)) {
 1296         error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
 1297         if (err) {
 1298             clearerr(fp_sub);
 1299             fclose(fp_sub);
 1300         }
 1301         fs_error = TRUE;
 1302     }
 1303     if ((err = ferror(fp_unsub)) || fclose(fp_unsub)) {
 1304         if (!fs_error) /* avoid repeatd error message */
 1305             error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
 1306         if (err) {
 1307             clearerr(fp_unsub);
 1308             fclose(fp_unsub);
 1309         }
 1310         fs_error = TRUE;
 1311     }
 1312     fp_sub = fp_unsub = NULL;
 1313 
 1314     if (fs_error)
 1315         goto rewrite_group_done;
 1316 
 1317     fclose(fp_in);
 1318     fp_in = NULL;
 1319 
 1320     /*
 1321      * The group to be moved cannot be found, so give up now
 1322      */
 1323     if (!found)
 1324         goto rewrite_group_done;
 1325 
 1326     /*
 1327      * write subscribed groups & repositioned group to newnewsrc
 1328      */
 1329     if ((fp_sub = fopen(sub, "r")) == NULL)
 1330         goto rewrite_group_done;
 1331 
 1332     while ((line = tin_fgets(fp_sub, FALSE)) != NULL) {
 1333         if (option_line) {
 1334             if (strchr(line, SUBSCRIBED) == NULL && strchr(line, UNSUBSCRIBED) == NULL) {
 1335                 fprintf(fp_out, "%s\n", line);
 1336                 continue;
 1337             } else
 1338                 option_line = FALSE;
 1339         }
 1340 
 1341         if (pos == subscribed_pos) {
 1342             write_newsrc_line(fp_out, newsgroup);
 1343             repositioned = TRUE;
 1344         }
 1345 
 1346         fprintf(fp_out, "%s\n", line);
 1347 
 1348         subscribed_pos++;
 1349     }
 1350 
 1351     if (!repositioned)
 1352         write_newsrc_line(fp_out, newsgroup);
 1353 
 1354     /*
 1355      * append unsubscribed groups file to newnewsrc
 1356      */
 1357     if ((fp_unsub = fopen(unsub, "r")) == NULL)
 1358         goto rewrite_group_done;
 1359 
 1360     while ((line = tin_fgets(fp_unsub, FALSE)) != NULL)
 1361         fprintf(fp_out, "%s\n", line);
 1362 
 1363     /*
 1364      * Try and cleanly close out the newnewsrc file
 1365      */
 1366     if ((err = ferror(fp_out)) || fclose(fp_out)) {
 1367         error_message(2, _(txt_filesystem_full), NEWSRC_FILE);
 1368         if (err) {
 1369             clearerr(fp_out);
 1370             fclose(fp_out);
 1371         }
 1372     } else {
 1373         rename_file(newnewsrc, newsrc);
 1374         ret_code = TRUE;
 1375     }
 1376     fp_out = NULL;
 1377     newnewsrc_created = FALSE;
 1378 
 1379 rewrite_group_done:
 1380     if (fp_in != NULL)
 1381         fclose(fp_in);
 1382 
 1383     if (fp_out != NULL)
 1384         fclose(fp_out);
 1385 
 1386     if (fp_sub != NULL)
 1387         fclose(fp_sub);
 1388 
 1389     if (fp_unsub != NULL)
 1390         fclose(fp_unsub);
 1391 
 1392     if (newnewsrc_created)
 1393         unlink(newnewsrc);
 1394 
 1395     if (sub_created)
 1396         unlink(sub);
 1397 
 1398     if (unsub_created)
 1399         unlink(unsub);
 1400 
 1401     FreeIfNeeded(newsgroup);
 1402 
 1403     return ret_code;
 1404 }
 1405 
 1406 
 1407 /*
 1408  * catchup all groups in .newsrc
 1409  */
 1410 void
 1411 catchup_newsrc_file(
 1412     void)
 1413 {
 1414     int i;
 1415     struct t_group *group;
 1416 
 1417     for (i = 0; i < selmenu.max; i++) {
 1418         group = &active[my_group[i]];
 1419         group->newsrc.present = TRUE;
 1420         FreeAndNull(group->newsrc.xbitmap);
 1421         if (group->xmax > group->newsrc.xmax)
 1422             group->newsrc.xmax = group->xmax;
 1423         group->newsrc.xmin = group->newsrc.xmax + 1;
 1424         group->newsrc.num_unread = 0;
 1425         group->newsrc.xbitlen = 0;
 1426     }
 1427 }
 1428 
 1429 
 1430 /*
 1431  * Break down a line of .newsrc file
 1432  * The sequence information [ eg; 1-3,10,12 ] is returned, line is truncated to
 1433  * just the group name and the subscription flag is copied to sub.
 1434  */
 1435 static char *
 1436 parse_newsrc_line(
 1437     char *line,
 1438     int *sub)
 1439 {
 1440     char *ptr, *tmp;
 1441 
 1442     *sub = UNSUBSCRIBED;                /* Default to no entry */
 1443 
 1444     if ((ptr = strpbrk(line, "!:")) == NULL)            /* space|SUBSCRIBED|UNSUBSCRIBED */
 1445         return NULL;
 1446 
 1447     *sub = *ptr;                        /* Save the subscription status */
 1448     tmp = ptr;                          /* Keep this blank for later */
 1449     *(ptr++) = '\0';                    /* Terminate the group name */
 1450 
 1451 #if 0
 1452     if (ptr == NULL)                    /* No seq info, so return a blank */
 1453         return tmp;
 1454 #endif /* 0 */
 1455 
 1456     if ((ptr = strpbrk(ptr, " \t")) == NULL)
 1457         return tmp;
 1458 
 1459     return (ptr + 1);   /* Return pointer to sequence info. At worst this will be \0 */
 1460 }
 1461 
 1462 
 1463 /*
 1464  * expand group->newsrc information if group->xmax is larger than
 1465  * group->newsrc.xmax or min is smaller than group->newsrc.xmin.
 1466  */
 1467 void
 1468 expand_bitmap(
 1469     struct t_group *group,
 1470     t_artnum min)
 1471 {
 1472     t_artnum bitlen;
 1473     t_artnum first;
 1474     t_artnum tmp;
 1475     t_artnum max;
 1476     t_bool need_full_copy = FALSE;
 1477 
 1478     /* calculate new max */
 1479     if (group->newsrc.xmax > group->xmax)
 1480         max = group->newsrc.xmax;
 1481     else
 1482         max = group->xmax;
 1483 
 1484     /* adjust min */
 1485     if (!min)
 1486         min = group->newsrc.xmin;
 1487 
 1488     /* calculate first */
 1489     if (min >= group->newsrc.xmin)
 1490         first = group->newsrc.xmin;
 1491     else
 1492         first = group->newsrc.xmin - ((group->newsrc.xmin - min + (NBITS - 1)) & ~(NBITS - 1));
 1493 
 1494     /* adjust first */
 1495     if (group->newsrc.xmax < first - 1)
 1496         first = first - ((first - (group->newsrc.xmax + 1) + (NBITS - 1)) & ~(NBITS - 1));
 1497 
 1498     /* check first */
 1499     if (first < 1) {
 1500         need_full_copy = TRUE;
 1501         first = 1;
 1502     }
 1503 
 1504     bitlen = max - first + 1;
 1505 
 1506     if (bitlen <= 0) {
 1507         bitlen = 0;
 1508         FreeIfNeeded(group->newsrc.xbitmap);
 1509         group->newsrc.xbitmap = (t_bitmap *) 0;
 1510 #ifdef DEBUG
 1511         if (debug & DEBUG_NEWSRC)
 1512             debug_print_comment("expand_bitmap: group->newsrc.bitlen == 0");
 1513 #endif /* DEBUG */
 1514     } else if (group->newsrc.xbitmap == NULL) {
 1515         group->newsrc.xbitmap = my_malloc(BITS_TO_BYTES(bitlen));
 1516         if (group->newsrc.xmin > first)
 1517             NSETRNG0(group->newsrc.xbitmap, T_ARTNUM_CONST(0), group->newsrc.xmin - first - T_ARTNUM_CONST(1));
 1518         if (bitlen > group->newsrc.xmin - first)
 1519             NSETRNG1(group->newsrc.xbitmap, group->newsrc.xmin - first, bitlen - 1);
 1520 #ifdef DEBUG
 1521         if (debug & DEBUG_NEWSRC)
 1522             debug_print_comment("expand_bitmap: group->newsrc.xbitmap == NULL");
 1523 #endif /* DEBUG */
 1524     } else if (need_full_copy) {
 1525         t_bitmap *newbitmap = my_malloc(BITS_TO_BYTES(bitlen));
 1526 
 1527         /* Copy over old bitmap */
 1528         /* TODO: change to use shift */
 1529         for (tmp = group->newsrc.xmin; tmp <= group->newsrc.xmax; tmp++) {
 1530             if (NTEST(group->newsrc.xbitmap, tmp - group->newsrc.xmin) == ART_READ)
 1531                 NSET0(newbitmap, tmp - first);
 1532             else
 1533                 NSET1(newbitmap, tmp - first);
 1534         }
 1535 
 1536         /* Mark earlier articles as read, updating num_unread */
 1537 
 1538         if (first < group->newsrc.xmin) {
 1539             NSETRNG0(newbitmap, T_ARTNUM_CONST(0), group->newsrc.xmin - first - T_ARTNUM_CONST(1));
 1540         }
 1541 
 1542         for (tmp = group->newsrc.xmin; tmp < min; tmp++) {
 1543             if (NTEST(newbitmap, tmp - first) != ART_READ) {
 1544                 NSET0(newbitmap, tmp - first);
 1545                 if (group->newsrc.num_unread)
 1546                     group->newsrc.num_unread--;
 1547             }
 1548         }
 1549 
 1550         /* Mark high numbered articles as unread */
 1551 
 1552         if (group->newsrc.xmin - first + group->newsrc.xbitlen < bitlen) {
 1553             tmp = group->newsrc.xmin - first + group->newsrc.xbitlen;
 1554             NSETRNG1(newbitmap, tmp, bitlen - 1);
 1555         }
 1556 
 1557         free(group->newsrc.xbitmap);
 1558         group->newsrc.xbitmap = newbitmap;
 1559 #ifdef DEBUG
 1560         if (debug & DEBUG_NEWSRC)
 1561             debug_print_comment("expand_bitmap: group->newsrc.bitlen != (group->max-group->min)+1 and need full copy");
 1562 #endif /* DEBUG */
 1563     } else if (max != group->newsrc.xmax || first != group->newsrc.xmin) {
 1564         t_bitmap *newbitmap;
 1565         newbitmap = my_malloc(BITS_TO_BYTES(bitlen));
 1566 
 1567         /* Copy over old bitmap */
 1568 
 1569         assert((group->newsrc.xmin - first) / NBITS + BITS_TO_BYTES(group->newsrc.xbitlen) <= BITS_TO_BYTES(bitlen));
 1570 
 1571         memcpy(newbitmap + (group->newsrc.xmin - first) / NBITS, group->newsrc.xbitmap, BITS_TO_BYTES(group->newsrc.xbitlen));
 1572 
 1573         /* Mark earlier articles as read, updating num_unread */
 1574 
 1575         if (first < group->newsrc.xmin) {
 1576             NSETRNG0(newbitmap, T_ARTNUM_CONST(0), group->newsrc.xmin - first - T_ARTNUM_CONST(1));
 1577         }
 1578 
 1579         for (tmp = group->newsrc.xmin; tmp < min; tmp++) {
 1580             if (NTEST(newbitmap, tmp - first) != ART_READ) {
 1581                 NSET0(newbitmap, tmp - first);
 1582                 if (group->newsrc.num_unread)
 1583                     group->newsrc.num_unread--;
 1584             }
 1585         }
 1586 
 1587         /* Mark high numbered articles as unread */
 1588 
 1589         if (group->newsrc.xmin - first + group->newsrc.xbitlen < bitlen) {
 1590             tmp = group->newsrc.xmin - first + group->newsrc.xbitlen;
 1591             NSETRNG1(newbitmap, tmp, bitlen - 1);
 1592         }
 1593 
 1594         free(group->newsrc.xbitmap);
 1595         group->newsrc.xbitmap = newbitmap;
 1596 #ifdef DEBUG
 1597         if (debug & DEBUG_NEWSRC)
 1598             debug_print_comment("expand_bitmap: group->newsrc.bitlen != (group->max-group->min)+1");
 1599 #endif /* DEBUG */
 1600     }
 1601     group->newsrc.xmin = first;
 1602     if (group->newsrc.xmax < max)
 1603         group->newsrc.num_unread += max - group->newsrc.xmax;
 1604     group->newsrc.xmax = max;
 1605     group->newsrc.xbitlen = bitlen;
 1606     group->newsrc.present = TRUE;
 1607 }
 1608 
 1609 
 1610 void
 1611 art_mark(
 1612     struct t_group *group,
 1613     struct t_article *art,
 1614     int flag)
 1615 {
 1616     if (art == NULL)
 1617         return;
 1618 
 1619     switch (flag) {
 1620         case ART_READ:
 1621             if (group != NULL) {
 1622                 if (art->artnum >= group->newsrc.xmin && art->artnum <= group->newsrc.xmax)
 1623                     NSET0(group->newsrc.xbitmap, art->artnum - group->newsrc.xmin);
 1624 #ifdef DEBUG
 1625                 if (debug & DEBUG_NEWSRC)
 1626                     debug_print_bitmap(group, art);
 1627 #endif /* DEBUG */
 1628             }
 1629             if ((art->status == ART_UNREAD) || (art->status == ART_WILL_RETURN)) {
 1630                 art_mark_xref_read(art);
 1631 
 1632                 if (group != NULL) {
 1633                     if (group->newsrc.num_unread)
 1634                         group->newsrc.num_unread--;
 1635 
 1636                     if (group->attribute->show_only_unread_arts)
 1637                         art->keep_in_base = TRUE;
 1638                 }
 1639 
 1640                 art->status = ART_READ;
 1641             }
 1642             break;
 1643 
 1644         case ART_UNREAD:
 1645         case ART_WILL_RETURN:
 1646             if (art->status == ART_READ) {
 1647                 if (group != NULL) {
 1648                     group->newsrc.num_unread++;
 1649 
 1650                     if (group->attribute->show_only_unread_arts)
 1651                         art->keep_in_base = FALSE;
 1652                 }
 1653 
 1654                 art->status = flag;
 1655             }
 1656             if (group != NULL) {
 1657                 if (art->artnum < group->newsrc.xmin)
 1658                     expand_bitmap(group, art->artnum);
 1659                 else {
 1660                     NSET1(group->newsrc.xbitmap, art->artnum - group->newsrc.xmin);
 1661 #ifdef DEBUG
 1662                     if (debug & DEBUG_NEWSRC)
 1663                         debug_print_bitmap(group, art);
 1664 #endif /* DEBUG */
 1665                 }
 1666             }
 1667             break;
 1668 
 1669         default:
 1670             break;
 1671     }
 1672 }
 1673 
 1674 
 1675 void
 1676 set_default_bitmap(
 1677     struct t_group *group)
 1678 {
 1679     if (group != NULL) {
 1680         group->newsrc.num_unread = 0;
 1681         group->newsrc.present = FALSE;
 1682 
 1683         FreeIfNeeded(group->newsrc.xbitmap);
 1684 
 1685         group->newsrc.xbitmap = (t_bitmap *) 0;
 1686         group->newsrc.xbitlen = 0;
 1687         if (group->xmin > 0)
 1688             group->newsrc.xmin = group->xmin;
 1689         else
 1690             group->newsrc.xmin = 1;
 1691         group->newsrc.xmax = group->newsrc.xmin - 1;
 1692     }
 1693 }