contrib/amd/mk-amd-map/mk-amd-map.c

   1 /*
   2  * Copyright (c) 1997-1998 Erez Zadok
   3  * Copyright (c) 1990 Jan-Simon Pendry
   4  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Jan-Simon Pendry at Imperial College, London.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by the University of
  22  *      California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  *
  39  *      %W% (Berkeley) %G%
  40  *
  41  * $Id: mk-amd-map.c,v 1.4 1998/08/27 07:25:25 obrien Exp $
  42  */
  43
  44 /*
  45  * Convert a file map into an ndbm map
  46  */
  47
  48 #ifdef HAVE_CONFIG_H
  49 # include <config.h>
  50 #endif /* HAVE_CONFIG_H */
  51 #include <am_defs.h>
  52
  53 /* dummy variables */
  54 char hostname[MAXHOSTNAMELEN];
  55 int orig_umask, foreground, debug_flags;
  56 pid_t mypid;
  57 serv_state amd_state;
  58
  59 /* (libdb version 2) uses .db extensions but an old dbm API */
  60 /* check for libgdbm to distinguish it from linux systems */
  61 #if defined(DBM_SUFFIX) && !defined(HAVE_LIBGDBM)
  62 # define HAVE_DB_SUFFIX
  63 #endif /* not defined(DBM_SUFFIX) && !defined(HAVE_LIBGDBM) */
  64
  65 #ifdef HAVE_MAP_NDBM
  66
  67 static int
  68 store_data(voidp db, char *k, char *v)
  69 {
  70   datum key, val;
  71
  72   key.dptr = k;
  73   val.dptr = v;
  74   key.dsize = strlen(k) + 1;
  75   val.dsize = strlen(v) + 1;
  76   return dbm_store((DBM *) db, key, val, DBM_INSERT);
  77 }
  78
  79
  80 /*
  81  * Read one line from file.
  82  */
  83 static int
  84 read_line(char *buf, int size, FILE *fp)
  85 {
  86   int done = 0;
  87
  88   do {
  89     while (fgets(buf, size, fp)) {
  90       int len = strlen(buf);
  91
  92       done += len;
  93       if (len > 1 && buf[len - 2] == '\\' && buf[len - 1] == '\n') {
  94         int ch;
  95         buf += len - 2;
  96         size -= len - 2;
  97         *buf = '\n';
  98         buf[1] = '\0';
  99
 100         /*
 101          * Skip leading white space on next line
 102          */
 103         while ((ch = getc(fp)) != EOF && isascii(ch) && isspace(ch)) ;
 104         (void) ungetc(ch, fp);
 105       } else {
 106         return done;
 107       }
 108     }
 109   } while (size > 0 && !feof(fp));
 110
 111   return done;
 112 }
 113
 114
 115 /*
 116  * Read through a map.
 117  */
 118 static int
 119 read_file(FILE *fp, char *map, voidp db)
 120 {
 121   char key_val[2048];
 122   int chuck = 0;
 123   int line_no = 0;
 124   int errs = 0;
 125
 126   while (read_line(key_val, 2048, fp)) {
 127     char *kp;
 128     char *cp;
 129     char *hash;
 130     int len = strlen(key_val);
 131
 132     line_no++;
 133
 134     /*
 135      * Make sure we got the whole line
 136      */
 137     if (key_val[len - 1] != '\n') {
 138       fprintf(stderr, "line %d in \"%s\" is too long", line_no, map);
 139       chuck = 1;
 140     } else {
 141       key_val[len - 1] = '\0';
 142     }
 143
 144     /*
 145      * Strip comments
 146      */
 147     hash = strchr(key_val, '#');
 148     if (hash)
 149       *hash = '\0';
 150
 151     /*
 152      * Find start of key
 153      */
 154     for (kp = key_val; *kp && isascii(*kp) && isspace((int)*kp); kp++) ;
 155
 156     /*
 157      * Ignore blank lines
 158      */
 159     if (!*kp)
 160       goto again;
 161
 162     /*
 163      * Find end of key
 164      */
 165     for (cp = kp; *cp && (!isascii(*cp) || !isspace((int)*cp)); cp++) ;
 166
 167     /*
 168      * Check whether key matches, or whether
 169      * the entry is a wildcard entry.
 170      */
 171     if (*cp)
 172       *cp++ = '\0';
 173     while (*cp && isascii(*cp) && isspace((int)*cp))
 174       cp++;
 175     if (*kp == '+') {
 176       fprintf(stderr, "Can't interpolate %s\n", kp);
 177       errs++;
 178     } else if (*cp) {
 179       if (db) {
 180         if (store_data(db, kp, cp) < 0) {
 181           fprintf(stderr, "Could store %s -> %s\n", kp, cp);
 182           errs++;
 183         }
 184       } else {
 185         printf("%s\t%s\n", kp, cp);
 186       }
 187     } else {
 188       fprintf(stderr, "%s: line %d has no value field", map, line_no);
 189       errs++;
 190     }
 191
 192   again:
 193     /*
 194      * If the last read didn't get a whole line then
 195      * throw away the remainder before continuing...
 196      */
 197     if (chuck) {
 198       while (fgets(key_val, sizeof(key_val), fp) &&
 199              !strchr(key_val, '\n')) ;
 200       chuck = 0;
 201     }
 202   }
 203   return errs;
 204 }
 205
 206
 207 static int
 208 remove_file(char *f)
 209 {
 210   if (unlink(f) < 0 && errno != ENOENT)
 211     return -1;
 212
 213   return 0;
 214 }
 215
 216
 217 int
 218 main(int argc, char *argv[])
 219 {
 220   FILE *mapf;                   /* the input file to read from */
 221   int error;
 222   char *mapsrc;
 223   DBM *db = NULL;
 224   static char maptmp[] = "dbmXXXXXX";
 225 #ifdef HAVE_DB_SUFFIX
 226   char maptdb[16];
 227   char *map_name_db = (char *) NULL;
 228 #else /* not HAVE_DB_SUFFIX */
 229   char maptpag[16], maptdir[16];
 230   char *map_name_pag = (char *) NULL, *map_name_dir = (char *) NULL;
 231 #endif /* not HAVE_DB_SUFFIX */
 232   int len;
 233   char *sl;
 234   int printit = 0;
 235   int usage = 0;
 236   int ch;
 237   extern int optind;
 238
 239   /* test options */
 240   while ((ch = getopt(argc, argv, "p")) != -1)
 241     switch (ch) {
 242     case 'p':
 243       printit = 1;
 244       break;
 245     default:
 246       usage++;
 247       break;
 248     }
 249
 250   if (usage || optind != (argc - 1)) {
 251     fputs("Usage: mk-amd-map [-p] file-map\n", stderr);
 252     exit(1);
 253   }
 254   mapsrc = argv[optind];
 255
 256   /* test if can get to the map directory */
 257   sl = strrchr(mapsrc, '/');
 258   if (sl) {
 259     *sl = '\0';
 260     if (chdir(mapsrc) < 0) {
 261       fputs("Can't chdir to ", stderr);
 262       perror(mapsrc);
 263       exit(1);
 264     }
 265     mapsrc = sl + 1;
 266   }
 267
 268   /* open source file */
 269   mapf = fopen(mapsrc, "r");
 270   if (!mapf) {
 271     fprintf(stderr, "cannot open source file ");
 272     perror(mapsrc);
 273     exit(1);
 274   }
 275
 276 #ifndef DEBUG
 277   signal(SIGINT, SIG_IGN);
 278 #endif /* DEBUG */
 279
 280   if (!printit) {
 281     len = strlen(mapsrc);
 282 #ifdef HAVE_DB_SUFFIX
 283     map_name_db = (char *) malloc(len + 4);
 284     error = (map_name_db == NULL);
 285 #else /* not HAVE_DB_SUFFIX */
 286     map_name_pag = (char *) malloc(len + 5);
 287     map_name_dir = (char *) malloc(len + 5);
 288     error = (map_name_pag == NULL || map_name_dir == NULL);
 289 #endif /* not HAVE_DB_SUFFIX */
 290     if (error) {
 291       perror("mk-amd-map: malloc");
 292       exit(1);
 293     }
 294
 295     mktemp(maptmp);
 296
 297     /* remove existing temps (if any) */
 298 #ifdef HAVE_DB_SUFFIX
 299     sprintf(maptdb, "%s.db", maptmp);
 300     if (remove_file(maptdb) < 0) {
 301       fprintf(stderr, "Can't remove existing temporary file; ");
 302       perror(maptdb);
 303       exit(1);
 304     }
 305 #else /* not HAVE_DB_SUFFIX */
 306     sprintf(maptpag, "%s.pag", maptmp);
 307     sprintf(maptdir, "%s.dir", maptmp);
 308     if (remove_file(maptpag) < 0 || remove_file(maptdir) < 0) {
 309       fprintf(stderr, "Can't remove existing temporary files; %s and ", maptpag);
 310       perror(maptdir);
 311       exit(1);
 312     }
 313 #endif /* not HAVE_DB_SUFFIX */
 314
 315     db = dbm_open(maptmp, O_RDWR|O_CREAT, 0444);
 316     if (!db) {
 317       fprintf(stderr, "cannot initialize temporary database: %s", maptmp);
 318       exit(1);
 319     }
 320   }
 321
 322   /* print db to stdout or to temp database */
 323   error = read_file(mapf, mapsrc, db);
 324   fclose(mapf);
 325   if (error) {
 326     if (printit)
 327       fprintf(stderr, "Error reading source file  %s\n", mapsrc);
 328     else
 329       fprintf(stderr, "Error creating database map for %s\n", mapsrc);
 330     exit(1);
 331   }
 332
 333   if (printit)
 334     exit(0);                    /* nothing more to do */
 335
 336   /* if gets here, we wrote to a database */
 337
 338   dbm_close(db);
 339   /* all went well */
 340
 341 #ifdef HAVE_DB_SUFFIX
 342   sprintf(map_name_db, "%s.db", mapsrc);
 343   if (rename(maptdb, map_name_db) < 0) {
 344     fprintf(stderr, "Couldn't rename %s to ", maptdb);
 345     perror(map_name_db);
 346     /* Throw away the temporary map */
 347     unlink(maptdb);
 348     exit(1);
 349   }
 350 #else /* not HAVE_DB_SUFFIX */
 351   sprintf(map_name_pag, "%s.pag", mapsrc);
 352   sprintf(map_name_dir, "%s.dir", mapsrc);
 353   if (rename(maptpag, map_name_pag) < 0) {
 354     fprintf(stderr, "Couldn't rename %s to ", maptpag);
 355     perror(map_name_pag);
 356     /* Throw away the temporary map */
 357     unlink(maptpag);
 358     unlink(maptdir);
 359     exit(1);
 360   }
 361   if (rename(maptdir, map_name_dir) < 0) {
 362     fprintf(stderr, "Couldn't rename %s to ", maptdir);
 363     perror(map_name_dir);
 364     /* remove the (presumably bad) .pag file */
 365     unlink(map_name_pag);
 366     /* throw away remaining part of original map */
 367     unlink(map_name_dir);
 368     /* throw away the temporary map */
 369     unlink(maptdir);
 370     fprintf(stderr, "WARNING: existing map \"%s.{dir,pag}\" destroyed\n",
 371             mapsrc);
 372     exit(1);
 373   }
 374 #endif /* not HAVE_DB_SUFFIX */
 375
 376   exit(0);
 377 }
 378
 379 #else /* not HAVE_MAP_NDBM */
 380
 381 int
 382 main()
 383 {
 384   fputs("mk-amd-map: This system does not support hashed database files\n", stderr);
 385   exit(1);
 386 }
 387
 388 #endif /* not HAVE_MAP_NDBM */