Merge branch 'exim-4.96+security'
[exim.git] / src / src / exim_dbmbuild.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
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 uschar * spool_directory = NULL;        /* dummy for hintsdb.h */
36
37 /******************************************************************************/
38                                         /* dummies needed by Solaris build */
39 void
40 millisleep(int msec)
41 {}
42 uschar *
43 readconf_printtime(int t)
44 { return NULL; }
45 void *
46 store_get_3(int size, const void * proto_mem, const char *filename, int linenumber)
47 { return NULL; }
48 void **
49 store_reset_3(void **ptr, const char *filename, int linenumber)
50 { return NULL; }
51 void
52 store_release_above_3(void *ptr, const char *func, int linenumber)
53 { }
54 gstring *
55 string_catn(gstring * g, const uschar * s, int count)
56 { return NULL; }
57 gstring *
58 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
59   unsigned size_limit, unsigned flags, const char *format, va_list ap)
60 { return NULL; }
61 uschar *
62 string_sprintf_trc(const char * a, const uschar * b, unsigned c, ...)
63 { return NULL; }
64 BOOL
65 string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
66   const char * fmt, ...)
67 { return FALSE; }
68 void
69 log_write(unsigned int selector, int flags, const char *format, ...)
70 { }
71
72
73 struct global_flags     f;
74 unsigned int            log_selector[1];
75 uschar *                queue_name;
76 BOOL                    split_spool_directory;
77
78
79 /* These introduced by the taintwarn handling */
80 rmark
81 store_mark_3(const char *func, int linenumber)
82 { return NULL; }
83 #ifdef ALLOW_INSECURE_TAINTED_DATA
84 BOOL    allow_insecure_tainted_data;
85 #endif
86
87 /******************************************************************************/
88
89
90 #define max_insize   20000
91 #define max_outsize 100000
92
93 /* This is global because it's defined in the headers and compilers grumble
94 if it is made static. */
95
96 const uschar *hex_digits = CUS"0123456789abcdef";
97
98
99 #ifdef STRERROR_FROM_ERRLIST
100 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
101 in their libraries, but can provide the same facility by this simple
102 alternative function. */
103
104 char *
105 strerror(int n)
106 {
107 if (n < 0 || n >= sys_nerr) return "unknown error number";
108 return sys_errlist[n];
109 }
110 #endif /* STRERROR_FROM_ERRLIST */
111
112
113
114 /*************************************************
115 *          Interpret escape sequence             *
116 *************************************************/
117
118 /* This function is copied from the main Exim code.
119
120 Arguments:
121   pp       points a pointer to the initiating "\" in the string;
122            the pointer gets updated to point to the final character
123 Returns:   the value of the character escape
124 */
125
126 int
127 string_interpret_escape(const uschar **pp)
128 {
129 int ch;
130 const uschar *p = *pp;
131 ch = *(++p);
132 if (ch == '\0') return **pp;
133 if (isdigit(ch) && ch != '8' && ch != '9')
134   {
135   ch -= '0';
136   if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
137     {
138     ch = ch * 8 + *(++p) - '0';
139     if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
140       ch = ch * 8 + *(++p) - '0';
141     }
142   }
143 else switch(ch)
144   {
145   case 'n':  ch = '\n'; break;
146   case 'r':  ch = '\r'; break;
147   case 't':  ch = '\t'; break;
148   case 'x':
149   ch = 0;
150   if (isxdigit(p[1]))
151     {
152     ch = ch * 16 +
153       Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
154     if (isxdigit(p[1])) ch = ch * 16 +
155       Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
156     }
157   break;
158   }
159 *pp = p;
160 return ch;
161 }
162
163
164 /*************************************************
165 *               Main Program                     *
166 *************************************************/
167
168 int main(int argc, char **argv)
169 {
170 int started;
171 int count = 0;
172 int dupcount = 0;
173 int yield = 0;
174 int arg = 1;
175 int add_zero = 1;
176 BOOL lowercase = TRUE;
177 BOOL warn = TRUE;
178 BOOL duperr = TRUE;
179 BOOL lastdup = FALSE;
180 #if !defined (USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
181 int is_db = 0;
182 struct stat statbuf;
183 #endif
184 FILE *f;
185 EXIM_DB *d;
186 EXIM_DATUM key, content;
187 uschar *bptr;
188 uschar  keybuffer[256];
189 uschar  temp_dbmname[512];
190 uschar  real_dbmname[512];
191 uschar  dirname[512];
192 uschar *buffer = malloc(max_outsize);
193 uschar *line = malloc(max_insize);
194
195 while (argc > 1)
196   {
197   if      (Ustrcmp(argv[arg], "-nolc") == 0)     lowercase = FALSE;
198   else if (Ustrcmp(argv[arg], "-nowarn") == 0)   warn = FALSE;
199   else if (Ustrcmp(argv[arg], "-lastdup") == 0)  lastdup = TRUE;
200   else if (Ustrcmp(argv[arg], "-noduperr") == 0) duperr = FALSE;
201   else if (Ustrcmp(argv[arg], "-nozero") == 0)   add_zero = 0;
202   else break;
203   arg++;
204   argc--;
205   }
206
207 if (argc != 3)
208   {
209   printf("usage: exim_dbmbuild [-nolc] <source file> <dbm base name>\n");
210   exit(1);
211   }
212
213 if (Ustrcmp(argv[arg], "-") == 0)
214   f = stdin;
215 else if (!(f = fopen(argv[arg], "rb")))
216   {
217   printf("exim_dbmbuild: unable to open %s: %s\n", argv[arg], strerror(errno));
218   exit(1);
219   }
220
221 /* By default Berkeley db does not put extensions on... which
222 can be painful! */
223
224 #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
225 if (Ustrcmp(argv[arg], argv[arg+1]) == 0)
226   {
227   printf("exim_dbmbuild: input and output filenames are the same\n");
228   exit(1);
229   }
230 #endif
231
232 /* Check length of filename; allow for adding .dbmbuild_temp and .db or
233 .dir/.pag later. */
234
235 if (strlen(argv[arg+1]) > sizeof(temp_dbmname) - 20)
236   {
237   printf("exim_dbmbuild: output filename is ridiculously long\n");
238   exit(1);
239   }
240
241 Ustrcpy(temp_dbmname, US argv[arg+1]);
242 Ustrcat(temp_dbmname, US".dbmbuild_temp");
243
244 Ustrcpy(dirname, temp_dbmname);
245 if ((bptr = Ustrrchr(dirname, '/')))
246   *bptr = '\0';
247 else
248   Ustrcpy(dirname, US".");
249
250 /* It is apparently necessary to open with O_RDWR for this to work
251 with gdbm-1.7.3, though no reading is actually going to be done. */
252
253 if (!(d = exim_dbopen(temp_dbmname, dirname, O_RDWR|O_CREAT|O_EXCL, 0644)))
254   {
255   printf("exim_dbmbuild: unable to create %s: %s\n", temp_dbmname,
256     strerror(errno));
257   (void)fclose(f);
258   exit(1);
259   }
260
261 /* Unless using native db calls, see if we have created <name>.db; if not,
262 assume .dir & .pag */
263
264 #if !defined(USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
265 sprintf(CS real_dbmname, "%s.db", temp_dbmname);
266 is_db = Ustat(real_dbmname, &statbuf) == 0;
267 #endif
268
269 /* Now do the business */
270
271 bptr = buffer;
272 started = 0;
273
274 while (Ufgets(line, max_insize, f) != NULL)
275   {
276   uschar *p;
277   int len = Ustrlen(line);
278
279   p = line + len;
280
281   if (len >= max_insize - 1 && p[-1] != '\n')
282     {
283     printf("Overlong line read: max permitted length is %d\n", max_insize - 1);
284     yield = 2;
285     goto TIDYUP;
286     }
287
288   if (line[0] == '#') continue;
289   while (p > line && isspace(p[-1])) p--;
290   *p = 0;
291   if (line[0] == 0) continue;
292
293   /* A continuation line is valid only if there was a previous first
294   line. */
295
296   if (isspace(line[0]))
297     {
298     uschar *s = line;
299     if (!started)
300       {
301       printf("Unexpected continuation line ignored\n%s\n\n", line);
302       continue;
303       }
304     while (isspace(*s)) s++;
305     *(--s) = ' ';
306
307     if (bptr - buffer + p - s >= max_outsize - 1)
308       {
309       printf("Continued set of lines is too long: max permitted length is %d\n",
310         max_outsize -1);
311       yield = 2;
312       goto TIDYUP;
313       }
314
315     Ustrcpy(bptr, s);
316     bptr += p - s;
317     }
318
319   /* A first line must have a name followed by a colon or whitespace or
320   end of line, but first finish with a previous line. The key is lower
321   cased by default - this is what the newaliases program for sendmail does.
322   However, there's an option not to do this. */
323
324   else
325     {
326     int i, rc;
327     uschar *s = line;
328     uschar *keystart;
329
330     if (started)
331       {
332       exim_datum_init(&content);
333       exim_datum_data_set(&content, buffer);
334       exim_datum_size_set(&content, bptr - buffer + add_zero);
335
336       switch(rc = exim_dbputb(d, &key, &content))
337         {
338         case EXIM_DBPUTB_OK:
339           count++;
340           break;
341
342         case EXIM_DBPUTB_DUP:
343           if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n", keybuffer);
344           dupcount++;
345           if(duperr) yield = 1;
346           if (lastdup) exim_dbput(d, &key, &content);
347           break;
348
349         default:
350           fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
351             keybuffer, errno);
352           yield = 2;
353           goto TIDYUP;
354         }
355
356       bptr = buffer;
357       }
358
359     exim_datum_init(&key);
360     exim_datum_data_set(&key, keybuffer);
361
362     /* Deal with quoted keys. Escape sequences always make one character
363     out of several, so we can re-build in place. */
364
365     if (*s == '\"')
366       {
367       uschar *t = s++;
368       keystart = t;
369       while (*s != 0 && *s != '\"')
370         {
371         *t++ = *s == '\\'
372         ? string_interpret_escape((const uschar **)&s)
373         : *s;
374         s++;
375         }
376       if (*s != 0) s++;               /* Past terminating " */
377       exim_datum_size_set(&key, t - keystart + add_zero);
378       }
379     else
380       {
381       keystart = s;
382       while (*s != 0 && *s != ':' && !isspace(*s)) s++;
383       exim_datum_size_set(&key, s - keystart + add_zero);
384       }
385
386     if (exim_datum_size_get(&key) > 256)
387       {
388       printf("Keys longer than 255 characters cannot be handled\n");
389       started = 0;
390       yield = 2;
391       goto TIDYUP;
392       }
393
394     if (lowercase)
395       for (i = 0; i < exim_datum_size_get(&key) - add_zero; i++)
396         keybuffer[i] = tolower(keystart[i]);
397     else
398       for (i = 0; i < exim_datum_size_get(&key) - add_zero; i++)
399         keybuffer[i] = keystart[i];
400
401     keybuffer[i] = 0;
402     started = 1;
403
404     while (isspace(*s))s++;
405     if (*s == ':')
406       {
407       s++;
408       while (isspace(*s))s++;
409       }
410     if (*s != 0)
411       {
412       Ustrcpy(bptr, s);
413       bptr += p - s;
414       }
415     else buffer[0] = 0;
416     }
417   }
418
419 if (started)
420   {
421   int rc;
422   exim_datum_init(&content);
423   exim_datum_data_set(&content, buffer);
424   exim_datum_size_set(&content, bptr - buffer + add_zero);
425
426   switch(rc = exim_dbputb(d, &key, &content))
427     {
428     case EXIM_DBPUTB_OK:
429     count++;
430     break;
431
432     case EXIM_DBPUTB_DUP:
433     if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n", keybuffer);
434     dupcount++;
435     if (duperr) yield = 1;
436     if (lastdup) exim_dbput(d, &key, &content);
437     break;
438
439     default:
440     fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
441       keybuffer, errno);
442     yield = 2;
443     break;
444     }
445   }
446
447 /* Close files, rename or abandon the temporary files, and exit */
448
449 TIDYUP:
450
451 exim_dbclose(d);
452 (void)fclose(f);
453
454 /* If successful, output the number of entries and rename the temporary
455 files. */
456
457 if (yield == 0 || yield == 1)
458   {
459   printf("%d entr%s written\n", count, (count == 1)? "y" : "ies");
460   if (dupcount > 0)
461     {
462     printf("%d duplicate key%s \n", dupcount, (dupcount > 1)? "s" : "");
463     }
464
465   #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
466   Ustrcpy(real_dbmname, temp_dbmname);
467   Ustrcpy(buffer, US 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   #else
474
475   /* Rename a single .db file */
476
477   if (is_db)
478     {
479     sprintf(CS real_dbmname, "%s.db", temp_dbmname);
480     sprintf(CS buffer, "%s.db", argv[arg+1]);
481     if (Urename(real_dbmname, buffer) != 0)
482       {
483       printf("Unable to rename %s as %s\n", real_dbmname, buffer);
484       return 1;
485       }
486     }
487
488   /* Rename .dir and .pag files */
489
490   else
491     {
492     sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
493     sprintf(CS buffer, "%s.dir", argv[arg+1]);
494     if (Urename(real_dbmname, buffer) != 0)
495       {
496       printf("Unable to rename %s as %s\n", real_dbmname, buffer);
497       return 1;
498       }
499
500     sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
501     sprintf(CS buffer, "%s.pag", argv[arg+1]);
502     if (Urename(real_dbmname, buffer) != 0)
503       {
504       printf("Unable to rename %s as %s\n", real_dbmname, buffer);
505       return 1;
506       }
507     }
508
509   #endif /* USE_DB || USE_TDB || USE_GDBM */
510   }
511
512 /* Otherwise unlink the temporary files. */
513
514 else
515   {
516   printf("dbmbuild abandoned\n");
517 #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
518   /* We created it, so safe to delete despite the name coming from outside */
519   /* coverity[tainted_string] */
520   Uunlink(temp_dbmname);
521 #else
522   if (is_db)
523     {
524     sprintf(CS real_dbmname, "%s.db", temp_dbmname);
525     Uunlink(real_dbmname);
526     }
527   else
528     {
529     sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
530     Uunlink(real_dbmname);
531     sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
532     Uunlink(real_dbmname);
533     }
534 #endif /* USE_DB || USE_TDB */
535   }
536
537 return yield;
538 }
539
540 /* End of exim_dbmbuild.c */