cache.c

   1 /*
   2  * Copyright 2001, 2002, 2003 David Mansfield and Cobite, Inc.
   3  * See COPYING file for license information
   4  */
   5
   6 #include <stdio.h>
   7 #include <search.h>
   8 #include <string.h>
   9 #include <stdlib.h>
  10 #include <limits.h>
  11 #include <unistd.h>
  12 #include <ctype.h>
  13 #include <time.h>
  14
  15 #include <cbtcommon/hash.h>
  16 #include <cbtcommon/debug.h>
  17
  18 #include "cache.h"
  19 #include "cvsps_types.h"
  20 #include "cvsps.h"
  21 #include "util.h"
  22
  23 #define CACHE_DESCR_BOUNDARY "-=-END CVSPS DESCR-=-\n"
  24
  25 /* change this when making the on-disk cache-format invalid */
  26 static int cache_version = 1;
  27
  28 /* the tree walk API pretty much requries use of globals :-( */
  29 static FILE * cache_fp;
  30 static int ps_counter;
  31
  32 static void write_patch_set_to_cache(PatchSet *);
  33 static void parse_cache_revision(PatchSetMember *, const char *);
  34 static void dump_patch_set(FILE *, PatchSet *);
  35
  36 static FILE *cache_open(char const *mode)
  37 {
  38     char *prefix;
  39     char fname[PATH_MAX];
  40     char root[PATH_MAX];
  41     char repository[PATH_MAX];
  42     FILE * fp;
  43
  44     /* Get the prefix */
  45     prefix = get_cvsps_dir();
  46     if (!prefix)
  47         return NULL;
  48
  49     /* Generate the full path */
  50     strcpy(root, root_path);
  51     strcpy(repository, repository_path);
  52
  53     strrep(root, '/', '#');
  54     strrep(repository, '/', '#');
  55
  56     snprintf(fname, PATH_MAX, "%s/%s#%s", prefix, root, repository);
  57
  58     if (!(fp = fopen(fname, mode)) && *mode == 'r')
  59     {
  60         if ((fp = fopen("CVS/cvsps.cache", mode)))
  61         {
  62             fprintf(stderr, "\n");
  63             fprintf(stderr, "****WARNING**** Obsolete CVS/cvsps.cache file found.\n");
  64             fprintf(stderr, "                New file will be re-written in ~/%s/\n", CVSPS_PREFIX);
  65             fprintf(stderr, "                Old file will be ignored.\n");
  66             fprintf(stderr, "                Please manually remove the old file.\n");
  67             fprintf(stderr, "                Continuing in 5 seconds.\n");
  68             sleep(5);
  69             fclose(fp);
  70             fp = NULL;
  71         }
  72     }
  73
  74     return fp;
  75 }
  76
  77 /* ************ Reading ************ */
  78
  79 enum
  80 {
  81     CACHE_NEED_FILE,
  82     CACHE_NEED_BRANCHES,
  83     CACHE_NEED_SYMBOLS,
  84     CACHE_NEED_REV,
  85     CACHE_NEED_PS,
  86     CACHE_NEED_PS_DATE,
  87     CACHE_NEED_PS_AUTHOR,
  88     CACHE_NEED_PS_TAG,
  89     CACHE_NEED_PS_TAG_FLAGS,
  90     CACHE_NEED_PS_BRANCH,
  91     CACHE_NEED_PS_BRANCH_ADD,
  92     CACHE_NEED_PS_DESCR,
  93     CACHE_NEED_PS_EOD,
  94     CACHE_NEED_PS_MEMBERS,
  95     CACHE_NEED_PS_EOM
  96 };
  97
  98 time_t read_cache()
  99 {
 100     FILE * fp;
 101     char buff[BUFSIZ];
 102     int state = CACHE_NEED_FILE;
 103     CvsFile * f = NULL;
 104     PatchSet * ps = NULL;
 105     char datebuff[20] = "";
 106     char authbuff[AUTH_STR_MAX] = "";
 107     char tagbuff[LOG_STR_MAX] = "";
 108     int tag_flags = 0;
 109     char branchbuff[LOG_STR_MAX] = "";
 110     int branch_add = 0;
 111     int logbufflen = LOG_STR_MAX + 1;
 112     char * logbuff = malloc(logbufflen);
 113     time_t cache_date = -1;
 114     int read_version;
 115
 116     if (logbuff == NULL)
 117     {
 118         debug(DEBUG_SYSERROR, "could not malloc %d bytes for logbuff in read_cache", logbufflen);
 119         exit(1);
 120     }
 121
 122     logbuff[0] = 0;
 123
 124     if (!(fp = cache_open("r")))
 125         goto out;
 126
 127     /* first line is cache version  format "cache version: %d\n" */
 128     if (!fgets(buff, BUFSIZ, fp) || strncmp(buff, "cache version:", 14))
 129     {
 130         debug(DEBUG_APPERROR, "bad cvsps.cache file");
 131         goto out_close;
 132     }
 133
 134     if ((read_version = atoi(buff + 15)) != cache_version)
 135     {
 136         debug(DEBUG_APPERROR, "bad cvsps.cache version %d, expecting %d.  ignoring cache",
 137               read_version, cache_version);
 138         goto out_close;
 139     }
 140
 141     /* second line is date cache was created, format "cache date: %d\n" */
 142     if (!fgets(buff, BUFSIZ, fp) || strncmp(buff, "cache date:", 11))
 143     {
 144         debug(DEBUG_APPERROR, "bad cvsps.cache file");
 145         goto out_close;
 146     }
 147
 148     cache_date = atoi(buff + 12);
 149     debug(DEBUG_STATUS, "read cache_date %d", (int)cache_date);
 150
 151     while (fgets(buff, BUFSIZ, fp))
 152     {
 153         int len = strlen(buff);
 154
 155         switch(state)
 156         {
 157         case CACHE_NEED_FILE:
 158             if (strncmp(buff, "file:", 5) == 0)
 159             {
 160                 len -= 6;
 161                 f = create_cvsfile();
 162                 f->filename = xstrdup(buff + 6);
 163                 f->filename[len-1] = 0; /* Remove the \n at the end of line */
 164                 debug(DEBUG_STATUS, "read cache filename '%s'", f->filename);
 165                 put_hash_object_ex(file_hash, f->filename, f, HT_NO_KEYCOPY, NULL, NULL);
 166                 state = CACHE_NEED_BRANCHES;
 167             }
 168             else
 169             {
 170                 state = CACHE_NEED_PS;
 171             }
 172             break;
 173         case CACHE_NEED_BRANCHES:
 174             if (buff[0] != '\n')
 175             {
 176                 char * tag;
 177
 178                 tag = strchr(buff, ':');
 179                 if (tag)
 180                 {
 181                     *tag = 0;
 182                     tag += 2;
 183                     buff[len - 1] = 0;
 184                     cvs_file_add_branch(f, buff, tag);
 185                 }
 186             }
 187             else
 188             {
 189                 f->have_branches = 1;
 190                 state = CACHE_NEED_SYMBOLS;
 191             }
 192             break;
 193         case CACHE_NEED_SYMBOLS:
 194             if (buff[0] != '\n')
 195             {
 196                 char * rev;
 197
 198                 rev = strchr(buff, ':');
 199                 if (rev)
 200                 {
 201                     *rev = 0;
 202                     rev += 2;
 203                     buff[len - 1] = 0;
 204                     cvs_file_add_symbol(f, rev, buff);
 205                 }
 206             }
 207             else
 208             {
 209                 state = CACHE_NEED_REV;
 210             }
 211             break;
 212         case CACHE_NEED_REV:
 213             if (isdigit(buff[0]))
 214             {
 215                 char * p = strchr(buff, ' ');
 216                 if (p)
 217                 {
 218                     CvsFileRevision * rev;
 219                     *p++ = 0;
 220                     buff[len-1] = 0;
 221                     rev = cvs_file_add_revision(f, buff);
 222                     if (strcmp(rev->branch, p) != 0)
 223                     {
 224                         debug(DEBUG_APPERROR, "branch mismatch for %s:%s %s != %s",
 225                               rev->file->filename, rev->rev, rev->branch, p);
 226                     }
 227                 }
 228             }
 229             else
 230             {
 231                 state = CACHE_NEED_FILE;
 232             }
 233             break;
 234         case CACHE_NEED_PS:
 235             if (strncmp(buff, "patchset:", 9) == 0)
 236                 state = CACHE_NEED_PS_DATE;
 237             break;
 238         case CACHE_NEED_PS_DATE:
 239             if (strncmp(buff, "date:", 5) == 0)
 240             {
 241                 /* remove prefix "date: " and LF from len */
 242                 len -= 6;
 243                 strzncpy(datebuff, buff + 6, MIN(len, sizeof(datebuff)));
 244                 state = CACHE_NEED_PS_AUTHOR;
 245             }
 246             break;
 247         case CACHE_NEED_PS_AUTHOR:
 248             if (strncmp(buff, "author:", 7) == 0)
 249             {
 250                 /* remove prefix "author: " and LF from len */
 251                 len -= 8;
 252                 strzncpy(authbuff, buff + 8, MIN(len, AUTH_STR_MAX));
 253                 state = CACHE_NEED_PS_TAG;
 254             }
 255             break;
 256         case CACHE_NEED_PS_TAG:
 257             if (strncmp(buff, "tag:", 4) == 0)
 258             {
 259                 /* remove prefix "tag: " and LF from len */
 260                 len -= 5;
 261                 strzncpy(tagbuff, buff + 5, MIN(len, LOG_STR_MAX));
 262                 state = CACHE_NEED_PS_TAG_FLAGS;
 263             }
 264             break;
 265         case CACHE_NEED_PS_TAG_FLAGS:
 266             if (strncmp(buff, "tag_flags:", 10) == 0)
 267             {
 268                 /* remove prefix "tag_flags: " and LF from len */
 269                 len -= 11;
 270                 tag_flags = atoi(buff + 11);
 271                 state = CACHE_NEED_PS_BRANCH;
 272             }
 273             break;
 274         case CACHE_NEED_PS_BRANCH:
 275             if (strncmp(buff, "branch:", 7) == 0)
 276             {
 277                 /* remove prefix "branch: " and LF from len */
 278                 len -= 8;
 279                 strzncpy(branchbuff, buff + 8, MIN(len, LOG_STR_MAX));
 280                 state = CACHE_NEED_PS_BRANCH_ADD;
 281             }
 282             break;
 283         case CACHE_NEED_PS_BRANCH_ADD:
 284             if (strncmp(buff, "branch_add:", 11) == 0)
 285             {
 286                 /* remove prefix "branch_add: " and LF from len */
 287                 len -= 12;
 288                 branch_add = atoi(buff + 12);
 289                 state = CACHE_NEED_PS_DESCR;
 290             }
 291             break;
 292         case CACHE_NEED_PS_DESCR:
 293             if (strncmp(buff, "descr:", 6) == 0)
 294                 state = CACHE_NEED_PS_EOD;
 295             break;
 296         case CACHE_NEED_PS_EOD:
 297             if (strcmp(buff, CACHE_DESCR_BOUNDARY) == 0)
 298             {
 299                 debug(DEBUG_STATUS, "patch set %s %s %s %s", datebuff, authbuff, logbuff, branchbuff);
 300                 ps = get_patch_set(datebuff, logbuff, authbuff, branchbuff, NULL);
 301                 /* the tag and tag_flags will be assigned by the resolve_global_symbols code
 302                  * ps->tag = (strlen(tagbuff)) ? get_string(tagbuff) : NULL;
 303                  * ps->tag_flags = tag_flags;
 304                  */
 305                 ps->branch_add = branch_add;
 306                 state = CACHE_NEED_PS_MEMBERS;
 307             }
 308             else
 309             {
 310                 /* Make sure we have enough in the buffer */
 311                 int len = strlen(buff);
 312                 if (strlen(logbuff) + len >= LOG_STR_MAX)
 313                 {
 314                     logbufflen += (len >= LOG_STR_MAX ? (len+1) : LOG_STR_MAX);
 315                     char * newlogbuff = realloc(logbuff, logbufflen);
 316                     if (newlogbuff == NULL)
 317                     {
 318                         debug(DEBUG_SYSERROR, "could not realloc %d bytes for logbuff in read_cache", logbufflen);
 319                         exit(1);
 320                     }
 321                     logbuff = newlogbuff;
 322                 }
 323                 strcat(logbuff, buff);
 324             }
 325             break;
 326         case CACHE_NEED_PS_MEMBERS:
 327             if (strncmp(buff, "members:", 8) == 0)
 328                 state = CACHE_NEED_PS_EOM;
 329             break;
 330         case CACHE_NEED_PS_EOM:
 331             if (buff[0] == '\n')
 332             {
 333                 datebuff[0] = 0;
 334                 authbuff[0] = 0;
 335                 tagbuff[0] = 0;
 336                 tag_flags = 0;
 337                 branchbuff[0] = 0;
 338                 branch_add = 0;
 339                 logbuff[0] = 0;
 340                 state = CACHE_NEED_PS;
 341             }
 342             else
 343             {
 344                 PatchSetMember * psm = create_patch_set_member();
 345                 parse_cache_revision(psm, buff);
 346                 patch_set_add_member(ps, psm);
 347             }
 348             break;
 349         }
 350     }
 351
 352  out_close:
 353     fclose(fp);
 354  out:
 355     free(logbuff);
 356     return cache_date;
 357 }
 358
 359 enum
 360 {
 361     CR_FILENAME,
 362     CR_PRE_REV,
 363     CR_POST_REV,
 364     CR_DEAD,
 365     CR_BRANCH_POINT
 366 };
 367
 368 static void parse_cache_revision(PatchSetMember * psm, const char * p_buff)
 369 {
 370     /* The format used to generate is:
 371      * "file:%s; pre_rev:%s; post_rev:%s; dead:%d; branch_point:%d\n"
 372      */
 373     char filename[PATH_MAX];
 374     char pre[REV_STR_MAX];
 375     char post[REV_STR_MAX];
 376     int dead = 0;
 377     int bp = 0;
 378     char buff[BUFSIZ];
 379     int state = CR_FILENAME;
 380     const char *s;
 381     char * p = buff;
 382
 383     strcpy(buff, p_buff);
 384
 385     while ((s = strsep(&p, ";")))
 386     {
 387         char * c = strchr(s, ':');
 388
 389         if (!c)
 390         {
 391             debug(DEBUG_APPERROR, "invalid cache revision line '%s'|'%s'", p_buff, s);
 392             exit(1);
 393         }
 394
 395         *c++ = 0;
 396
 397         switch(state)
 398         {
 399         case CR_FILENAME:
 400             strcpy(filename, c);
 401             break;
 402         case CR_PRE_REV:
 403             strcpy(pre, c);
 404             break;
 405         case CR_POST_REV:
 406             strcpy(post, c);
 407             break;
 408         case CR_DEAD:
 409             dead = atoi(c);
 410             break;
 411         case CR_BRANCH_POINT:
 412             bp = atoi(c);
 413             break;
 414         }
 415         state++;
 416     }
 417
 418     psm->file = (CvsFile*)get_hash_object(file_hash, filename);
 419
 420     if (!psm->file)
 421     {
 422         debug(DEBUG_APPERROR, "file '%s' not found in hash", filename);
 423         exit(1);
 424     }
 425
 426     psm->pre_rev = file_get_revision(psm->file, pre);
 427     psm->post_rev = file_get_revision(psm->file, post);
 428     psm->post_rev->dead = dead;
 429     psm->post_rev->post_psm = psm;
 430
 431     if (!bp)
 432     {
 433         if (psm->pre_rev)
 434             psm->pre_rev->pre_psm = psm;
 435     }
 436     else
 437     {
 438         list_add(&psm->post_rev->link, &psm->pre_rev->branch_children);
 439     }
 440 }
 441
 442 /************ Writing ************/
 443
 444 void write_cache(time_t cache_date)
 445 {
 446     struct hash_entry * file_iter;
 447
 448     ps_counter = 0;
 449
 450     if ((cache_fp = cache_open("w")) == NULL)
 451     {
 452         debug(DEBUG_SYSERROR, "can't open cvsps.cache for write");
 453         return;
 454     }
 455
 456     fprintf(cache_fp, "cache version: %d\n", cache_version);
 457     fprintf(cache_fp, "cache date: %d\n", (int)cache_date);
 458
 459     reset_hash_iterator(file_hash);
 460
 461     while ((file_iter = next_hash_entry(file_hash)))
 462     {
 463         CvsFile * file = (CvsFile*)file_iter->he_obj;
 464         struct hash_entry * rev_iter;
 465
 466         fprintf(cache_fp, "file: %s\n", file->filename);
 467
 468         reset_hash_iterator(file->branches);
 469         while ((rev_iter = next_hash_entry(file->branches)))
 470         {
 471             char * rev = (char *)rev_iter->he_key;
 472             char * tag = (char *)rev_iter->he_obj;
 473             fprintf(cache_fp, "%s: %s\n", rev, tag);
 474         }
 475
 476         fprintf(cache_fp, "\n");
 477
 478         reset_hash_iterator(file->symbols);
 479         while ((rev_iter = next_hash_entry(file->symbols)))
 480         {
 481             char * tag = (char *)rev_iter->he_key;
 482             CvsFileRevision * rev = (CvsFileRevision*)rev_iter->he_obj;
 483
 484             if (rev->present)
 485                 fprintf(cache_fp, "%s: %s\n", tag, rev->rev);
 486         }
 487
 488         fprintf(cache_fp, "\n");
 489
 490         reset_hash_iterator(file->revisions);
 491         while ((rev_iter = next_hash_entry(file->revisions)))
 492         {
 493             CvsFileRevision * rev = (CvsFileRevision*)rev_iter->he_obj;
 494             if (rev->present)
 495                 fprintf(cache_fp, "%s %s\n", rev->rev, rev->branch);
 496         }
 497
 498         fprintf(cache_fp, "\n");
 499     }
 500
 501     fprintf(cache_fp, "\n");
 502     walk_all_patch_sets(write_patch_set_to_cache);
 503     fclose(cache_fp);
 504     cache_fp = NULL;
 505 }
 506
 507 static void write_patch_set_to_cache(PatchSet * ps)
 508 {
 509     dump_patch_set(cache_fp, ps);
 510 }
 511
 512 static void dump_patch_set(FILE * fp, PatchSet * ps)
 513 {
 514     struct list_head * next = ps->members.next;
 515
 516     ps_counter++;
 517     fprintf(fp, "patchset: %d\n", ps_counter);
 518     fprintf(fp, "date: %d\n", (int)ps->date);
 519     fprintf(fp, "author: %s\n", ps->author);
 520     fprintf(fp, "tag: %s\n", ps->tag ? ps->tag : "");
 521     fprintf(fp, "tag_flags: %d\n", ps->tag_flags);
 522     fprintf(fp, "branch: %s\n", ps->branch);
 523     fprintf(fp, "branch_add: %d\n", ps->branch_add);
 524     fprintf(fp, "descr:\n%s", ps->descr); /* descr is guaranteed to end with LF */
 525     fprintf(fp, CACHE_DESCR_BOUNDARY);
 526     fprintf(fp, "members:\n");
 527
 528     while (next != &ps->members)
 529     {
 530         PatchSetMember * psm = list_entry(next, PatchSetMember, link);
 531         int bp = 1;
 532
 533         /* this actually deduces if this revision is a branch point... */
 534         if (!psm->pre_rev || (psm->pre_rev->pre_psm && psm->pre_rev->pre_psm == psm))
 535             bp = 0;
 536
 537         fflush(fp);
 538
 539         fprintf(fp, "file:%s; pre_rev:%s; post_rev:%s; dead:%d; branch_point:%d\n",
 540                 psm->file->filename,
 541                 psm->pre_rev ? psm->pre_rev->rev : "INITIAL", psm->post_rev->rev,
 542                 psm->post_rev->dead, bp);
 543         next = next->next;
 544     }
 545
 546     fprintf(fp, "\n");
 547 }
 548
 549 /* where's arithmetic?... */