4ff724cdcf6a05746be2f7ba11c9f60fbb4d6eac
[exim.git] / src / src / exim_dbmbuild.c
1 /* $Cambridge: exim/src/src/exim_dbmbuild.c,v 1.9 2009/11/16 19:50:36 nm4 Exp $ */
2
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 /* A small freestanding program to build dbm databases from serial input. For
12 alias files, this program fulfils the function of the newaliases program used
13 by other mailers, but it can be used for other dbm data files too. It operates
14 by writing a new file or files, and then renaming; otherwise old entries can
15 never get flushed out.
16
17 This program is clever enough to cope with ndbm, which creates two files called
18 <name>.dir and <name>.pag, or with db, which creates a single file called
19 <name>.db. If native db is in use (USE_DB defined) or tdb is in use (USE_TDB
20 defined) there is no extension to the output filename. This is also handled. If
21 there are any other variants, the program won't cope.
22
23 The first argument to the program is the name of the serial file; the second
24 is the base name for the DBM file(s). When native db is in use, these must be
25 different.
26
27 Input lines beginning with # are ignored, as are blank lines. Entries begin
28 with a key terminated by a colon or end of line or whitespace and continue with
29 indented lines. Keys may be quoted if they contain colons or whitespace or #
30 characters. */
31
32
33 #include "exim.h"
34
35
36 #define max_insize 20000
37 #define max_outsize 100000
38
39 /* This is global because it's defined in the headers and compilers grumble
40 if it is made static. */
41
42 uschar *hex_digits = US"0123456789abcdef";
43
44
45 #ifdef STRERROR_FROM_ERRLIST
46 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
47 in their libraries, but can provide the same facility by this simple
48 alternative function. */
49
50 char *
51 strerror(int n)
52 {
53 if (n < 0 || n >= sys_nerr) return "unknown error number";
54 return sys_errlist[n];
55 }
56 #endif /* STRERROR_FROM_ERRLIST */
57
58
59 /* For Berkeley DB >= 2, we can define a function to be called in case of DB
60 errors. This should help with debugging strange DB problems, e.g. getting "File
61 exists" when you try to open a db file. The API changed at release 4.3. */
62
63 #if defined(USE_DB) && defined(DB_VERSION_STRING)
64 void
65 #if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
66 dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
67 {
68 dbenv = dbenv;
69 #else
70 dbfn_bdb_error_callback(const char *pfx, char *msg)
71 {
72 #endif
73 pfx = pfx;
74 printf("Berkeley DB error: %s\n", msg);
75 }
76 #endif
77
78
79
80 /*************************************************
81 * Interpret escape sequence *
82 *************************************************/
83
84 /* This function is copied from the main Exim code.
85
86 Arguments:
87 pp points a pointer to the initiating "\" in the string;
88 the pointer gets updated to point to the final character
89 Returns: the value of the character escape
90 */
91
92 int
93 string_interpret_escape(uschar **pp)
94 {
95 int ch;
96 uschar *p = *pp;
97 ch = *(++p);
98 if (isdigit(ch) && ch != '8' && ch != '9')
99 {
100 ch -= '0';
101 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
102 {
103 ch = ch * 8 + *(++p) - '0';
104 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
105 ch = ch * 8 + *(++p) - '0';
106 }
107 }
108 else switch(ch)
109 {
110 case 'n': ch = '\n'; break;
111 case 'r': ch = '\r'; break;
112 case 't': ch = '\t'; break;
113 case 'x':
114 ch = 0;
115 if (isxdigit(p[1]))
116 {
117 ch = ch * 16 +
118 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
119 if (isxdigit(p[1])) ch = ch * 16 +
120 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
121 }
122 break;
123 }
124 *pp = p;
125 return ch;
126 }
127
128
129 /*************************************************
130 * Main Program *
131 *************************************************/
132
133 int main(int argc, char **argv)
134 {
135 int started;
136 int count = 0;
137 int dupcount = 0;
138 int yield = 0;
139 int arg = 1;
140 int add_zero = 1;
141 BOOL lowercase = TRUE;
142 BOOL warn = TRUE;
143 BOOL duperr = TRUE;
144 BOOL lastdup = FALSE;
145 #if !defined (USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
146 int is_db = 0;
147 struct stat statbuf;
148 #endif
149 FILE *f;
150 EXIM_DB *d;
151 EXIM_DATUM key, content;
152 uschar *bptr;
153 uschar keybuffer[256];
154 uschar temp_dbmname[512];
155 uschar real_dbmname[512];
156 uschar *buffer = malloc(max_outsize);
157 uschar *line = malloc(max_insize);
158
159 while (argc > 1)
160 {
161 if (Ustrcmp(argv[arg], "-nolc") == 0) lowercase = FALSE;
162 else if (Ustrcmp(argv[arg], "-nowarn") == 0) warn = FALSE;
163 else if (Ustrcmp(argv[arg], "-lastdup") == 0) lastdup = TRUE;
164 else if (Ustrcmp(argv[arg], "-noduperr") == 0) duperr = FALSE;
165 else if (Ustrcmp(argv[arg], "-nozero") == 0) add_zero = 0;
166 else break;
167 arg++;
168 argc--;
169 }
170
171 if (argc != 3)
172 {
173 printf("usage: exim_dbmbuild [-nolc] <source file> <dbm base name>\n");
174 exit(1);
175 }
176
177 if (Ustrcmp(argv[arg], "-") == 0) f = stdin; else
178 {
179 f = fopen(argv[arg], "rb");
180 if (f == NULL)
181 {
182 printf("exim_dbmbuild: unable to open %s: %s\n", argv[arg], strerror(errno));
183 exit(1);
184 }
185 }
186
187 /* By default Berkeley db does not put extensions on... which
188 can be painful! */
189
190 #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
191 if (Ustrcmp(argv[arg], argv[arg+1]) == 0)
192 {
193 printf("exim_dbmbuild: input and output filenames are the same\n");
194 exit(1);
195 }
196 #endif
197
198 /* Check length of filename; allow for adding .dbmbuild_temp and .db or
199 .dir/.pag later. */
200
201 if (strlen(argv[arg+1]) > sizeof(temp_dbmname) - 20)
202 {
203 printf("exim_dbmbuild: output filename is ridiculously long\n");
204 exit(1);
205 }
206
207 Ustrcpy(temp_dbmname, argv[arg+1]);
208 Ustrcat(temp_dbmname, ".dbmbuild_temp");
209
210 /* It is apparently necessary to open with O_RDWR for this to work
211 with gdbm-1.7.3, though no reading is actually going to be done. */
212
213 EXIM_DBOPEN(temp_dbmname, O_RDWR|O_CREAT|O_EXCL, 0644, &d);
214
215 if (d == NULL)
216 {
217 printf("exim_dbmbuild: unable to create %s: %s\n", temp_dbmname,
218 strerror(errno));
219 (void)fclose(f);
220 exit(1);
221 }
222
223 /* Unless using native db calls, see if we have created <name>.db; if not,
224 assume .dir & .pag */
225
226 #if !defined(USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
227 sprintf(CS real_dbmname, "%s.db", temp_dbmname);
228 is_db = Ustat(real_dbmname, &statbuf) == 0;
229 #endif
230
231 /* Now do the business */
232
233 bptr = buffer;
234 started = 0;
235
236 while (Ufgets(line, max_insize, f) != NULL)
237 {
238 uschar *p;
239 int len = Ustrlen(line);
240
241 p = line + len;
242
243 if (len >= max_insize - 1 && p[-1] != '\n')
244 {
245 printf("Overlong line read: max permitted length is %d\n", max_insize - 1);
246 yield = 2;
247 goto TIDYUP;
248 }
249
250 if (line[0] == '#') continue;
251 while (p > line && isspace(p[-1])) p--;
252 *p = 0;
253 if (line[0] == 0) continue;
254
255 /* A continuation line is valid only if there was a previous first
256 line. */
257
258 if (isspace(line[0]))
259 {
260 uschar *s = line;
261 if (!started)
262 {
263 printf("Unexpected continuation line ignored\n%s\n\n", line);
264 continue;
265 }
266 while (isspace(*s)) s++;
267 *(--s) = ' ';
268
269 if (bptr - buffer + p - s >= max_outsize - 1)
270 {
271 printf("Continued set of lines is too long: max permitted length is %d\n",
272 max_outsize -1);
273 yield = 2;
274 goto TIDYUP;
275 }
276
277 Ustrcpy(bptr, s);
278 bptr += p - s;
279 }
280
281 /* A first line must have a name followed by a colon or whitespace or
282 end of line, but first finish with a previous line. The key is lower
283 cased by default - this is what the newaliases program for sendmail does.
284 However, there's an option not to do this. */
285
286 else
287 {
288 int i, rc;
289 uschar *s = line;
290 uschar *keystart;
291
292 if (started)
293 {
294 EXIM_DATUM_INIT(content);
295 EXIM_DATUM_DATA(content) = CS buffer;
296 EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;
297
298 switch(rc = EXIM_DBPUTB(d, key, content))
299 {
300 case EXIM_DBPUTB_OK:
301 count++;
302 break;
303
304 case EXIM_DBPUTB_DUP:
305 if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n",
306 keybuffer);
307 dupcount++;
308 if(duperr) yield = 1;
309 if (lastdup) EXIM_DBPUT(d, key, content);
310 break;
311
312 default:
313 fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
314 keybuffer, errno);
315 yield = 2;
316 goto TIDYUP;
317 }
318
319 bptr = buffer;
320 }
321
322 EXIM_DATUM_INIT(key);
323 EXIM_DATUM_DATA(key) = CS keybuffer;
324
325 /* Deal with quoted keys. Escape sequences always make one character
326 out of several, so we can re-build in place. */
327
328 if (*s == '\"')
329 {
330 uschar *t = s++;
331 keystart = t;
332 while (*s != 0 && *s != '\"')
333 {
334 if (*s == '\\') *t++ = string_interpret_escape(&s);
335 else *t++ = *s;
336 s++;
337 }
338 if (*s != 0) s++; /* Past terminating " */
339 EXIM_DATUM_SIZE(key) = t - keystart + add_zero;
340 }
341 else
342 {
343 keystart = s;
344 while (*s != 0 && *s != ':' && !isspace(*s)) s++;
345 EXIM_DATUM_SIZE(key) = s - keystart + add_zero;
346 }
347
348 if (EXIM_DATUM_SIZE(key) > 256)
349 {
350 printf("Keys longer than 255 characters cannot be handled\n");
351 started = 0;
352 yield = 2;
353 goto TIDYUP;
354 }
355
356 if (lowercase)
357 {
358 for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
359 keybuffer[i] = tolower(keystart[i]);
360 }
361 else
362 {
363 for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
364 keybuffer[i] = keystart[i];
365 }
366
367 keybuffer[i] = 0;
368 started = 1;
369
370 while (isspace(*s))s++;
371 if (*s == ':')
372 {
373 s++;
374 while (isspace(*s))s++;
375 }
376 if (*s != 0)
377 {
378 Ustrcpy(bptr, s);
379 bptr += p - s;
380 }
381 else buffer[0] = 0;
382 }
383 }
384
385 if (started)
386 {
387 int rc;
388 EXIM_DATUM_INIT(content);
389 EXIM_DATUM_DATA(content) = CS buffer;
390 EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;
391
392 switch(rc = EXIM_DBPUTB(d, key, content))
393 {
394 case EXIM_DBPUTB_OK:
395 count++;
396 break;
397
398 case EXIM_DBPUTB_DUP:
399 if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n", keybuffer);
400 dupcount++;
401 if (duperr) yield = 1;
402 if (lastdup) EXIM_DBPUT(d, key, content);
403 break;
404
405 default:
406 fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
407 keybuffer, errno);
408 yield = 2;
409 break;
410 }
411 }
412
413 /* Close files, rename or abandon the temporary files, and exit */
414
415 TIDYUP:
416
417 EXIM_DBCLOSE(d);
418 (void)fclose(f);
419
420 /* If successful, output the number of entries and rename the temporary
421 files. */
422
423 if (yield == 0 || yield == 1)
424 {
425 printf("%d entr%s written\n", count, (count == 1)? "y" : "ies");
426 if (dupcount > 0)
427 {
428 printf("%d duplicate key%s \n", dupcount, (dupcount > 1)? "s" : "");
429 }
430
431 #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
432 Ustrcpy(real_dbmname, temp_dbmname);
433 Ustrcpy(buffer, argv[arg+1]);
434 if (Urename(real_dbmname, buffer) != 0)
435 {
436 printf("Unable to rename %s as %s\n", real_dbmname, buffer);
437 return 1;
438 }
439 #else
440
441 /* Rename a single .db file */
442
443 if (is_db)
444 {
445 sprintf(CS real_dbmname, "%s.db", temp_dbmname);
446 sprintf(CS buffer, "%s.db", argv[arg+1]);
447 if (Urename(real_dbmname, buffer) != 0)
448 {
449 printf("Unable to rename %s as %s\n", real_dbmname, buffer);
450 return 1;
451 }
452 }
453
454 /* Rename .dir and .pag files */
455
456 else
457 {
458 sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
459 sprintf(CS buffer, "%s.dir", argv[arg+1]);
460 if (Urename(real_dbmname, buffer) != 0)
461 {
462 printf("Unable to rename %s as %s\n", real_dbmname, buffer);
463 return 1;
464 }
465
466 sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
467 sprintf(CS buffer, "%s.pag", argv[arg+1]);
468 if (Urename(real_dbmname, buffer) != 0)
469 {
470 printf("Unable to rename %s as %s\n", real_dbmname, buffer);
471 return 1;
472 }
473 }
474
475 #endif /* USE_DB || USE_TDB || USE_GDBM */
476 }
477
478 /* Otherwise unlink the temporary files. */
479
480 else
481 {
482 printf("dbmbuild abandoned\n");
483 #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
484 Uunlink(temp_dbmname);
485 #else
486 if (is_db)
487 {
488 sprintf(CS real_dbmname, "%s.db", temp_dbmname);
489 Uunlink(real_dbmname);
490 }
491 else
492 {
493 sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
494 Uunlink(real_dbmname);
495 sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
496 Uunlink(real_dbmname);
497 }
498 #endif /* USE_DB || USE_TDB */
499 }
500
501 return yield;
502 }
503
504 /* End of exim_dbmbuild.c */