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 */
54char hostname[MAXHOSTNAMELEN];
55int orig_umask, foreground, debug_flags;
56pid_t mypid;
57serv_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
67static int
68store_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 */
83static int
84read_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 */
118static int
119read_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
207static int
208remove_file(char *f)
209{
210 if (unlink(f) < 0 && errno != ENOENT)
211 return -1;
212
213 return 0;
214}
215
216
217int
218main(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
381int
382main()
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 */