[hcoop/debian/exim4.git] / src / exim_dbmbuild.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2018 */
/* See the file NOTICE for conditions of use and distribution. */


/* A small freestanding program to build dbm databases from serial input. For
alias files, this program fulfils the function of the newaliases program used
by other mailers, but it can be used for other dbm data files too. It operates
by writing a new file or files, and then renaming; otherwise old entries can
never get flushed out.

This program is clever enough to cope with ndbm, which creates two files called
<name>.dir and <name>.pag, or with db, which creates a single file called
<name>.db. If native db is in use (USE_DB defined) or tdb is in use (USE_TDB
defined) there is no extension to the output filename. This is also handled. If
there are any other variants, the program won't cope.

The first argument to the program is the name of the serial file; the second
is the base name for the DBM file(s). When native db is in use, these must be
different.

Input lines beginning with # are ignored, as are blank lines. Entries begin
with a key terminated by a colon or end of line or whitespace and continue with
indented lines. Keys may be quoted if they contain colons or whitespace or #
characters. */


#include "exim.h"

uschar * spool_directory = NULL;	/* dummy for dbstuff.h */

#define max_insize   20000
#define max_outsize 100000

/* This is global because it's defined in the headers and compilers grumble
if it is made static. */

const uschar *hex_digits = CUS"0123456789abcdef";


#ifdef STRERROR_FROM_ERRLIST
/* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
in their libraries, but can provide the same facility by this simple
alternative function. */

char *
strerror(int n)
{
if (n < 0 || n >= sys_nerr) return "unknown error number";
return sys_errlist[n];
}
#endif /* STRERROR_FROM_ERRLIST */


/* For Berkeley DB >= 2, we can define a function to be called in case of DB
errors. This should help with debugging strange DB problems, e.g. getting "File
exists" when you try to open a db file. The API changed at release 4.3. */

