contrib/cvs-1.12/src/entries.c

   1 /*
   2  * Copyright (C) 1986-2005 The Free Software Foundation, Inc.
   3  *
   4  * Portions Copyright (C) 1998-2005 Derek Price, Ximbiot <http://ximbiot.com>,
   5  *                                  and others.
   6  *
   7  * Portions Copyright (C) 1992, Brian Berliner and Jeff Polk
   8  * Portions Copyright (C) 1989-1992, Brian Berliner
   9  *
  10  * You may distribute under the terms of the GNU General Public License as
  11  * specified in the README file that comes with the CVS source distribution.
  12  *
  13  * Entries file to Files file
  14  *
  15  * Creates the file Files containing the names that comprise the project, from
  16  * the Entries file.
  17  */
  18
  19 #include "cvs.h"
  20 #include "getline.h"
  21
  22 static Node *AddEntryNode (List * list, Entnode *entnode);
  23
  24 static Entnode *fgetentent (FILE *, char *, int *);
  25 static int   fputentent (FILE *, Entnode *);
  26
  27 static Entnode *subdir_record (int, const char *, const char *);
  28
  29 static FILE *entfile;
  30 static char *entfilename;               /* for error messages */
  31
  32
  33
  34 /*
  35  * Construct an Entnode
  36  */
  37 static Entnode *
  38 Entnode_Create (enum ent_type type, const char *user, const char *vn,
  39                 const char *ts, const char *options, const char *tag,
  40                 const char *date, const char *ts_conflict)
  41 {
  42     Entnode *ent;
  43
  44     /* Note that timestamp and options must be non-NULL */
  45     ent = xmalloc (sizeof (Entnode));
  46     ent->type      = type;
  47     ent->user      = xstrdup (user);
  48     ent->version   = xstrdup (vn);
  49     ent->timestamp = xstrdup (ts ? ts : "");
  50     ent->options   = xstrdup (options ? options : "");
  51     ent->tag       = xstrdup (tag);
  52     ent->date      = xstrdup (date);
  53     ent->conflict  = xstrdup (ts_conflict);
  54
  55     return ent;
  56 }
  57
  58 /*
  59  * Destruct an Entnode
  60  */
  61 static void Entnode_Destroy (Entnode *);
  62
  63 static void
  64 Entnode_Destroy (Entnode *ent)
  65 {
  66     free (ent->user);
  67     free (ent->version);
  68     free (ent->timestamp);
  69     free (ent->options);
  70     if (ent->tag)
  71         free (ent->tag);
  72     if (ent->date)
  73         free (ent->date);
  74     if (ent->conflict)
  75         free (ent->conflict);
  76     free (ent);
  77 }
  78
  79 /*
  80  * Write out the line associated with a node of an entries file
  81  */
  82 static int write_ent_proc (Node *, void *);
  83 static int
  84 write_ent_proc (Node *node, void *closure)
  85 {
  86     Entnode *entnode = node->data;
  87
  88     if (closure != NULL && entnode->type != ENT_FILE)
  89         *(int *) closure = 1;
  90
  91     if (fputentent (entfile, entnode))
  92         error (1, errno, "cannot write %s", entfilename);
  93
  94     return 0;
  95 }
  96
  97 /*
  98  * write out the current entries file given a list,  making a backup copy
  99  * first of course
 100  */
 101 static void
 102 write_entries (List *list)
 103 {
 104     int sawdir;
 105
 106     sawdir = 0;
 107
 108     /* open the new one and walk the list writing entries */
 109     entfilename = CVSADM_ENTBAK;
 110     entfile = CVS_FOPEN (entfilename, "w+");
 111     if (entfile == NULL)
 112     {
 113         /* Make this a warning, not an error.  For example, one user might
 114            have checked out a working directory which, for whatever reason,
 115            contains an Entries.Log file.  A second user, without write access
 116            to that working directory, might want to do a "cvs log".  The
 117            problem rewriting Entries shouldn't affect the ability of "cvs log"
 118            to work, although the warning is probably a good idea so that
 119            whether Entries gets rewritten is not an inexplicable process.  */
 120         /* FIXME: should be including update_dir in message.  */
 121         error (0, errno, "cannot rewrite %s", entfilename);
 122
 123         /* Now just return.  We leave the Entries.Log file around.  As far
 124            as I know, there is never any data lying around in 'list' that
 125            is not in Entries.Log at this time (if there is an error writing
 126            Entries.Log that is a separate problem).  */
 127         return;
 128     }
 129
 130     (void) walklist (list, write_ent_proc, (void *) &sawdir);
 131     if (! sawdir)
 132     {
 133         struct stickydirtag *sdtp;
 134
 135         /* We didn't write out any directories.  Check the list
 136            private data to see whether subdirectory information is
 137            known.  If it is, we need to write out an empty D line.  */
 138         sdtp = list->list->data;
 139         if (sdtp == NULL || sdtp->subdirs)
 140             if (fprintf (entfile, "D\n") < 0)
 141                 error (1, errno, "cannot write %s", entfilename);
 142     }
 143     if (fclose (entfile) == EOF)
 144         error (1, errno, "error closing %s", entfilename);
 145
 146     /* now, atomically (on systems that support it) rename it */
 147     rename_file (entfilename, CVSADM_ENT);
 148
 149     /* now, remove the log file */
 150     if (unlink_file (CVSADM_ENTLOG) < 0
 151         && !existence_error (errno))
 152         error (0, errno, "cannot remove %s", CVSADM_ENTLOG);
 153 }
 154
 155
 156
 157 /*
 158  * Removes the argument file from the Entries file if necessary.
 159  */
 160 void
 161 Scratch_Entry (List *list, const char *fname)
 162 {
 163     Node *node;
 164
 165     TRACE (TRACE_FUNCTION, "Scratch_Entry(%s)", fname);
 166
 167     /* hashlookup to see if it is there */
 168     if ((node = findnode_fn (list, fname)) != NULL)
 169     {
 170         if (!noexec)
 171         {
 172             entfilename = CVSADM_ENTLOG;
 173             entfile = xfopen (entfilename, "a");
 174
 175             if (fprintf (entfile, "R ") < 0)
 176                 error (1, errno, "cannot write %s", entfilename);
 177
 178             write_ent_proc (node, NULL);
 179
 180             if (fclose (entfile) == EOF)
 181                 error (1, errno, "error closing %s", entfilename);
 182         }
 183
 184         delnode (node);                 /* delete the node */
 185
 186 #ifdef SERVER_SUPPORT
 187         if (server_active)
 188             server_scratch (fname);
 189 #endif
 190     }
 191 }
 192
 193
 194
 195 /*
 196  * Enters the given file name/version/time-stamp into the Entries file,
 197  * removing the old entry first, if necessary.
 198  */
 199 void
 200 Register (List *list, const char *fname, const char *vn, const char *ts,
 201           const char *options, const char *tag, const char *date,
 202           const char *ts_conflict)
 203 {
 204     Entnode *entnode;
 205     Node *node;
 206
 207 #ifdef SERVER_SUPPORT
 208     if (server_active)
 209     {
 210         server_register (fname, vn, ts, options, tag, date, ts_conflict);
 211     }
 212 #endif
 213
 214     TRACE (TRACE_FUNCTION, "Register(%s, %s, %s%s%s, %s, %s %s)",
 215            fname, vn, ts ? ts : "",
 216            ts_conflict ? "+" : "", ts_conflict ? ts_conflict : "",
 217            options, tag ? tag : "", date ? date : "");
 218
 219     entnode = Entnode_Create (ENT_FILE, fname, vn, ts, options, tag, date,
 220                               ts_conflict);
 221     node = AddEntryNode (list, entnode);
 222
 223     if (!noexec)
 224     {
 225         entfilename = CVSADM_ENTLOG;
 226         entfile = CVS_FOPEN (entfilename, "a");
 227
 228         if (entfile == NULL)
 229         {
 230             /* Warning, not error, as in write_entries.  */
 231             /* FIXME-update-dir: should be including update_dir in message.  */
 232             error (0, errno, "cannot open %s", entfilename);
 233             return;
 234         }
 235
 236         if (fprintf (entfile, "A ") < 0)
 237             error (1, errno, "cannot write %s", entfilename);
 238
 239         write_ent_proc (node, NULL);
 240
 241         if (fclose (entfile) == EOF)
 242             error (1, errno, "error closing %s", entfilename);
 243     }
 244 }
 245
 246 /*
 247  * Node delete procedure for list-private sticky dir tag/date info
 248  */
 249 static void
 250 freesdt (Node *p)
 251 {
 252     struct stickydirtag *sdtp = p->data;
 253
 254     if (sdtp->tag)
 255         free (sdtp->tag);
 256     if (sdtp->date)
 257         free (sdtp->date);
 258     free ((char *) sdtp);
 259 }
 260
 261 /* Return the next real Entries line.  On end of file, returns NULL.
 262    On error, prints an error message and returns NULL.  */
 263
 264 static Entnode *
 265 fgetentent (FILE *fpin, char *cmd, int *sawdir)
 266 {
 267     Entnode *ent;
 268     char *line;
 269     size_t line_chars_allocated;
 270     register char *cp;
 271     enum ent_type type;
 272     char *l, *user, *vn, *ts, *options;
 273     char *tag_or_date, *tag, *date, *ts_conflict;
 274     int line_length;
 275
 276     line = NULL;
 277     line_chars_allocated = 0;
 278
 279     ent = NULL;
 280     while ((line_length = getline (&line, &line_chars_allocated, fpin)) > 0)
 281     {
 282         l = line;
 283
 284         /* If CMD is not NULL, we are reading an Entries.Log file.
 285            Each line in the Entries.Log file starts with a single
 286            character command followed by a space.  For backward
 287            compatibility, the absence of a space indicates an add
 288            command.  */
 289         if (cmd != NULL)
 290         {
 291             if (l[1] != ' ')
 292                 *cmd = 'A';
 293             else
 294             {
 295                 *cmd = l[0];
 296                 l += 2;
 297             }
 298         }
 299
 300         type = ENT_FILE;
 301
 302         if (l[0] == 'D')
 303         {
 304             type = ENT_SUBDIR;
 305             *sawdir = 1;
 306             ++l;
 307             /* An empty D line is permitted; it is a signal that this
 308                Entries file lists all known subdirectories.  */
 309         }
 310
 311         if (l[0] != '/')
 312             continue;
 313
 314         user = l + 1;
 315         if ((cp = strchr (user, '/')) == NULL)
 316             continue;
 317         *cp++ = '\0';
 318         vn = cp;
 319         if ((cp = strchr (vn, '/')) == NULL)
 320             continue;
 321         *cp++ = '\0';
 322         ts = cp;
 323         if ((cp = strchr (ts, '/')) == NULL)
 324             continue;
 325         *cp++ = '\0';
 326         options = cp;
 327         if ((cp = strchr (options, '/')) == NULL)
 328             continue;
 329         *cp++ = '\0';
 330         tag_or_date = cp;
 331         if ((cp = strchr (tag_or_date, '\n')) == NULL)
 332             continue;
 333         *cp = '\0';
 334         tag = NULL;
 335         date = NULL;
 336         if (*tag_or_date == 'T')
 337             tag = tag_or_date + 1;
 338         else if (*tag_or_date == 'D')
 339             date = tag_or_date + 1;
 340
 341         if ((ts_conflict = strchr (ts, '+')))
 342             *ts_conflict++ = '\0';
 343
 344         /*
 345          * XXX - Convert timestamp from old format to new format.
 346          *
 347          * If the timestamp doesn't match the file's current
 348          * mtime, we'd have to generate a string that doesn't
 349          * match anyways, so cheat and base it on the existing
 350          * string; it doesn't have to match the same mod time.
 351          *
 352          * For an unmodified file, write the correct timestamp.
 353          */
 354         {
 355             struct stat sb;
 356             if (strlen (ts) > 30 && stat (user, &sb) == 0)
 357             {
 358                 char *c = ctime (&sb.st_mtime);
 359                 /* Fix non-standard format.  */
 360                 if (c[8] == '0') c[8] = ' ';
 361
 362                 if (!strncmp (ts + 25, c, 24))
 363                     ts = time_stamp (user);
 364                 else
 365                 {
 366                     ts += 24;
 367                     ts[0] = '*';
 368                 }
 369             }
 370         }
 371
 372         ent = Entnode_Create (type, user, vn, ts, options, tag, date,
 373                               ts_conflict);
 374         break;
 375     }
 376
 377     if (line_length < 0 && !feof (fpin))
 378         error (0, errno, "cannot read entries file");
 379
 380     free (line);
 381     return ent;
 382 }
 383
 384 static int
 385 fputentent (FILE *fp, Entnode *p)
 386 {
 387     switch (p->type)
 388     {
 389     case ENT_FILE:
 390         break;
 391     case ENT_SUBDIR:
 392         if (fprintf (fp, "D") < 0)
 393             return 1;
 394         break;
 395     }
 396
 397     if (fprintf (fp, "/%s/%s/%s", p->user, p->version, p->timestamp) < 0)
 398         return 1;
 399     if (p->conflict)
 400     {
 401         if (fprintf (fp, "+%s", p->conflict) < 0)
 402             return 1;
 403     }
 404     if (fprintf (fp, "/%s/", p->options) < 0)
 405         return 1;
 406
 407     if (p->tag)
 408     {
 409         if (fprintf (fp, "T%s\n", p->tag) < 0)
 410             return 1;
 411     }
 412     else if (p->date)
 413     {
 414         if (fprintf (fp, "D%s\n", p->date) < 0)
 415             return 1;
 416     }
 417     else
 418     {
 419         if (fprintf (fp, "\n") < 0)
 420             return 1;
 421     }
 422
 423     return 0;
 424 }
 425
 426
 427 /* Read the entries file into a list, hashing on the file name.
 428
 429    UPDATE_DIR is the name of the current directory, for use in error
 430    messages, or NULL if not known (that is, noone has gotten around
 431    to updating the caller to pass in the information).  */
 432 List *
 433 Entries_Open (int aflag, char *update_dir)
 434 {
 435     List *entries;
 436     struct stickydirtag *sdtp = NULL;
 437     Entnode *ent;
 438     char *dirtag, *dirdate;
 439     int dirnonbranch;
 440     int do_rewrite = 0;
 441     FILE *fpin;
 442     int sawdir;
 443
 444     /* get a fresh list... */
 445     entries = getlist ();
 446
 447     /*
 448      * Parse the CVS/Tag file, to get any default tag/date settings. Use
 449      * list-private storage to tuck them away for Version_TS().
 450      */
 451     ParseTag (&dirtag, &dirdate, &dirnonbranch);
 452     if (aflag || dirtag || dirdate)
 453     {
 454         sdtp = xmalloc (sizeof (*sdtp));
 455         memset (sdtp, 0, sizeof (*sdtp));
 456         sdtp->aflag = aflag;
 457         sdtp->tag = xstrdup (dirtag);
 458         sdtp->date = xstrdup (dirdate);
 459         sdtp->nonbranch = dirnonbranch;
 460
 461         /* feed it into the list-private area */
 462         entries->list->data = sdtp;
 463         entries->list->delproc = freesdt;
 464     }
 465
 466     sawdir = 0;
 467
 468     fpin = CVS_FOPEN (CVSADM_ENT, "r");
 469     if (fpin == NULL)
 470     {
 471         if (update_dir != NULL)
 472             error (0, 0, "in directory %s:", update_dir);
 473         error (0, errno, "cannot open %s for reading", CVSADM_ENT);
 474     }
 475     else
 476     {
 477         while ((ent = fgetentent (fpin, NULL, &sawdir)) != NULL)
 478         {
 479             (void) AddEntryNode (entries, ent);
 480         }
 481
 482         if (fclose (fpin) < 0)
 483             /* FIXME-update-dir: should include update_dir in message.  */
 484             error (0, errno, "cannot close %s", CVSADM_ENT);
 485     }
 486
 487     fpin = CVS_FOPEN (CVSADM_ENTLOG, "r");
 488     if (fpin != NULL)
 489     {
 490         char cmd;
 491         Node *node;
 492
 493         while ((ent = fgetentent (fpin, &cmd, &sawdir)) != NULL)
 494         {
 495             switch (cmd)
 496             {
 497             case 'A':
 498                 (void) AddEntryNode (entries, ent);
 499                 break;
 500             case 'R':
 501                 node = findnode_fn (entries, ent->user);
 502                 if (node != NULL)
 503                     delnode (node);
 504                 Entnode_Destroy (ent);
 505                 break;
 506             default:
 507                 /* Ignore unrecognized commands.  */
 508                 Entnode_Destroy (ent);
 509                 break;
 510             }
 511         }
 512         do_rewrite = 1;
 513         if (fclose (fpin) < 0)
 514             /* FIXME-update-dir: should include update_dir in message.  */
 515             error (0, errno, "cannot close %s", CVSADM_ENTLOG);
 516     }
 517
 518     /* Update the list private data to indicate whether subdirectory
 519        information is known.  Nonexistent list private data is taken
 520        to mean that it is known.  */
 521     if (sdtp != NULL)
 522         sdtp->subdirs = sawdir;
 523     else if (! sawdir)
 524     {
 525         sdtp = xmalloc (sizeof (*sdtp));
 526         memset (sdtp, 0, sizeof (*sdtp));
 527         sdtp->subdirs = 0;
 528         entries->list->data = sdtp;
 529         entries->list->delproc = freesdt;
 530     }
 531
 532     if (do_rewrite && !noexec)
 533         write_entries (entries);
 534
 535     /* clean up and return */
 536     if (dirtag)
 537         free (dirtag);
 538     if (dirdate)
 539         free (dirdate);
 540     return entries;
 541 }
 542
 543 void
 544 Entries_Close (List *list)
 545 {
 546     if (list)
 547     {
 548         if (!noexec)
 549         {
 550             if (isfile (CVSADM_ENTLOG))
 551                 write_entries (list);
 552         }
 553         dellist (&list);
 554     }
 555 }
 556
 557
 558 /*
 559  * Free up the memory associated with the data section of an ENTRIES type
 560  * node
 561  */
 562 static void
 563 Entries_delproc (Node *node)
 564 {
 565     Entnode *p = node->data;
 566
 567     Entnode_Destroy (p);
 568 }
 569
 570 /*
 571  * Get an Entries file list node, initialize it, and add it to the specified
 572  * list
 573  */
 574 static Node *
 575 AddEntryNode (List *list, Entnode *entdata)
 576 {
 577     Node *p;
 578
 579     /* was it already there? */
 580     if ((p  = findnode_fn (list, entdata->user)) != NULL)
 581     {
 582         /* take it out */
 583         delnode (p);
 584     }
 585
 586     /* get a node and fill in the regular stuff */
 587     p = getnode ();
 588     p->type = ENTRIES;
 589     p->delproc = Entries_delproc;
 590
 591     /* this one gets a key of the name for hashing */
 592     /* FIXME This results in duplicated data --- the hash package shouldn't
 593        assume that the key is dynamically allocated.  The user's free proc
 594        should be responsible for freeing the key. */
 595     p->key = xstrdup (entdata->user);
 596     p->data = entdata;
 597
 598     /* put the node into the list */
 599     addnode (list, p);
 600     return p;
 601 }
 602
 603
 604
 605 /*
 606  * Write out the CVS/Template file.
 607  */
 608 void
 609 WriteTemplate (const char *update_dir, int xdotemplate, const char *repository)
 610 {
 611 #ifdef SERVER_SUPPORT
 612     TRACE (TRACE_FUNCTION, "Write_Template (%s, %s)", update_dir, repository);
 613
 614     if (noexec)
 615         return;
 616
 617     if (server_active && xdotemplate)
 618     {
 619         /* Clear the CVS/Template if supported to allow for the case
 620          * where the rcsinfo file no longer has an entry for this
 621          * directory.
 622          */
 623         server_clear_template (update_dir, repository);
 624         server_template (update_dir, repository);
 625     }
 626 #endif
 627
 628     return;
 629 }
 630
 631
 632
 633 /*
 634  * Write out/Clear the CVS/Tag file.
 635  */
 636 void
 637 WriteTag (const char *dir, const char *tag, const char *date, int nonbranch,
 638           const char *update_dir, const char *repository)
 639 {
 640     FILE *fout;
 641     char *tmp;
 642
 643     if (noexec)
 644         return;
 645
 646     if (dir != NULL)
 647         tmp = Xasprintf ("%s/%s", dir, CVSADM_TAG);
 648     else
 649         tmp = xstrdup (CVSADM_TAG);
 650
 651
 652     if (tag || date)
 653     {
 654         fout = xfopen (tmp, "w+");
 655         if (tag)
 656         {
 657             if (nonbranch)
 658             {
 659                 if (fprintf (fout, "N%s\n", tag) < 0)
 660                     error (1, errno, "write to %s failed", tmp);
 661             }
 662             else
 663             {
 664                 if (fprintf (fout, "T%s\n", tag) < 0)
 665                     error (1, errno, "write to %s failed", tmp);
 666             }
 667         }
 668         else
 669         {
 670             if (fprintf (fout, "D%s\n", date) < 0)
 671                 error (1, errno, "write to %s failed", tmp);
 672         }
 673         if (fclose (fout) == EOF)
 674             error (1, errno, "cannot close %s", tmp);
 675     }
 676     else
 677         if (unlink_file (tmp) < 0 && ! existence_error (errno))
 678             error (1, errno, "cannot remove %s", tmp);
 679     free (tmp);
 680 #ifdef SERVER_SUPPORT
 681     if (server_active)
 682         server_set_sticky (update_dir, repository, tag, date, nonbranch);
 683 #endif
 684 }
 685
 686 /* Parse the CVS/Tag file for the current directory.
 687
 688    If it contains a date, sets *DATEP to the date in a newly malloc'd
 689    string, *TAGP to NULL, and *NONBRANCHP to an unspecified value.
 690
 691    If it contains a branch tag, sets *TAGP to the tag in a newly
 692    malloc'd string, *NONBRANCHP to 0, and *DATEP to NULL.
 693
 694    If it contains a nonbranch tag, sets *TAGP to the tag in a newly
 695    malloc'd string, *NONBRANCHP to 1, and *DATEP to NULL.
 696
 697    If it does not exist, or contains something unrecognized by this
 698    version of CVS, set *DATEP and *TAGP to NULL and *NONBRANCHP to
 699    an unspecified value.
 700
 701    If there is an error, print an error message, set *DATEP and *TAGP
 702    to NULL, and return.  */
 703 void
 704 ParseTag (char **tagp, char **datep, int *nonbranchp)
 705 {
 706     FILE *fp;
 707
 708     if (tagp)
 709         *tagp = NULL;
 710     if (datep)
 711         *datep = NULL;
 712     /* Always store a value here, even in the 'D' case where the value
 713        is unspecified.  Shuts up tools which check for references to
 714        uninitialized memory.  */
 715     if (nonbranchp != NULL)
 716         *nonbranchp = 0;
 717     fp = CVS_FOPEN (CVSADM_TAG, "r");
 718     if (fp)
 719     {
 720         char *line;
 721         int line_length;
 722         size_t line_chars_allocated;
 723
 724         line = NULL;
 725         line_chars_allocated = 0;
 726
 727         if ((line_length = getline (&line, &line_chars_allocated, fp)) > 0)
 728         {
 729             /* Remove any trailing newline.  */
 730             if (line[line_length - 1] == '\n')
 731                 line[--line_length] = '\0';
 732             switch (*line)
 733             {
 734                 case 'T':
 735                     if (tagp != NULL)
 736                         *tagp = xstrdup (line + 1);
 737                     break;
 738                 case 'D':
 739                     if (datep != NULL)
 740                         *datep = xstrdup (line + 1);
 741                     break;
 742                 case 'N':
 743                     if (tagp != NULL)
 744                         *tagp = xstrdup (line + 1);
 745                     if (nonbranchp != NULL)
 746                         *nonbranchp = 1;
 747                     break;
 748                 default:
 749                     /* Silently ignore it; it may have been
 750                        written by a future version of CVS which extends the
 751                        syntax.  */
 752                     break;
 753             }
 754         }
 755
 756         if (line_length < 0)
 757         {
 758             /* FIXME-update-dir: should include update_dir in messages.  */
 759             if (feof (fp))
 760                 error (0, 0, "cannot read %s: end of file", CVSADM_TAG);
 761             else
 762                 error (0, errno, "cannot read %s", CVSADM_TAG);
 763         }
 764
 765         if (fclose (fp) < 0)
 766             /* FIXME-update-dir: should include update_dir in message.  */
 767             error (0, errno, "cannot close %s", CVSADM_TAG);
 768
 769         free (line);
 770     }
 771     else if (!existence_error (errno))
 772         /* FIXME-update-dir: should include update_dir in message.  */
 773         error (0, errno, "cannot open %s", CVSADM_TAG);
 774 }
 775
 776 /*
 777  * This is called if all subdirectory information is known, but there
 778  * aren't any subdirectories.  It records that fact in the list
 779  * private data.
 780  */
 781
 782 void
 783 Subdirs_Known (List *entries)
 784 {
 785     struct stickydirtag *sdtp = entries->list->data;
 786
 787     /* If there is no list private data, that means that the
 788        subdirectory information is known.  */
 789     if (sdtp != NULL && ! sdtp->subdirs)
 790     {
 791         FILE *fp;
 792
 793         sdtp->subdirs = 1;
 794         if (!noexec)
 795         {
 796             /* Create Entries.Log so that Entries_Close will do something.  */
 797             entfilename = CVSADM_ENTLOG;
 798             fp = CVS_FOPEN (entfilename, "a");
 799             if (fp == NULL)
 800             {
 801                 int save_errno = errno;
 802
 803                 /* As in subdir_record, just silently skip the whole thing
 804                    if there is no CVSADM directory.  */
 805                 if (! isdir (CVSADM))
 806                     return;
 807                 error (1, save_errno, "cannot open %s", entfilename);
 808             }
 809             else
 810             {
 811                 if (fclose (fp) == EOF)
 812                     error (1, errno, "cannot close %s", entfilename);
 813             }
 814         }
 815     }
 816 }
 817
 818 /* Record subdirectory information.  */
 819
 820 static Entnode *
 821 subdir_record (int cmd, const char *parent, const char *dir)
 822 {
 823     Entnode *entnode;
 824
 825     /* None of the information associated with a directory is
 826        currently meaningful.  */
 827     entnode = Entnode_Create (ENT_SUBDIR, dir, "", "", "",
 828                               NULL, NULL, NULL);
 829
 830     if (!noexec)
 831     {
 832         if (parent == NULL)
 833             entfilename = CVSADM_ENTLOG;
 834         else
 835             entfilename = Xasprintf ("%s/%s", parent, CVSADM_ENTLOG);
 836
 837         entfile = CVS_FOPEN (entfilename, "a");
 838         if (entfile == NULL)
 839         {
 840             int save_errno = errno;
 841
 842             /* It is not an error if there is no CVS administration
 843                directory.  Permitting this case simplifies some
 844                calling code.  */
 845
 846             if (parent == NULL)
 847             {
 848                 if (! isdir (CVSADM))
 849                     return entnode;
 850             }
 851             else
 852             {
 853                 free (entfilename);
 854                 entfilename = Xasprintf ("%s/%s", parent, CVSADM);
 855                 if (! isdir (entfilename))
 856                 {
 857                     free (entfilename);
 858                     entfilename = NULL;
 859                     return entnode;
 860                 }
 861             }
 862
 863             error (1, save_errno, "cannot open %s", entfilename);
 864         }
 865
 866         if (fprintf (entfile, "%c ", cmd) < 0)
 867             error (1, errno, "cannot write %s", entfilename);
 868
 869         if (fputentent (entfile, entnode) != 0)
 870             error (1, errno, "cannot write %s", entfilename);
 871
 872         if (fclose (entfile) == EOF)
 873             error (1, errno, "error closing %s", entfilename);
 874
 875         if (parent != NULL)
 876         {
 877             free (entfilename);
 878             entfilename = NULL;
 879         }
 880     }
 881
 882     return entnode;
 883 }
 884
 885 /*
 886  * Record the addition of a new subdirectory DIR in PARENT.  PARENT
 887  * may be NULL, which means the current directory.  ENTRIES is the
 888  * current entries list; it may be NULL, which means that it need not
 889  * be updated.
 890  */
 891
 892 void
 893 Subdir_Register (List *entries, const char *parent, const char *dir)
 894 {
 895     Entnode *entnode;
 896
 897     /* Ignore attempts to register ".".  These can happen in the
 898        server code.  */
 899     if (dir[0] == '.' && dir[1] == '\0')
 900         return;
 901
 902     entnode = subdir_record ('A', parent, dir);
 903
 904     if (entries != NULL && (parent == NULL || strcmp (parent, ".") == 0))
 905         (void) AddEntryNode (entries, entnode);
 906     else
 907         Entnode_Destroy (entnode);
 908 }
 909
 910
 911
 912 /*
 913  * Record the removal of a subdirectory.  The arguments are the same
 914  * as for Subdir_Register.
 915  */
 916
 917 void
 918 Subdir_Deregister (List *entries, const char *parent, const char *dir)
 919 {
 920     Entnode *entnode;
 921
 922     entnode = subdir_record ('R', parent, dir);
 923     Entnode_Destroy (entnode);
 924
 925     if (entries != NULL && (parent == NULL || strcmp (parent, ".") == 0))
 926     {
 927         Node *p;
 928
 929         p = findnode_fn (entries, dir);
 930         if (p != NULL)
 931             delnode (p);
 932     }
 933 }
 934
 935
 936
 937 /* OK, the following base_* code tracks the revisions of the files in
 938    CVS/Base.  We do this in a file CVS/Baserev.  Separate from
 939    CVS/Entries because it needs to go in separate data structures
 940    anyway (the name in Entries must be unique), so this seemed
 941    cleaner.  The business of rewriting the whole file in
 942    base_deregister and base_register is the kind of thing we used to
 943    do for Entries and which turned out to be slow, which is why there
 944    is now the Entries.Log machinery.  So maybe from that point of
 945    view it is a mistake to do this separately from Entries, I dunno.  */
 946
 947 enum base_walk
 948 {
 949     /* Set the revision for FILE to *REV.  */
 950     BASE_REGISTER,
 951     /* Get the revision for FILE and put it in a newly malloc'd string
 952        in *REV, or put NULL if not mentioned.  */
 953     BASE_GET,
 954     /* Remove FILE.  */
 955     BASE_DEREGISTER
 956 };
 957
 958 static void base_walk (enum base_walk, struct file_info *, char **);
 959
 960 /* Read through the lines in CVS/Baserev, taking the actions as documented
 961    for CODE.  */
 962
 963 static void
 964 base_walk (enum base_walk code, struct file_info *finfo, char **rev)
 965 {
 966     FILE *fp;
 967     char *line;
 968     size_t line_allocated;
 969     FILE *newf;
 970     char *baserev_fullname;
 971     char *baserevtmp_fullname;
 972
 973     line = NULL;
 974     line_allocated = 0;
 975     newf = NULL;
 976
 977     /* First compute the fullnames for the error messages.  This
 978        computation probably should be broken out into a separate function,
 979        as recurse.c does it too and places like Entries_Open should be
 980        doing it.  */
 981     if (finfo->update_dir[0] != '\0')
 982     {
 983         baserev_fullname = Xasprintf ("%s/%s", finfo->update_dir,
 984                                       CVSADM_BASEREV);
 985         baserevtmp_fullname = Xasprintf ("%s/%s", finfo->update_dir,
 986                                          CVSADM_BASEREVTMP);
 987     }
 988     else
 989     {
 990         baserev_fullname = xstrdup (CVSADM_BASEREV);
 991         baserevtmp_fullname = xstrdup (CVSADM_BASEREVTMP);
 992     }
 993
 994     fp = CVS_FOPEN (CVSADM_BASEREV, "r");
 995     if (fp == NULL)
 996     {
 997         if (!existence_error (errno))
 998         {
 999             error (0, errno, "cannot open %s for reading", baserev_fullname);
1000             goto out;
1001         }
1002     }
1003
1004     switch (code)
1005     {
1006         case BASE_REGISTER:
1007         case BASE_DEREGISTER:
1008             newf = CVS_FOPEN (CVSADM_BASEREVTMP, "w");
1009             if (newf == NULL)
1010             {
1011                 error (0, errno, "cannot open %s for writing",
1012                        baserevtmp_fullname);
1013                 goto out;
1014             }
1015             break;
1016         case BASE_GET:
1017             *rev = NULL;
1018             break;
1019     }
1020
1021     if (fp != NULL)
1022     {
1023         while (getline (&line, &line_allocated, fp) >= 0)
1024         {
1025             char *linefile;
1026             char *p;
1027             char *linerev;
1028
1029             if (line[0] != 'B')
1030                 /* Ignore, for future expansion.  */
1031                 continue;
1032
1033             linefile = line + 1;
1034             p = strchr (linefile, '/');
1035             if (p == NULL)
1036                 /* Syntax error, ignore.  */
1037                 continue;
1038             linerev = p + 1;
1039             p = strchr (linerev, '/');
1040             if (p == NULL)
1041                 continue;
1042
1043             linerev[-1] = '\0';
1044             if (fncmp (linefile, finfo->file) == 0)
1045             {
1046                 switch (code)
1047                 {
1048                 case BASE_REGISTER:
1049                 case BASE_DEREGISTER:
1050                     /* Don't copy over the old entry, we don't want it.  */
1051                     break;
1052                 case BASE_GET:
1053                     *p = '\0';
1054                     *rev = xstrdup (linerev);
1055                     *p = '/';
1056                     goto got_it;
1057                 }
1058             }
1059             else
1060             {
1061                 linerev[-1] = '/';
1062                 switch (code)
1063                 {
1064                 case BASE_REGISTER:
1065                 case BASE_DEREGISTER:
1066                     if (fprintf (newf, "%s\n", line) < 0)
1067                         error (0, errno, "error writing %s",
1068                                baserevtmp_fullname);
1069                     break;
1070                 case BASE_GET:
1071                     break;
1072                 }
1073             }
1074         }
1075         if (ferror (fp))
1076             error (0, errno, "cannot read %s", baserev_fullname);
1077     }
1078  got_it:
1079
1080     if (code == BASE_REGISTER)
1081     {
1082         if (fprintf (newf, "B%s/%s/\n", finfo->file, *rev) < 0)
1083             error (0, errno, "error writing %s",
1084                    baserevtmp_fullname);
1085     }
1086
1087  out:
1088
1089     if (line != NULL)
1090         free (line);
1091
1092     if (fp != NULL)
1093     {
1094         if (fclose (fp) < 0)
1095             error (0, errno, "cannot close %s", baserev_fullname);
1096     }
1097     if (newf != NULL)
1098     {
1099         if (fclose (newf) < 0)
1100             error (0, errno, "cannot close %s", baserevtmp_fullname);
1101         rename_file (CVSADM_BASEREVTMP, CVSADM_BASEREV);
1102     }
1103
1104     free (baserev_fullname);
1105     free (baserevtmp_fullname);
1106 }
1107
1108 /* Return, in a newly malloc'd string, the revision for FILE in CVS/Baserev,
1109    or NULL if not listed.  */
1110
1111 char *
1112 base_get (struct file_info *finfo)
1113 {
1114     char *rev;
1115     base_walk (BASE_GET, finfo, &rev);
1116     return rev;
1117 }
1118
1119 /* Set the revision for FILE to REV.  */
1120
1121 void
1122 base_register (struct file_info *finfo, char *rev)
1123 {
1124     base_walk (BASE_REGISTER, finfo, &rev);
1125 }
1126
1127 /* Remove FILE.  */
1128
1129 void
1130 base_deregister (struct file_info *finfo)
1131 {
1132     base_walk (BASE_DEREGISTER, finfo, NULL);
1133 }