[exim.git] / src / 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 */

/******************************************************************************/
					/* dummies needed by Solaris build */
void
millisleep(int msec)
{}
uschar *
readconf_printtime(int t)
{ return NULL; }
void *
store_get_3(int size, BOOL tainted, const char *filename, int linenumber)
{ return NULL; }
void **
store_reset_3(void **ptr, int pool, const char *filename, int linenumber)
{ return NULL; }
void
store_release_above_3(void *ptr, const char *func, int linenumber)
{ }
gstring *
string_vformat_trc(gstring * g, const uschar * func, unsigned line,
  unsigned size_limit, unsigned flags, const char *format, va_list ap)
{ return NULL; }
uschar *
string_sprintf_trc(const char * a, const uschar * b, unsigned c, ...)
{ return NULL; }
BOOL
string_format_trc(uschar * buf, int len, const uschar * func, unsigned line,
  const char * fmt, ...)
{ return FALSE; }


struct global_flags	f;
unsigned int		log_selector[1];
uschar *		queue_name;
BOOL			split_spool_directory;
/******************************************************************************/


#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 (ch == '\0') return **pp;
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, US argv[arg+1]);
Ustrcat(temp_dbmname, US".dbmbuild_temp");

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

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