#if defined(USE_DB) && defined(DB_VERSION_STRING)
void
#if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
dbfn_bdb_error_callback(const DB_ENV *dbenv, const char *pfx, const char *msg)
{
dbenv = dbenv;
#else
dbfn_bdb_error_callback(const char *pfx, char *msg)
{
#endif
pfx = pfx;
printf("Berkeley DB error: %s\n", msg);
}
#endif


/*************************************************
*          Interpret escape sequence             *
*************************************************/

/* This function is copied from the main Exim code.

Arguments:
  pp       points a pointer to the initiating "\" in the string;
           the pointer gets updated to point to the final character
Returns:   the value of the character escape
*/

int
string_interpret_escape(const uschar **pp)
{
int ch;
const uschar *p = *pp;
ch = *(++p);
if (isdigit(ch) && ch != '8' && ch != '9')
  {
  ch -= '0';
  if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
    {
    ch = ch * 8 + *(++p) - '0';
    if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
      ch = ch * 8 + *(++p) - '0';
    }
  }
else switch(ch)
  {
  case 'n':  ch = '\n'; break;
  case 'r':  ch = '\r'; break;
  case 't':  ch = '\t'; break;
  case 'x':
  ch = 0;
  if (isxdigit(p[1]))
    {
    ch = ch * 16 +
      Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
    if (isxdigit(p[1])) ch = ch * 16 +
      Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
    }
  break;
  }
*pp = p;
return ch;
}


/*************************************************
*               Main Program                     *
*************************************************/

int main(int argc, char **argv)
{
int started;
int count = 0;
int dupcount = 0;
int yield = 0;
int arg = 1;
int add_zero = 1;
BOOL lowercase = TRUE;
BOOL warn = TRUE;
BOOL duperr = TRUE;
BOOL lastdup = FALSE;
#if !defined (USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
int is_db = 0;
struct stat statbuf;
#endif
FILE *f;
EXIM_DB *d;
EXIM_DATUM key, content;
uschar *bptr;
uschar  keybuffer[256];
uschar  temp_dbmname[512];
uschar  real_dbmname[512];
uschar  dirname[512];
uschar *buffer = malloc(max_outsize);
uschar *line = malloc(max_insize);

while (argc > 1)
  {
  if      (Ustrcmp(argv[arg], "-nolc") == 0)     lowercase = FALSE;
  else if (Ustrcmp(argv[arg], "-nowarn") == 0)   warn = FALSE;
  else if (Ustrcmp(argv[arg], "-lastdup") == 0)  lastdup = TRUE;
  else if (Ustrcmp(argv[arg], "-noduperr") == 0) duperr = FALSE;
  else if (Ustrcmp(argv[arg], "-nozero") == 0)   add_zero = 0;
  else break;
  arg++;
  argc--;
  }

if (argc != 3)
  {
  printf("usage: exim_dbmbuild [-nolc] <source file> <dbm base name>\n");
  exit(1);
  }

if (Ustrcmp(argv[arg], "-") == 0) f = stdin; else
  {
  f = fopen(argv[arg], "rb");
  if (f == NULL)
    {
    printf("exim_dbmbuild: unable to open %s: %s\n", argv[arg], strerror(errno));
    exit(1);
    }
  }

/* By default Berkeley db does not put extensions on... which
can be painful! */

#if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
if (Ustrcmp(argv[arg], argv[arg+1]) == 0)
  {
  printf("exim_dbmbuild: input and output filenames are the same\n");
  exit(1);
  }
#endif

/* Check length of filename; allow for adding .dbmbuild_temp and .db or
.dir/.pag later. */

if (strlen(argv[arg+1]) > sizeof(temp_dbmname) - 20)
  {
  printf("exim_dbmbuild: output filename is ridiculously long\n");
  exit(1);
  }

Ustrcpy(temp_dbmname, argv[arg+1]);
Ustrcat(temp_dbmname, ".dbmbuild_temp");

Ustrcpy(dirname, temp_dbmname);
if ((bptr = Ustrrchr(dirname, '/')))
  *bptr = '\0';
else
  Ustrcpy(dirname, ".");

/* It is apparently necessary to open with O_RDWR for this to work
with gdbm-1.7.3, though no reading is actually going to be done. */

EXIM_DBOPEN(temp_dbmname, dirname, O_RDWR|O_CREAT|O_EXCL, 0644, &d);

if (d == NULL)
  {
  printf("exim_dbmbuild: unable to create %s: %s\n", temp_dbmname,
    strerror(errno));
  (void)fclose(f);
  exit(1);
  }

/* Unless using native db calls, see if we have created <name>.db; if not,
assume .dir & .pag */

#if !defined(USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
sprintf(CS real_dbmname, "%s.db", temp_dbmname);
is_db = Ustat(real_dbmname, &statbuf) == 0;
#endif

/* Now do the business */

bptr = buffer;
started = 0;

while (Ufgets(line, max_insize, f) != NULL)
  {
  uschar *p;
  int len = Ustrlen(line);

  p = line + len;

  if (len >= max_insize - 1 && p[-1] != '\n')
    {
    printf("Overlong line read: max permitted length is %d\n", max_insize - 1);
    yield = 2;
    goto TIDYUP;
    }

  if (line[0] == '#') continue;
  while (p > line && isspace(p[-1])) p--;
  *p = 0;
  if (line[0] == 0) continue;

  /* A continuation line is valid only if there was a previous first
  line. */

  if (isspace(line[0]))
    {
    uschar *s = line;
    if (!started)
      {
      printf("Unexpected continuation line ignored\n%s\n\n", line);
      continue;
      }
    while (isspace(*s)) s++;
    *(--s) = ' ';

    if (bptr - buffer + p - s >= max_outsize - 1)
      {
      printf("Continued set of lines is too long: max permitted length is %d\n",
        max_outsize -1);
      yield = 2;
      goto TIDYUP;
      }

    Ustrcpy(bptr, s);
    bptr += p - s;
    }

  /* A first line must have a name followed by a colon or whitespace or
  end of line, but first finish with a previous line. The key is lower
  cased by default - this is what the newaliases program for sendmail does.
  However, there's an option not to do this. */

  else
    {
    int i, rc;
    uschar *s = line;
    uschar *keystart;

    if (started)
      {
      EXIM_DATUM_INIT(content);
      EXIM_DATUM_DATA(content) = CS buffer;
      EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;

      switch(rc = EXIM_DBPUTB(d, key, content))
        {
        case EXIM_DBPUTB_OK:
        count++;
        break;

        case EXIM_DBPUTB_DUP:
        if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n",
          keybuffer);
        dupcount++;
        if(duperr) yield = 1;
        if (lastdup) EXIM_DBPUT(d, key, content);
        break;

        default:
        fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
          keybuffer, errno);
        yield = 2;
        goto TIDYUP;
        }

      bptr = buffer;
      }

    EXIM_DATUM_INIT(key);
    EXIM_DATUM_DATA(key) = CS keybuffer;

    /* Deal with quoted keys. Escape sequences always make one character
    out of several, so we can re-build in place. */

    if (*s == '\"')
      {
      uschar *t = s++;
      keystart = t;
      while (*s != 0 && *s != '\"')
        {
        if (*s == '\\') *t++ = string_interpret_escape((const uschar **)&s);
          else *t++ = *s;
        s++;
        }
      if (*s != 0) s++;               /* Past terminating " */
      EXIM_DATUM_SIZE(key) = t - keystart + add_zero;
      }
    else
      {
      keystart = s;
      while (*s != 0 && *s != ':' && !isspace(*s)) s++;
      EXIM_DATUM_SIZE(key) = s - keystart + add_zero;
      }

    if (EXIM_DATUM_SIZE(key) > 256)
      {
      printf("Keys longer than 255 characters cannot be handled\n");
      started = 0;
      yield = 2;
      goto TIDYUP;
      }

    if (lowercase)
      {
      for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
        keybuffer[i] = tolower(keystart[i]);
      }
    else
      {
      for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
        keybuffer[i] = keystart[i];
      }

    keybuffer[i] = 0;
    started = 1;

    while (isspace(*s))s++;
    if (*s == ':')
      {
      s++;
      while (isspace(*s))s++;
      }
    if (*s != 0)
      {
      Ustrcpy(bptr, s);
      bptr += p - s;
      }
    else buffer[0] = 0;
    }
  }

