expire/makehistory.c

   1 /*  $Id: makehistory.c 7468 2005-12-12 03:23:21Z eagle $
   2 **
   3 **  Rebuild history/overview databases.
   4 */
   5
   6 #include "config.h"
   7 #include "clibrary.h"
   8 #include "portable/wait.h"
   9 #include <assert.h>
  10 #include <errno.h>
  11 #include <pwd.h>
  12 #include <syslog.h>
  13
  14 #include "inn/buffer.h"
  15 #include "inn/history.h"
  16 #include "inn/innconf.h"
  17 #include "inn/messages.h"
  18 #include "inn/qio.h"
  19 #include "inn/wire.h"
  20 #include "libinn.h"
  21 #include "ov.h"
  22 #include "paths.h"
  23 #include "storage.h"
  24
  25 static const char usage[] = "\
  26 Usage: makehistory [-bOIax] [-f file] [-l count] [-s size] [-T tmpdir]\n\
  27 \n\
  28     -b          delete bad articles from spool\n\
  29     -e          read entire articles to compute proper byte count\n\
  30     -f          write history entries to file (default $pathdb/history)\n\
  31     -s size     size new history database for approximately size entries\n\
  32     -a          open output history file in append mode\n\
  33     -O          create overview entries for articles\n\
  34     -I          do not create overview for articles numbered below lowmark\n\
  35     -l count    size of overview updates (default 10000)\n\
  36     -x          don't write history entries\n\
  37     -T tmpdir   use directory tmpdir for temporary files\n\
  38     -F          fork when writing overview\n";
  39
  40
  41 /*
  42 **  Information about the schema of the news overview files.
  43 */
  44 typedef struct _ARTOVERFIELD {
  45     char        *Headername;
  46     int         HeadernameLength;
  47     bool        NeedHeadername;
  48     const char  *Header;
  49     int         HeaderLength;
  50     bool        HasHeader;
  51 } ARTOVERFIELD;
  52
  53 #define DEFAULT_SEGSIZE 10000;
  54
  55 bool NukeBadArts;
  56 char *SchemaPath = NULL;
  57 char *ActivePath = NULL;
  58 char *HistoryPath = NULL;
  59 struct history *History;
  60 FILE *Overchan;
  61 bool DoOverview;
  62 bool Fork;
  63 bool Cutofflow = false;
  64 char *TmpDir;
  65 int OverTmpSegSize, OverTmpSegCount;
  66 FILE *OverTmpFile;
  67 char *OverTmpPath = NULL;
  68 bool NoHistory;
  69 OVSORTTYPE sorttype;
  70 int RetrMode;
  71
  72 TIMEINFO Now;
  73
  74 /* Misc variables needed for the overview creation code. */
  75 static char             MESSAGEID[] = "Message-ID";
  76 static char             EXPIRES[] = "Expires";
  77 static char             DATE[] = "Date";
  78 static char             XREF[] = "Xref";
  79 static ARTOVERFIELD     *ARTfields; /* overview fields listed in overview.fmt */
  80 static size_t           ARTfieldsize;
  81 static ARTOVERFIELD     *Datep = (ARTOVERFIELD *)NULL;
  82 static ARTOVERFIELD     *Msgidp = (ARTOVERFIELD *)NULL;
  83 static ARTOVERFIELD     *Expp = (ARTOVERFIELD *)NULL;
  84 static ARTOVERFIELD     *Xrefp = (ARTOVERFIELD *)NULL;
  85 static ARTOVERFIELD     *Missfields; /* header fields not listed in
  86                                         overview.fmt, but ones that we need
  87                                         (e.g. message-id */
  88 static size_t           Missfieldsize = 0;
  89
  90 static void OverAddAllNewsgroups(void);
  91
  92 /*
  93 **  Check and parse an date header line.  Return the new value or
  94 **  zero on error.
  95 */
  96 static long
  97 GetaDate(char *p)
  98 {
  99     time_t              t;
 100
 101     while (ISWHITE(*p))
 102         p++;
 103     if ((t = parsedate(p, &Now)) == -1)
 104         return 0L;
 105     return (long)t;
 106 }
 107
 108 /*
 109 **  Check and parse a Message-ID header line.  Return private space.
 110 */
 111 static const char *
 112 GetMessageID(char *p)
 113 {
 114     static struct buffer buffer = { 0, 0, 0, NULL };
 115
 116     while (ISWHITE(*p))
 117         p++;
 118     if (p[0] != '<' || p[strlen(p) - 1] != '>')
 119         return "";
 120
 121     /* Copy into re-used memory space, including NUL. */
 122     buffer_set(&buffer, p, strlen(p)+1);
 123     return buffer.data;
 124 }
 125
 126 /*
 127  * The overview temp file is used to accumulate overview lines as articles are
 128  * scanned.  The format is
 129  * (1st) newsgroup name\tToken\toverview data.
 130  * When about 10000 lines of this overview data are accumulated, the data
 131  * file is sorted and then read back in and the data added to overview.
 132  * The sorting/batching helps improve efficiency.
 133  */
 134
 135 /*
 136  * Flush the unwritten OverTempFile data to disk, sort the file, read it
 137  * back in, and add it to overview.
 138  */
 139
 140 static void
 141 FlushOverTmpFile(void)
 142 {
 143     char temp[SMBUF];
 144     char *SortedTmpPath;
 145     int i, pid, fd;
 146     TOKEN token;
 147     QIOSTATE *qp;
 148     int count;
 149     char *line, *p;
 150     char *q = NULL;
 151     char *r = NULL;
 152     time_t arrived, expires;
 153     static int first = 1;
 154
 155     if (OverTmpFile == NULL)
 156         return;
 157     if (fflush(OverTmpFile) == EOF || ferror(OverTmpFile) || fclose(OverTmpFile) == EOF)
 158         sysdie("cannot close temporary overview file");
 159     if(Fork) {
 160         if(!first) { /* if previous one is running, wait for it */
 161             int status;
 162             wait(&status);
 163             if((WIFEXITED(status) && WEXITSTATUS(status) != 0)
 164                     || WIFSIGNALED(status))
 165                 exit(1);
 166         }
 167
 168         pid = fork();
 169         if(pid == -1)
 170             sysdie("cannot fork");
 171         if(pid > 0) {
 172             /* parent */
 173             first = 0;
 174             free(OverTmpPath);
 175             OverTmpPath = NULL;
 176             return;
 177         }
 178
 179         /* child */
 180         /* init the overview setup. */
 181         if (!OVopen(OV_WRITE)) {
 182             warn("cannot open overview");
 183             _exit(1);
 184         }
 185         if (!OVctl(OVSORT, (void *)&sorttype)) {
 186             warn("cannot obtain overview sorting information");
 187             OVclose();
 188             _exit(1);
 189         }
 190         if (!OVctl(OVCUTOFFLOW, (void *)&Cutofflow)) {
 191             warn("cannot obtain overview cutoff information");
 192             OVclose();
 193             _exit(1);
 194         }
 195     }
 196
 197     /* This is a bit odd, but as long as other user's files can't be deleted
 198        out of the temporary directory, it should work.  We're using mkstemp to
 199        create a file and then passing its name to sort, which will then open
 200        it again and overwrite it. */
 201     SortedTmpPath = concatpath(TmpDir, "hisTXXXXXX");
 202     fd = mkstemp(SortedTmpPath);
 203     if (fd < 0) {
 204         syswarn("cannot create temporary file");
 205         OVclose();
 206         Fork ? _exit(1) : exit(1);
 207     }
 208     close(fd);
 209     snprintf(temp, sizeof(temp), "exec %s -T %s -t'%c' -o %s %s", _PATH_SORT,
 210              TmpDir, '\t', SortedTmpPath, OverTmpPath);
 211
 212     i = system(temp) >> 8;
 213     if (i != 0) {
 214         syswarn("cannot sort temporary overview file (%s exited %d)",
 215                 _PATH_SORT, i);
 216         OVclose();
 217         Fork ? _exit(1) : exit(1);
 218     }
 219
 220     /* don't need old path anymore. */
 221     unlink(OverTmpPath);
 222     free(OverTmpPath);
 223     OverTmpPath = NULL;
 224
 225     /* read sorted lines. */
 226     if ((qp = QIOopen(SortedTmpPath)) == NULL) {
 227         syswarn("cannot open sorted overview file %s", SortedTmpPath);
 228         OVclose();
 229         Fork ? _exit(1) : exit(1);
 230     }
 231
 232     for (count = 1; ; ++count) {
 233         line = QIOread(qp);
 234         if (line == NULL) {
 235             if (QIOtoolong(qp)) {
 236                 warn("overview line %d is too long", count);
 237                 continue;
 238             } else
 239                 break;
 240         }
 241         if ((p = strchr(line, '\t')) == NULL
 242             || (q = strchr(p+1, '\t')) == NULL
 243             || (r = strchr(q+1, '\t')) == NULL) {
 244             warn("sorted overview file %s has a bad line at %d",
 245                  SortedTmpPath, count);
 246             continue;
 247         }
 248         /* p+1 now points to start of token, q+1 points to start of overline. */
 249         if (sorttype == OVNEWSGROUP) {
 250             *p++ = '\0';
 251             *q++ = '\0';
 252             *r++ = '\0';
 253             arrived = (time_t)atol(p);
 254             expires = (time_t)atol(q);
 255             q = r;
 256             if ((r = strchr(r, '\t')) == NULL) {
 257                 warn("sorted overview file %s has a bad line at %d",
 258                      SortedTmpPath, count);
 259                 continue;
 260             }
 261             *r++ = '\0';
 262         } else {
 263             *p++ = '\0';
 264             *q++ = '\0';
 265             *r++ = '\0';
 266             arrived = (time_t)atol(line);
 267             expires = (time_t)atol(p);
 268         }
 269         token = TextToToken(q);
 270         if (OVadd(token, r, strlen(r), arrived, expires) == OVADDFAILED) {
 271             if (OVctl(OVSPACE, (void *)&i) && i == OV_NOSPACE) {
 272                 warn("no space left for overview");
 273                 OVclose();
 274                 Fork ? _exit(1) : exit(1);
 275             }
 276             warn("cannot write overview data \"%.40s\"", q);
 277         }
 278     }
 279     /* Check for errors and close. */
 280     if (QIOerror(qp)) {
 281         syswarn("cannot read sorted overview file %s", SortedTmpPath);
 282         OVclose();
 283         Fork ? _exit(1) : exit(1);
 284     }
 285     QIOclose(qp);
 286     /* unlink sorted tmp file */
 287     unlink(SortedTmpPath);
 288     free(SortedTmpPath);
 289     if(Fork) {
 290         OVclose();
 291         _exit(0);
 292     }
 293 }
 294
 295
 296 /*
 297  * Write a line to the overview temp file.
 298  */
 299 static void
 300 WriteOverLine(TOKEN *token, const char *xrefs, int xrefslen,
 301               char *overdata, int overlen, time_t arrived, time_t expires)
 302 {
 303     char temp[SMBUF];
 304     const char *p, *q, *r;
 305     int i, fd;
 306
 307     if (sorttype == OVNOSORT) {
 308         if (Fork) {
 309             fprintf(Overchan, "%s %ld %ld ", TokenToText(*token), (long)arrived, (long)expires);
 310             if (fwrite(overdata, 1, overlen, Overchan) != (size_t) overlen)
 311                 sysdie("writing overview failed");
 312             fputc('\n', Overchan);
 313         } else if (OVadd(*token, overdata, overlen, arrived, expires) == OVADDFAILED) {
 314             if (OVctl(OVSPACE, (void *)&i) && i == OV_NOSPACE) {
 315                 warn("no space left for overview");
 316                 OVclose();
 317                 exit(1);
 318             }
 319             warn("cannot write overview data for article %s",
 320                  TokenToText(*token));
 321         }
 322         return;
 323     }
 324     if (OverTmpPath == NULL) {
 325         /* need new temp file, so create it. */
 326         OverTmpPath = concatpath(TmpDir, "histXXXXXX");
 327         fd = mkstemp(OverTmpPath);
 328         if (fd < 0)
 329             sysdie("cannot create temporary file");
 330         OverTmpFile = fdopen(fd, "w");
 331         if (OverTmpFile == NULL)
 332             sysdie("cannot open %s", OverTmpPath);
 333         OverTmpSegCount = 0;
 334     }
 335     if (sorttype == OVNEWSGROUP) {
 336         /* find first ng name in xref. */
 337         for (p = xrefs, q=NULL ; p < xrefs+xrefslen ; ++p) {
 338             if (*p == ' ') {
 339                 q = p+1; /* found space */
 340                 break;
 341             }
 342         }
 343         if (!q) {
 344             warn("bogus Xref data for %s", TokenToText(*token));
 345             /* XXX do nuke here? */
 346             return;
 347         }
 348
 349         for (p = q, r=NULL ; p < xrefs+xrefslen ; ++p) {
 350             if (*p == ':') {
 351                 r=p;
 352                 break;
 353             }
 354         }
 355         if (!r) {
 356             warn("bogus Xref data for %s", TokenToText(*token));
 357             /* XXX do nuke here? */
 358             return;
 359         }
 360         /* q points to start of ng name, r points to its end. */
 361         assert(sizeof(temp) > r - q + 1);
 362         memcpy(temp, q, r - q + 1);
 363         temp[r - q + 1] = '\0';
 364         fprintf(OverTmpFile, "%s\t%10lu\t%lu\t%s\t", temp,
 365                 (unsigned long) arrived, (unsigned long) expires,
 366                 TokenToText(*token));
 367     } else
 368         fprintf(OverTmpFile, "%10lu\t%lu\t%s\t", (unsigned long) arrived,
 369                 (unsigned long) expires,
 370                 TokenToText(*token));
 371
 372     fwrite(overdata, overlen, 1, OverTmpFile);
 373     fprintf(OverTmpFile, "\n");
 374     OverTmpSegCount++;
 375
 376     if (OverTmpSegSize != 0 && OverTmpSegCount >= OverTmpSegSize) {
 377         FlushOverTmpFile();
 378     }
 379 }
 380
 381
 382 /*
 383 **  Read the overview schema.
 384 */
 385 static void
 386 ARTreadschema(bool Overview)
 387 {
 388     FILE                        *F;
 389     char                        *p;
 390     ARTOVERFIELD                *fp;
 391     int                         i;
 392     char                        buff[SMBUF];
 393     bool                        foundxreffull = false;
 394
 395     if (Overview) {
 396         /* Open file, count lines. */
 397         if ((F = fopen(SchemaPath, "r")) == NULL)
 398             sysdie("cannot open %s", SchemaPath);
 399         for (i = 0; fgets(buff, sizeof buff, F) != NULL; i++)
 400             continue;
 401         fseeko(F, 0, SEEK_SET);
 402         ARTfields = xmalloc((i + 1) * sizeof(ARTOVERFIELD));
 403
 404         /* Parse each field. */
 405         for (fp = ARTfields; fgets(buff, sizeof buff, F) != NULL; ) {
 406             /* Ignore blank and comment lines. */
 407             if ((p = strchr(buff, '\n')) != NULL)
 408                 *p = '\0';
 409             if ((p = strchr(buff, '#')) != NULL)
 410                 *p = '\0';
 411             if (buff[0] == '\0')
 412                 continue;
 413             if ((p = strchr(buff, ':')) != NULL) {
 414                 *p++ = '\0';
 415                 fp->NeedHeadername = (strcmp(p, "full") == 0);
 416             }
 417             else
 418                 fp->NeedHeadername = false;
 419             fp->Headername = xstrdup(buff);
 420             fp->HeadernameLength = strlen(buff);
 421             fp->Header = (char *)NULL;
 422             fp->HasHeader = false;
 423             fp->HeaderLength = 0;
 424             if (strncasecmp(buff, DATE, strlen(DATE)) == 0)
 425                 Datep = fp;
 426             if (strncasecmp(buff, MESSAGEID, strlen(MESSAGEID)) == 0)
 427                 Msgidp = fp;
 428             if (strncasecmp(buff, EXPIRES, strlen(EXPIRES)) == 0)
 429                 Expp = fp;
 430             if (strncasecmp(buff, XREF, strlen(XREF)) == 0) {
 431                 Xrefp = fp;
 432                 foundxreffull = fp->NeedHeadername;
 433             }
 434             fp++;
 435         }
 436         ARTfieldsize = fp - ARTfields;
 437         fclose(F);
 438     }
 439     if (Msgidp == (ARTOVERFIELD *)NULL)
 440         Missfieldsize++;
 441     if (Datep == (ARTOVERFIELD *)NULL)
 442         Missfieldsize++;
 443     if (Expp == (ARTOVERFIELD *)NULL)
 444         Missfieldsize++;
 445     if (Overview && (Xrefp == (ARTOVERFIELD *)NULL || !foundxreffull))
 446         die("Xref:full must be included in %s", SchemaPath);
 447     if (Missfieldsize > 0) {
 448         Missfields = xmalloc(Missfieldsize * sizeof(ARTOVERFIELD));
 449         fp = Missfields;
 450         if (Msgidp == (ARTOVERFIELD *)NULL) {
 451             fp->NeedHeadername = false;
 452             fp->Headername = xstrdup(MESSAGEID);
 453             fp->HeadernameLength = strlen(MESSAGEID);
 454             fp->Header = (char *)NULL;
 455             fp->HasHeader = false;
 456             fp->HeaderLength = 0;
 457             Msgidp = fp++;
 458         }
 459         if (Datep == (ARTOVERFIELD *)NULL) {
 460             fp->NeedHeadername = false;
 461             fp->Headername = xstrdup(DATE);
 462             fp->HeadernameLength = strlen(DATE);
 463             fp->Header = (char *)NULL;
 464             fp->HasHeader = false;
 465             fp->HeaderLength = 0;
 466             Datep = fp++;
 467         }
 468         if (Expp == (ARTOVERFIELD *)NULL) {
 469             fp->NeedHeadername = false;
 470             fp->Headername = xstrdup(EXPIRES);
 471             fp->HeadernameLength = strlen(EXPIRES);
 472             fp->Header = (char *)NULL;
 473             fp->HasHeader = false;
 474             fp->HeaderLength = 0;
 475             Expp = fp++;
 476         }
 477         if (Overview && Xrefp == (ARTOVERFIELD *)NULL) {
 478             fp->NeedHeadername = false;
 479             fp->Headername = xstrdup(XREF);
 480             fp->HeadernameLength = strlen(XREF);
 481             fp->Header = (char *)NULL;
 482             fp->HasHeader = false;
 483             fp->HeaderLength = 0;
 484             Xrefp = fp++;
 485         }
 486     }
 487 }
 488
 489 /*
 490  * Handle a single article.  This routine's fairly complicated.
 491  */
 492 static void
 493 DoArt(ARTHANDLE *art)
 494 {
 495     ARTOVERFIELD                *fp;
 496     const char                  *p, *end;
 497     char                        *q;
 498     static struct buffer        buffer = { 0, 0, 0, NULL };
 499     static char                 SEP[] = "\t";
 500     static char                 NUL[] = "\0";
 501     static char                 COLONSPACE[] = ": ";
 502     size_t                      i, j, len;
 503     const char                  *MessageID;
 504     time_t                      Arrived;
 505     time_t                      Expires;
 506     time_t                      Posted;
 507     char                        overdata[BIG_BUFFER];
 508     char                        bytes[BIG_BUFFER];
 509     struct artngnum             ann;
 510
 511     /* Set up place to store headers. */
 512     for (fp = ARTfields, i = 0; i < ARTfieldsize; i++, fp++) {
 513         if (fp->HeaderLength) {
 514             fp->Header = 0;
 515         }
 516         fp->HeaderLength = 0;
 517         fp->HasHeader = false;
 518     }
 519     if (Missfieldsize > 0) {
 520         for (fp = Missfields, i = 0; i < Missfieldsize; i++, fp++) {
 521             if (fp->HeaderLength) {
 522                 fp->Header = 0;
 523             }
 524             fp->HeaderLength = 0;
 525             fp->HasHeader = false;
 526         }
 527     }
 528     for (fp = ARTfields, i = 0; i < ARTfieldsize; i++, fp++) {
 529         fp->Header = wire_findheader(art->data, art->len, fp->Headername);
 530
 531         /* Someone managed to break their server so that they were appending
 532            multiple Xref headers, and INN had a bug where it wouldn't notice
 533            this and reject the article.  Just in case, see if there are
 534            multiple Xref headers and use the last one. */
 535         if (fp == Xrefp) {
 536             const char *next = fp->Header;
 537             size_t left;
 538
 539             while (next != NULL) {
 540                 next = wire_endheader(fp->Header, art->data + art->len - 1);
 541                 if (next == NULL)
 542                     break;
 543                 next++;
 544                 left = art->len - (next - art->data);
 545                 next = wire_findheader(next, left, fp->Headername);
 546                 if (next != NULL)
 547                     fp->Header = next;
 548             }
 549         }
 550
 551         /* Now, if we have a header, find and record its length. */
 552         if (fp->Header != NULL) {
 553             fp->HasHeader = true;
 554             p = wire_endheader(fp->Header, art->data + art->len - 1);
 555             if (p == NULL)
 556                 continue;
 557
 558             /* The true length of the header is p - fp->Header + 1, but p
 559                points to the \n at the end of the header, so subtract 2 to
 560                peel off the \r\n (we're guaranteed we're dealing with
 561                wire-format articles. */
 562             fp->HeaderLength = p - fp->Header - 1;
 563         } else if (RetrMode == RETR_ALL
 564                    && strcmp(fp->Headername, "Bytes") == 0) {
 565             snprintf(bytes, sizeof(bytes), "%lu", (unsigned long) art->len);
 566             fp->HasHeader = true;
 567             fp->Header = bytes;
 568             fp->HeaderLength = strlen(bytes);
 569         }
 570     }
 571     if (Missfieldsize > 0) {
 572         for (fp = Missfields, i = 0; i < Missfieldsize; i++, fp++) {
 573             fp->Header = wire_findheader(art->data, art->len, fp->Headername);
 574             if (fp->Header != NULL) {
 575                 fp->HasHeader = true;
 576                 p = wire_endheader(fp->Header, art->data + art->len - 1);
 577                 if (p == NULL)
 578                     continue;
 579                 fp->HeaderLength = p - fp->Header - 1;
 580             }
 581         }
 582     }
 583     if (DoOverview && Xrefp->HeaderLength == 0) {
 584         if (!SMprobe(SMARTNGNUM, art->token, (void *)&ann)) {
 585             Xrefp->Header = NULL;
 586             Xrefp->HeaderLength = 0;
 587         } else {
 588             if (ann.artnum == 0 || ann.groupname == NULL)
 589                 return;
 590             len = strlen(innconf->pathhost) + 1 + strlen(ann.groupname) + 1
 591                 + 16 + 1;
 592             if (len > BIG_BUFFER) {
 593                 Xrefp->Header = NULL;
 594                 Xrefp->HeaderLength = 0;
 595             } else {
 596                 snprintf(overdata, sizeof(overdata), "%s %s:%lu",
 597                          innconf->pathhost, ann.groupname, ann.artnum);
 598                 Xrefp->Header = overdata;
 599                 Xrefp->HeaderLength = strlen(overdata);
 600             }
 601             if (ann.groupname != NULL)
 602                 free(ann.groupname);
 603         }
 604     }
 605
 606     MessageID = (char *)NULL;
 607     Arrived = art->arrived;
 608     Expires = 0;
 609     Posted = 0;
 610
 611     if (!Msgidp->HasHeader) {
 612         warn("no Message-ID header in %s", TokenToText(*art->token));
 613         if (NukeBadArts)
 614             SMcancel(*art->token);
 615         return;
 616     }
 617
 618     buffer_set(&buffer, Msgidp->Header, Msgidp->HeaderLength);
 619     buffer_append(&buffer, NUL, 1);
 620     for (i = 0, q = buffer.data; i < buffer.left; q++, i++)
 621         if (*q == '\t' || *q == '\n' || *q == '\r')
 622             *q = ' ';
 623     MessageID = GetMessageID(buffer.data);
 624     if (*MessageID == '\0') {
 625         warn("no Message-ID header in %s", TokenToText(*art->token));
 626         if (NukeBadArts)
 627             SMcancel(*art->token);
 628         return;
 629     }
 630
 631     /*
 632      * check if msgid is in history if in update mode, or if article is
 633      * newer than start time of makehistory.
 634      */
 635
 636     if (!Datep->HasHeader) {
 637         Posted = Arrived;
 638     } else {
 639         buffer_set(&buffer, Datep->Header, Datep->HeaderLength);
 640         buffer_append(&buffer, NUL, 1);
 641         for (i = 0, q = buffer.data; i < buffer.left; q++, i++)
 642             if (*q == '\t' || *q == '\n' || *q == '\r')
 643                 *q = ' ';
 644         if ((Posted = GetaDate(buffer.data)) == 0)
 645             Posted = Arrived;
 646     }
 647
 648     if (Expp->HasHeader) {
 649         buffer_set(&buffer, Expp->Header, Expp->HeaderLength);
 650         buffer_append(&buffer, NUL, 1);
 651         for (i = 0, q = buffer.data; i < buffer.left; q++, i++)
 652             if (*q == '\t' || *q == '\n' || *q == '\r')
 653                 *q = ' ';
 654         Expires = GetaDate(buffer.data);
 655     }
 656
 657     if (DoOverview && Xrefp->HeaderLength > 0) {
 658         for (fp = ARTfields, j = 0; j < ARTfieldsize; j++, fp++) {
 659             if (fp == ARTfields)
 660                 buffer_set(&buffer, "", 0);
 661             else
 662                 buffer_append(&buffer, SEP, strlen(SEP));
 663             if (fp->HeaderLength == 0)
 664                 continue;
 665             if (fp->NeedHeadername) {
 666                 buffer_append(&buffer, fp->Headername, fp->HeadernameLength);
 667                 buffer_append(&buffer, COLONSPACE, strlen(COLONSPACE));
 668             }
 669             i = buffer.left;
 670             buffer_resize(&buffer, buffer.left + fp->HeaderLength);
 671             end = fp->Header + fp->HeaderLength - 1;
 672             for (p = fp->Header, q = &buffer.data[i]; p <= end; p++) {
 673                 if (*p == '\r' && p < end && p[1] == '\n') {
 674                     p++;
 675                     continue;
 676                 }
 677                 if (*p == '\0' || *p == '\t' || *p == '\n' || *p == '\r')
 678                     *q++ = ' ';
 679                 else
 680                     *q++ = *p;
 681                 buffer.left++;
 682             }
 683         }
 684         WriteOverLine(art->token, Xrefp->Header, Xrefp->HeaderLength,
 685                       buffer.data, buffer.left, Arrived, Expires);
 686     }
 687
 688     if (!NoHistory) {
 689         bool r;
 690
 691         r = HISwrite(History, MessageID,
 692                      Arrived, Posted, Expires, art->token);
 693         if (r == false)
 694             sysdie("cannot write history line");
 695     }
 696 }
 697
 698
 699 /*
 700 ** Add all groups to overview group.index. --rmt
 701 */
 702 static void
 703 OverAddAllNewsgroups(void)
 704 {
 705     QIOSTATE *qp;
 706     int count;
 707     char *q,*p;
 708     char *line;
 709     ARTNUM hi, lo;
 710
 711     if ((qp = QIOopen(ActivePath)) == NULL)
 712         sysdie("cannot open %s", ActivePath);
 713     for (count = 1; (line = QIOread(qp)) != NULL; count++) {
 714         if ((p = strchr(line, ' ')) == NULL) {
 715             warn("bad active line %d: %.40s", count, line);
 716             continue;
 717         }
 718         *p++ = '\0';
 719         hi = (ARTNUM)atol(p);
 720         if ((p = strchr(p, ' ')) == NULL) {
 721             warn("bad active line %d: %.40s", count, line);
 722             continue;
 723         }
 724         *p++ = '\0';
 725         lo = (ARTNUM)atol(p);
 726         if ((q = strrchr(p, ' ')) == NULL) {
 727             warn("bad active line %d: %.40s", count, line);
 728             continue;
 729         }
 730         /* q+1 points to NG flag */
 731         if (!OVgroupadd(line, lo, hi, q+1))
 732             die("cannot add %s to overview group index", line);
 733     }
 734     /* Test error conditions; QIOtoolong shouldn't happen. */
 735     if (QIOtoolong(qp))
 736         die("active file line %d is too long", count);
 737     if (QIOerror(qp))
 738         sysdie("cannot read %s around line %d", ActivePath, count);
 739     QIOclose(qp);
 740 }
 741
 742
 743 /*
 744 **  Change to the news user if possible, and if not, die.  Used for operations
 745 **  that may create new database files, so as not to mess up the ownership.
 746 */
 747 static void
 748 setuid_news(void)
 749 {
 750     struct passwd *pwd;
 751
 752     pwd = getpwnam(NEWSUSER);
 753     if (pwd == NULL)
 754         die("can't resolve %s to a UID (account doesn't exist?)", NEWSUSER);
 755     if (getuid() == 0)
 756         setuid(pwd->pw_uid);
 757     if (getuid() != pwd->pw_uid)
 758         die("must be run as %s", NEWSUSER);
 759 }
 760
 761
 762 int
 763 main(int argc, char **argv)
 764 {
 765     ARTHANDLE *art = NULL;
 766     bool AppendMode;
 767     int i;
 768     bool val;
 769     char *HistoryDir;
 770     char *p;
 771     char *buff;
 772     size_t npairs = 0;
 773
 774     /* First thing, set up logging and our identity. */
 775     openlog("makehistory", L_OPENLOG_FLAGS | LOG_PID, LOG_INN_PROG);
 776     message_program_name = "makehistory";
 777
 778     /* Set defaults. */
 779     if (!innconf_read(NULL))
 780         exit(1);
 781     HistoryPath = concatpath(innconf->pathdb, _PATH_HISTORY);
 782     ActivePath = concatpath(innconf->pathdb, _PATH_ACTIVE);
 783     TmpDir = innconf->pathtmp;
 784     SchemaPath = concatpath(innconf->pathetc, _PATH_SCHEMA);
 785
 786     OverTmpSegSize = DEFAULT_SEGSIZE;
 787     OverTmpSegCount = 0;
 788     NukeBadArts = false;
 789     DoOverview = false;
 790     Fork = false;
 791     AppendMode = false;
 792     NoHistory = false;
 793     RetrMode = RETR_HEAD;
 794
 795     while ((i = getopt(argc, argv, "aebf:Il:OT:xFs:")) != EOF) {
 796         switch(i) {
 797         case 'T':
 798             TmpDir = optarg;
 799             break;
 800         case 'x':
 801             NoHistory = true;
 802             break;
 803         case 'a':
 804             AppendMode = true;
 805             break;
 806         case 'b':
 807             NukeBadArts = true;
 808             break;
 809         case 'f':
 810             HistoryPath = optarg;
 811             break;
 812         case 'I':
 813             Cutofflow = true;
 814             break;
 815         case 'l':
 816             OverTmpSegSize = atoi(optarg);
 817             break;
 818         case 'O':
 819             DoOverview = true;
 820             break;
 821         case 'F':
 822             Fork = true;
 823             break;
 824         case 'e':
 825             RetrMode = RETR_ALL;
 826             break;
 827         case 's':
 828             npairs = atoi(optarg);
 829             break;
 830
 831         default:
 832             fprintf(stderr, "%s", usage);
 833             exit(1);
 834             break;
 835         }
 836     }
 837     argc -= optind;
 838     argv += optind;
 839     if (argc) {
 840         fprintf(stderr, "%s", usage);
 841         exit(1);
 842     }
 843
 844     if ((p = strrchr(HistoryPath, '/')) == NULL) {
 845         /* find the default history file directory */
 846         HistoryDir = innconf->pathdb;
 847     } else {
 848         *p = '\0';
 849         HistoryDir = xstrdup(HistoryPath);
 850         *p = '/';
 851     }
 852
 853     if (chdir(HistoryDir) < 0)
 854         sysdie("cannot chdir to %s", HistoryDir);
 855
 856     /* Change users if necessary. */
 857     setuid_news();
 858
 859     /* Read in the overview schema */
 860     ARTreadschema(DoOverview);
 861
 862     if (DoOverview) {
 863         /* init the overview setup. */
 864         if (!OVopen(OV_WRITE))
 865             sysdie("cannot open overview");
 866         if (!OVctl(OVSORT, (void *)&sorttype))
 867             die("cannot obtain overview sort information");
 868         if (!Fork) {
 869             if (!OVctl(OVCUTOFFLOW, (void *)&Cutofflow))
 870                 die("cannot obtain overview cutoff information");
 871             OverAddAllNewsgroups();
 872         } else {
 873             OverAddAllNewsgroups();
 874             if (sorttype == OVNOSORT) {
 875                 buff = concat(innconf->pathbin, "/", "overchan", NULL);
 876                 if ((Overchan = popen(buff, "w")) == NULL)
 877                     sysdie("cannot fork overchan process");
 878                 free(buff);
 879             }
 880             OVclose();
 881         }
 882     }
 883
 884     /* Init the Storage Manager */
 885     val = true;
 886     if (!SMsetup(SM_RDWR, (void *)&val) || !SMsetup(SM_PREOPEN, (void *)&val))
 887         sysdie("cannot set up storage manager");
 888     if (!SMinit())
 889         sysdie("cannot initialize storage manager: %s", SMerrorstr);
 890
 891     /* Initialise the history manager */
 892     if (!NoHistory) {
 893         int flags = HIS_RDWR | HIS_INCORE;
 894
 895         if (!AppendMode)
 896             flags |= HIS_CREAT;
 897         History = HISopen(NULL, innconf->hismethod, flags);
 898         if (History == NULL)
 899             sysdie("cannot create history handle");
 900         HISctl(History, HISCTLS_NPAIRS, &npairs);
 901         if (!HISctl(History, HISCTLS_PATH, HistoryPath))
 902             sysdie("cannot open %s", HistoryPath);
 903     }
 904
 905     /* Get the time.  Only get it once, which is good enough. */
 906     if (GetTimeInfo(&Now) < 0)
 907         sysdie("cannot get the time");
 908
 909     /*
 910      * Scan the entire spool, nuke any bad arts if needed, and process each
 911      * article.
 912      */
 913
 914     while ((art = SMnext(art, RetrMode)) != NULL) {
 915         if (art->len == 0) {
 916             if (NukeBadArts && art->data == NULL && art->token != NULL)
 917                 SMcancel(*art->token);
 918             continue;
 919         }
 920         DoArt(art);
 921     }
 922
 923     if (!NoHistory) {
 924         /* close history file. */
 925         if (!HISclose(History))
 926             sysdie("cannot close history file");
 927     }
 928
 929     if (DoOverview) {
 930         if (sorttype == OVNOSORT && Fork)
 931             if (fflush(Overchan) == EOF || ferror(Overchan) || pclose(Overchan) == EOF)
 932                 sysdie("cannot flush overview data");
 933         if (sorttype != OVNOSORT) {
 934             int status;
 935             FlushOverTmpFile();
 936             if(Fork)
 937                 wait(&status);
 938         }
 939     }
 940     if(!Fork)
 941         OVclose();
 942     exit(0);
 943 }
 944