git.gag.com Git - debian/gcpegg/blob - storage.c

   1 /* PROGRAM:     eggsh
   2  * FILE:        $Header: /home/egg/src/RCS/storage.c,v 1.4 1998/12/31 22:07:56 ghn Exp $
   3  * PURPOSE:     Data storage functions
   4  * AUTHOR:      Greg Nelson
   5  * DATE:        98-05-09
   6  *
   7  * REVISED:
   8  * $Log: storage.c,v $
   9  * Revision 1.4  1998/12/31 22:07:56  ghn
  10  * Rev 5 code: includes multi-reg support, HTML, etc.
  11  *
  12  * Revision 1.3  1998/08/03 20:32:46  kelvin
  13  * File byte-order independence, STORAGE_DEBUG
  14  *
  15  * Revision 1.2  1998/08/01  17:18:45  ghn
  16  * Fixes to prevent core dumps and make "database" engine work correctly.
  17  *
  18  * Revision 1.1  1998/07/21 11:36:21  ghn
  19  * Initial revision
  20  *
  21  * Copyright 1998 - Greg Nelson
  22  * Redistributable under the terms of the GNU Public Licence (GPL)
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <time.h>
  31 #include <fcntl.h>
  32 #include <sys/types.h>
  33 #include <sys/time.h>
  34 #include <sys/stat.h>
  35 #include "global.h"
  36 #include "genlib.h"
  37 #include "storage.h"
  38 #include "errnos.h"
  39
  40 /* Some systems (e.g. Linux) implement strdup but don't define
  41    it by default in string.h.  Define it explicitly here, which
  42    doesn't seem to do any harm on other systems.  If you encounter
  43    an error on the following declaration, disable it for your
  44    platform. */
  45
  46 /*extern char *strdup (const char *s1);*/
  47
  48 /* Eventually, these might deal with making a safe copy or mounting
  49    and unmounting a partition. Until such time as we actually do
  50    something with these, they are no-ops. */
  51 #define Protect(x)
  52 #define Unprotect(x)
  53
  54 #define DATAFMT         "%Y%m/%%e"
  55 #define PROJSTART       901947600L
  56
  57 static char *datafmt;                 /* Data file format string */
  58
  59 /*  Prototypes for forward functions.  */
  60
  61 static int32 FileLoadPacket(FILE *fp, EggCarton *cart);
  62 static int32 next_filename(char *fn, uint32 tindex, int16 eggid,
  63                            int16 *lastind, int16 mustexist);
  64 static int32 next_poss_fn(char *fn, uint32 tindex, int16 eggid);
  65
  66 /* The seek optimisation table saves the file name, last
  67    packet returned, and corresponding file of the next
  68    packet (if any) in the file, for the last SEEK_OPT_MAX
  69    requests.  This allows LoadNextPacket to avoid searching
  70    the entire database for the next packet if the request
  71    matches one in the seek optimisation table.
  72
  73 */
  74
  75 #define SEEK_OPT_MAX MAX_BASKETS
  76
  77 struct seekopt {
  78     char filename[256];
  79     uint32 last_time;
  80     int32 next_packet;
  81 };
  82
  83 static struct seekopt seekOpt[SEEK_OPT_MAX];
  84 static int seekOptIndex = 0;
  85
  86 /* The initialization provides a way to specify a format for the
  87    database file names.  If the argument is null, it uses a default
  88    from the environment, or it takes the default given above.  This
  89    string is used as an argument to strftime(3) which replaces certain
  90    characters with corresponding fields of the date and time.  This
  91    provides an automatic way of generating a logical new filename on a
  92    periodic basis.  Note that you can call InitStorage as many times
  93    as you wish to change the format for file names opened
  94    subsequently. */
  95
  96 int32 InitStorage(char *path) {
  97   char *p, *np;
  98   char ns[256], pa[12];
  99   int changed = 0;
 100
 101   /* First, take this opportunity to clear the seek optimisation
 102      table.  If we're changing the file name format, none of the
 103      items in it will be valid in any case. */
 104
 105   memset(seekOpt, 0, sizeof seekOpt);
 106
 107   /* Set the path based on the environment variable, argument,
 108      or default. */
 109
 110   if (path == NULL) {
 111     if ((path = getenv("EGG_DATA")) == NULL) {
 112       path = DATAFMT;
 113     }
 114   }
 115
 116   /* If the path contains any of our special "$" editing
 117      codes, interpolate the requested text into the string.
 118      Strftime "%" editing codes are left intact. */
 119
 120   ns[0] = 0;
 121   p = path;
 122   while ((np = strchr(p, '$')) != NULL) {
 123     char *phrargs = np + 1;
 124
 125     /* Copy portion of string prior to phrase to output. */
 126
 127     if (np > p) {
 128         int l = strlen(ns);
 129
 130         memcpy(ns + l, p, np - p);
 131         ns[l + (np - p)] = 0;
 132     }
 133
 134     /* Parse format phrase and possible arguments. */
 135
 136     while ((*phrargs != 0) && !isalpha(*phrargs)) {
 137         phrargs++;
 138     }
 139     if (*phrargs == 0) {
 140         fprintf(stderr, "Data format string error in:\n    %s\nunterminated $ phrase.\n", path);
 141         exit(-1);
 142     }
 143
 144     /* Copy arguments, if any, to second character of arguments
 145        string for possible use by phrase interpreters in
 146        sprintf. */
 147
 148     pa[0] = '%';                      /* Start editing phrase */
 149     pa[1] = 0;
 150     if (phrargs > (np + 1)) {
 151         memcpy(pa + 1, np + 1, phrargs - (np + 1));
 152         pa[1 + (phrargs - (np + 1))] = 0;
 153     }
 154 /*fprintf(stderr, "Phrase arguments = <%s>\n", pa);*/
 155
 156     /* Now interpret the specific format phrase letters.
 157        The value selected by each phrase should be concatenated
 158        to the output string ns.  Available format phrases
 159        are:
 160
 161            $b          Basket name
 162            $e          Egg name
 163            $[0][n]E    Egg number, right justified,
 164                        optionally zero filled in n characters
 165
 166     */
 167
 168
 169     switch (*phrargs) {
 170
 171         case 'b':                     /* Basket name */
 172             strcat(ns, baskettable[0].name);
 173             break;
 174
 175         case 'e':                     /* Egg name */
 176             strcat(ns, eggtable[0].name);
 177             break;
 178
 179         case 'E':                     /* Egg number, edited decimal number */
 180             strcat(pa, "d");
 181             sprintf(ns + strlen(ns), pa, eggtable[0].id);
 182             break;
 183
 184         default:
 185             fprintf(stderr, "Data format string error in:\n    %s\nunknown phrase $%c.\n",
 186                     path, *phrargs);
 187             exit(-1);
 188     }
 189
 190     /* Adjust pointer to resume scan following the phrase
 191        in the source string. */
 192
 193     p = phrargs + 1;
 194     changed++;
 195   }
 196
 197   if (changed) {
 198     strcat(ns, p);                    /* Concatenate balance of string */
 199     path = strdup(ns);
 200     if (path == NULL) {
 201         fprintf(stderr, "Cannot allocate memory for file name format string.\n");
 202         exit(-1);
 203     }
 204 /*printf("Expanded path name phrase = <%s>\n", path); exit(0);*/
 205   }
 206
 207   datafmt = path;
 208   return 0;
 209 }
 210
 211 /* Save packet is the basic save function.  It does not take a
 212    filename, relying on the datafmt variable created during
 213    initialization to generate an appropriate filename.  The
 214    date for the saved data is based on the timestamp of the packet's
 215    first record. */
 216
 217 int32 SavePacket(EggCarton *cart) {
 218   FILE          *fp;
 219   char          *packet, datatmp[255], datafile[255], *sp;
 220   uint32        pktime, res;
 221
 222   pktime = cart->records[0].timestamp;
 223 #ifdef STORAGE_DEBUG
 224   time_t pktime_val = pktime;
 225   fprintf(stderr, "SavePacket for %u: %s", pktime, asctime(gmtime(&pktime_val)));
 226 #endif
 227
 228   /* Generate the file name corresponding to the date of
 229      the first record in the packet.  Since we know the
 230      date, there's no need to use next_filename. */
 231
 232   res = next_poss_fn(datafile, pktime, cart->hdr.eggid);
 233
 234   /* Open the file for appending. */
 235
 236   Unprotect(datafile);
 237   fp = fopen(datafile, "a");
 238
 239   /* If we can't open the file, the odds are it's because
 240      the file is in a directory we've yet to create. */
 241
 242   if (fp == NULL) {
 243 #ifdef STORAGE_DEBUG
 244     fprintf(stderr, "SavePacket: no such file %s\n", datafile);
 245 #endif
 246     sp = strrchr(datafile, '/');
 247     while (sp) {
 248       strncpy(datatmp, datafile, sp - datafile);
 249       datatmp[sp - datafile] = 0;
 250       mkdir(datatmp, 0777);
 251 #ifdef STORAGE_DEBUG
 252       fprintf(stderr, "SavePacket: mkdir %s\n", datatmp);
 253 #endif
 254       sp = strchr(sp + 1, '/');
 255     }
 256
 257     /* Now try re-opening the file.  */
 258
 259     Unprotect(datafile);
 260     if ((fp = fopen(datafile, "a")) == NULL) {
 261       fprintf(stderr, "SavePacket: cannot create database file %s.\n", datafile);
 262       exit(-1);
 263     }
 264   }
 265
 266   if (!fp) {
 267 #ifdef STORAGE_DEBUG
 268     fprintf(stderr, "SavePacket: error opening %s\n", datafile);
 269 #endif
 270     return -2;
 271   }
 272   packet = Packetize(cart);
 273   if (!packet) return -1;
 274   fwrite(packet, sizeof(char), cart->hdr.pktsize, fp);
 275   free(packet);
 276   fclose(fp);
 277   Protect(datafile);
 278   cart->hdr.numrec = 0;
 279
 280   return 1;
 281 }
 282
 283 /* Open database for reading, positioning to specified location.
 284    If eggid is less than zero, it will load any packet. */
 285 int32 OpenDatabase(DBRec *dbp, uint32 tindex, int16 eggid) {
 286   int32         res;
 287
 288 #ifdef STORAGE_DEBUG
 289   time_t tindex_val = tindex;
 290   fprintf(stderr, "OpenDatabase: Egg = %d, tindex = %u %s",
 291     eggid, tindex, asctime(gmtime(&tindex_val)));
 292 #endif
 293   dbp->eggind = 0;
 294   dbp->fp = NULL;
 295   if ((res = next_filename(dbp->fn, tindex, eggid, &(dbp->eggind), TRUE)) < 0)
 296     return res;
 297
 298   Unprotect(dbp->fn);
 299   dbp->fp = fopen(dbp->fn, "r");
 300   if (dbp->fp == NULL) {
 301     Protect(dbp->fn);
 302 #ifdef STORAGE_DEBUG
 303   fprintf(stderr, "OpenDatabase -- EOF\n");
 304 #endif
 305     return ERR_EOF;
 306   } else {
 307 #ifdef STORAGE_DEBUG
 308   fprintf(stderr, "OpenDatabase -- Opened %s\n", dbp->fn);
 309 #endif
 310     return ERR_NONE;
 311   }
 312 }
 313
 314 /* Close database */
 315 int32 CloseDatabase(DBRec *dbp) {
 316   fclose(dbp->fp);
 317 #ifdef STORAGE_DEBUG
 318   fprintf(stderr, "CloseDatabase -- Closed %s\n", dbp->fn);
 319 #endif
 320   Protect(dbp->fn);
 321   dbp->fp = NULL;
 322   /* We preserve file name; this lets us not open the same
 323      file name again unless we want to. */
 324   return ERR_NONE;
 325 }
 326
 327 /* Reset database allows us to open same file name again. */
 328 int32 ResetDatabase(DBRec *dbp) {
 329   *(dbp->fn) = 0;
 330 #ifdef STORAGE_DEBUG
 331   fprintf(stderr, "ResetDatabase\n");
 332 #endif
 333   return ERR_NONE;
 334 }
 335
 336 /* Load next packet fitting specified time index and egg id.
 337    If eggid is less than zero, it will load any packet. */
 338
 339 static int32 LoadNextPacket(DBRec *dbp, uint32 tindex, int16 eggid, EggCarton *cart) {
 340   EggCarton     pktbuf;
 341   int32         res, i;
 342   uint32        findex = tindex, now;
 343
 344   now = getzulutime(NULL);
 345   if (findex < PROJSTART) {
 346     findex = PROJSTART;
 347   }
 348 #ifdef STORAGE_DEBUG
 349   fprintf(stderr, "LoadNextPacket(%s, %u, %d)\n", dbp->fn, tindex, eggid);
 350 #endif
 351
 352   /* See if the start address for this request is present
 353      in the seek optimisation table.  If so, seek directly
 354      to the address to avoid having to read through all
 355      earlier packets in the database. */
 356
 357   i = seekOptIndex;
 358   /* Conditioning while on tindex > 0 causes seek optimisation to be
 359      skipped when a request for any packet is received. */
 360   while (tindex > 0) {
 361       i--;
 362       if (i < 0) {
 363           i = SEEK_OPT_MAX - 1;
 364       }
 365       if (strcmp(seekOpt[i].filename, dbp->fn) == 0 &&
 366           seekOpt[i].last_time == tindex) {
 367           fseek(dbp->fp, seekOpt[i].next_packet, SEEK_SET);
 368 #ifdef STORAGE_DEBUG
 369         time_t last_time_val = seekOpt[i].last_time;
 370         fprintf(stderr, "LoadNextPacket; Seek optimised [%d] to %d for\n    file %s at %u %s",
 371               i,
 372               seekOpt[i].next_packet,
 373               seekOpt[i].filename,
 374               seekOpt[i].last_time,
 375               asctime(gmtime(&last_time_val)));
 376
 377 #endif
 378           break;
 379       }
 380       if (i == seekOptIndex) {
 381 #ifdef STORAGE_DEBUG
 382         time_t tindex_val = tindex;
 383           fprintf(stderr, "LoadNextPacket; Cannot optimise seek in file %s\n    at %u %s",
 384               dbp->fn, tindex, asctime(gmtime(&tindex_val)));
 385 #endif
 386           break;                      /* Search wrapped table--cannot optimise */
 387       }
 388   }
 389
 390   while (1) {
 391     res = FileLoadPacket(dbp->fp, &pktbuf);
 392     if (res == ERR_EOF) {
 393       /* File is finished.  Close and open the next.  We assume
 394          that tindex and eggid have been tracking appropriately. */
 395       CloseDatabase(dbp);
 396
 397       /* Advance findex to start of next day after the one we've
 398          just exhausted. */
 399
 400 #define SECONDS_PER_DAY (24L * 60 * 60)
 401       findex = ((findex / SECONDS_PER_DAY) + 1) * SECONDS_PER_DAY;
 402 #ifdef STORAGE_DEBUG
 403      time_t findex_val = findex;
 404       fprintf(stderr, "LoadNextPacket; EOF, CloseDatabase, findex = %u: %s",
 405           findex, asctime(gmtime(&findex_val)));
 406 #endif
 407       if (findex > now) {
 408 #ifdef STORAGE_DEBUG
 409      time_t now_val = now;
 410           fprintf(stderr, "LoadNextPacket; EOF findex = %u > now = %u %s",
 411           findex, now, asctime(gmtime(&now_val)));
 412 #endif
 413         return ERR_EOF;
 414       }
 415       /* Do not reset database; we won't open same one again. */
 416       if ((res = OpenDatabase(dbp, findex, eggid)) < 0) return res;
 417       continue;
 418     }
 419 /*
 420 fprintf(stderr, "Eggid = %d Packet.eggid = %d\n", eggid, pktbuf.hdr.eggid);
 421 */
 422     if (eggid >= 0 && pktbuf.hdr.eggid != eggid) continue;
 423     for (i = 0; i < pktbuf.hdr.numrec; i++) {
 424 /*fprintf(stderr, " Rec %ld timestamp = %lu  tindex = %lu\n", i, pktbuf.records[i].timestamp, tindex);
 425 */
 426       if (pktbuf.records[i].timestamp > tindex) {
 427         memcpy(cart, &pktbuf, sizeof(EggCarton));
 428
 429         /* Save the location of the packet following this one
 430            in the seek optimisation table. */
 431
 432         strcpy(seekOpt[seekOptIndex].filename, dbp->fn);
 433         seekOpt[seekOptIndex].last_time = pktbuf.records[pktbuf.hdr.numrec - 1].timestamp;
 434         seekOpt[seekOptIndex].next_packet = ftell(dbp->fp);
 435 #ifdef STORAGE_DEBUG
 436      time_t last_time_val = seekOpt[seekOptIndex].last_time;
 437         fprintf(stderr, "LoadNextPacket; Seek optimisation[%d] for %s\n    to address %d for time %u %s",
 438             seekOptIndex,
 439             seekOpt[seekOptIndex].filename,
 440             seekOpt[seekOptIndex].next_packet,
 441             seekOpt[seekOptIndex].last_time,
 442             asctime(gmtime(&last_time_val)));
 443 #endif
 444         seekOptIndex = (seekOptIndex + 1) % SEEK_OPT_MAX;
 445         return ERR_NONE;
 446       }
 447     }
 448   }
 449 }
 450
 451 /* Load next packet following a particular time index and egg id */
 452
 453 int32 LoadPacket(uint32 tindex, int16 eggid, EggCarton *cart) {
 454   DBRec db;
 455   int32 res;
 456
 457   ResetDatabase(&db);   /* Here we need to be able to open same db as
 458                            last time. */
 459   if ((res = OpenDatabase(&db, tindex, eggid)) < 0) return res;
 460   if ((res = LoadNextPacket(&db, tindex, eggid, cart)) < 0) return res;
 461   return CloseDatabase(&db);
 462 }
 463
 464 static int32 FileLoadPacket(FILE *fp, EggCarton *cart) {
 465   char *rbuf;
 466   int32 res;
 467   uint16 pksize;
 468
 469   if (feof(fp)) return ERR_EOF;
 470
 471   if (fread(&(cart->hdr.type), sizeof(uint16), 1, fp) != 1) {
 472     if (feof(fp)) return ERR_EOF; else return ERR_CNREAD;
 473   }
 474   if (fread(&(cart->hdr.pktsize), sizeof(uint16), 1, fp) != 1) {
 475     if (feof(fp)) return ERR_EOF; else return ERR_CNREAD;
 476   }
 477
 478   /* Since the file packet is in network byte order, we need to
 479      be sure the length field is in host order before using
 480      it to allocate and read the balance of the packet from the
 481      file.  Once that's done, Unpacketize will take responsibility
 482      for getting all the packet fields into host order. */
 483   pksize = ntohs(cart->hdr.pktsize);
 484
 485   rbuf = (char *)malloc(pksize);
 486   if (!rbuf) return ERR_NOMEM;
 487
 488   memcpy(rbuf, &(cart->hdr), 2*sizeof(uint16));
 489   if (fread(rbuf+4, pksize - 4, 1, fp) != 1) return ERR_CNREAD;
 490
 491   res = Unpacketize(cart, rbuf);
 492   free(rbuf);
 493
 494   return res;
 495 }
 496
 497 static int32 next_filename(char *fn, uint32 tindex, int16 eggid,
 498                     int16 *lastind, int16 mustexist) {
 499   struct stat   statbuf;
 500   uint32        findex, now;
 501   int32         res;
 502   char          ldf[255];
 503
 504 #ifdef STORAGE_DEBUG
 505   time_t tindex_val = tindex;
 506   fprintf(stderr, "next_filename: egg = %d, mustexist = %d, tindex = %u %s",
 507     eggid, mustexist, tindex, asctime(gmtime(&tindex_val)));
 508 #endif
 509   if (eggid < 0 && !mustexist) {
 510 #ifdef STORAGE_DEBUG
 511     fprintf(stderr, "next_filename: egg ID out of range.\n");
 512 #endif
 513     return ERR_INRANGE;
 514   }
 515
 516   /* Can't go back before project began. */
 517   now = getzulutime(NULL);
 518   if (tindex < PROJSTART) {
 519     findex = PROJSTART;
 520   } else {
 521     findex = tindex;
 522   }
 523
 524   /* Search possible file names until one is found.  We jump by days,
 525      assuming files don't have a greater granularity than that.  In
 526      the existence-testing process, we are checking to make sure the
 527      file name is different each time. */
 528
 529   if (lastind == NULL) eggid = eggtable[0].id;
 530   else {
 531     if (eggid < 0) eggid = eggtable[(*lastind)++].id;
 532     if (*lastind == numeggs) *lastind = 0;
 533   }
 534
 535   strcpy(ldf, fn);
 536   do {
 537     res = next_poss_fn(fn, findex, eggid);
 538     findex += 86400L;
 539     if (!strcmp(fn, ldf)) continue;
 540     strcpy(ldf, fn);
 541     /* Check for file.  If stat fails, reason is ENOENT, isn't it? */
 542     if (stat(fn, &statbuf) >= 0) {
 543 #ifdef STORAGE_DEBUG
 544       fprintf(stderr, "next_filename: Found file %s\n", fn);
 545 #endif
 546         return ERR_NONE;
 547     }
 548     if (!mustexist) {
 549 #ifdef STORAGE_DEBUG
 550         fprintf(stderr, "next_filename: File %s does not exist.\n", fn);
 551 #endif
 552         return ERR_NOENT;
 553     }
 554   } while (findex < now+86400L);
 555
 556 #ifdef STORAGE_DEBUG
 557       fprintf(stderr, "next_filename: End of file.\n");
 558 #endif
 559   return ERR_EOF;
 560 }
 561
 562 /* tindex and eggid must be defined here */
 563 static int32 next_poss_fn(char *fn, uint32 tindex, int16 eggid) {
 564   char          datatmp[255], *sp;
 565   int16         eggind;
 566   struct tm     *tm;
 567
 568   time_t time_index = tindex;
 569   tm = gmtime(&time_index);
 570   strftime(datatmp, 255, datafmt, tm);
 571 #ifdef STORAGE_DEBUG
 572   fprintf(stderr, "next_poss_fn: egg = %d, tindex = %u %s",
 573     eggid, tindex, asctime(tm));
 574 #endif
 575
 576   /* If an %e phrase remains after processing by strftime
 577      (it should be specified as %%e in the original
 578      DATAFMT specification), interpolate the egg number
 579      from this packet. */
 580
 581   if ((sp = strchr(datatmp, '%')) != NULL) {
 582     if (sp[1] == 'e') {
 583       for (eggind = 0;
 584            eggind < numeggs && eggtable[eggind].id != eggid;
 585            eggind++);
 586       if (eggind == numeggs) {
 587 #ifdef STORAGE_DEBUG
 588         fprintf(stderr, "next_poss_fn: Egg number out of range.\n");
 589 #endif
 590         return ERR_INRANGE;
 591       }
 592       *sp = 0;
 593       strcpy(fn, datatmp);
 594       strcat(fn, eggtable[eggind].name);
 595       strcat(fn, sp + 2);
 596     } else {
 597       fprintf(stderr, "Bad file format expr: %%%c\n", sp[1]);
 598       strcpy(fn, datatmp);
 599       return ERR_INRANGE;
 600     }
 601   } else {
 602     strcpy(fn, datatmp);
 603   }
 604 #ifdef STORAGE_DEBUG
 605   fprintf(stderr, "next_poss_fn: File name = %s\n", fn);
 606 #endif
 607   return ERR_NONE;
 608 }