if (started)
  {
  int rc;
  EXIM_DATUM_INIT(content);
  EXIM_DATUM_DATA(content) = CS buffer;
  EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;

  switch(rc = EXIM_DBPUTB(d, key, content))
    {
    case EXIM_DBPUTB_OK:
    count++;
    break;

    case EXIM_DBPUTB_DUP:
    if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n", keybuffer);
    dupcount++;
    if (duperr) yield = 1;
    if (lastdup) EXIM_DBPUT(d, key, content);
    break;

    default:
    fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
      keybuffer, errno);
    yield = 2;
    break;
    }
  }

/* Close files, rename or abandon the temporary files, and exit */

TIDYUP:

EXIM_DBCLOSE(d);
(void)fclose(f);

/* If successful, output the number of entries and rename the temporary
files. */

if (yield == 0 || yield == 1)
  {
  printf("%d entr%s written\n", count, (count == 1)? "y" : "ies");
  if (dupcount > 0)
    {
    printf("%d duplicate key%s \n", dupcount, (dupcount > 1)? "s" : "");
    }

  #if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
  Ustrcpy(real_dbmname, temp_dbmname);
  Ustrcpy(buffer, argv[arg+1]);
  if (Urename(real_dbmname, buffer) != 0)
    {
    printf("Unable to rename %s as %s\n", real_dbmname, buffer);
    return 1;
    }
  #else

  /* Rename a single .db file */

  if (is_db)
    {
    sprintf(CS real_dbmname, "%s.db", temp_dbmname);
    sprintf(CS buffer, "%s.db", argv[arg+1]);
    if (Urename(real_dbmname, buffer) != 0)
      {
      printf("Unable to rename %s as %s\n", real_dbmname, buffer);
      return 1;
      }
    }

  /* Rename .dir and .pag files */

  else
    {
    sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
    sprintf(CS buffer, "%s.dir", argv[arg+1]);
    if (Urename(real_dbmname, buffer) != 0)
      {
      printf("Unable to rename %s as %s\n", real_dbmname, buffer);
      return 1;
      }

    sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
    sprintf(CS buffer, "%s.pag", argv[arg+1]);
    if (Urename(real_dbmname, buffer) != 0)
      {
      printf("Unable to rename %s as %s\n", real_dbmname, buffer);
      return 1;
      }
    }

  #endif /* USE_DB || USE_TDB || USE_GDBM */
  }

/* Otherwise unlink the temporary files. */

else
  {
  printf("dbmbuild abandoned\n");
#if defined(USE_DB) || defined(USE_TDB) || defined(USE_GDBM)
  /* We created it, so safe to delete despite the name coming from outside */
  /* coverity[tainted_string] */
  Uunlink(temp_dbmname);
#else
  if (is_db)
    {
    sprintf(CS real_dbmname, "%s.db", temp_dbmname);
    Uunlink(real_dbmname);
    }
  else
    {
    sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
    Uunlink(real_dbmname);
    sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
    Uunlink(real_dbmname);
    }
#endif /* USE_DB || USE_TDB */
  }

return yield;
}

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