[exim.git] / src / src / exim_dbmbuild.c

/* $Cambridge: exim/src/src/exim_dbmbuild.c,v 1.3 2005/06/14 10:32:01 ph10 Exp $ */

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

/* Copyright (c) University of Cambridge 1995 - 2005 */
/* 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"


#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. */

uschar *hex_digits = US"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(uschar **pp)
{
int ch;
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[256];
uschar  real_dbmname[256];
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

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

/* 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, O_RDWR|O_CREAT|O_EXCL, 0644, &d);

if (d == NULL)
  {
  printf("exim_dbmbuild: unable to create %s: %s\n", temp_dbmname,
    strerror(errno));
  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);
    return 1;
    }

  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);
      return 1;
      }

    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(&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);
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)
  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
1f922db1	1	/* $Cambridge: exim/src/src/exim_dbmbuild.c,v 1.3 2005/06/14 10:32:01 ph10 Exp $ */
059ec3d9 PH	2
	3	/*************************************************
	4	* Exim - an Internet mail transport agent *
	5	*************************************************/
	6
c988f1f4	7	/* Copyright (c) University of Cambridge 1995 - 2005 */
059ec3d9 PH	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
1f922db1	61	exists" when you try to open a db file. The API changed at release 4.3. */
059ec3d9 PH	62
	63	#if defined(USE_DB) && defined(DB_VERSION_STRING)
	64	void
1f922db1 PH	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
059ec3d9 PH	70	dbfn_bdb_error_callback(const char pfx, char msg)
059ec3d9 PH	71	{
1f922db1	72	#endif
059ec3d9 PH	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[256];
155	uschar real_dbmname[256];
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	Ustrcpy(temp_dbmname, argv[arg+1]);
199	Ustrcat(temp_dbmname, ".dbmbuild_temp");
200
201	/* It is apparently necessary to open with O_RDWR for this to work
202	with gdbm-1.7.3, though no reading is actually going to be done. */
203
204	EXIM_DBOPEN(temp_dbmname, O_RDWR\|O_CREAT\|O_EXCL, 0644, &d);
205
206	if (d == NULL)
207	{
208	printf("exim_dbmbuild: unable to create %s: %s\n", temp_dbmname,
209	strerror(errno));
210	fclose(f);
211	exit(1);
212	}
213
214	/* Unless using native db calls, see if we have created <name>.db; if not,
215	assume .dir & .pag */
216
217	#if !defined(USE_DB) && !defined(USE_TDB) && !defined(USE_GDBM)
218	sprintf(CS real_dbmname, "%s.db", temp_dbmname);
219	is_db = Ustat(real_dbmname, &statbuf) == 0;
220	#endif
221
222	/* Now do the business */
223
224	bptr = buffer;
225	started = 0;
226
227	while (Ufgets(line, max_insize, f) != NULL)
228	{
229	uschar *p;
230	int len = Ustrlen(line);
231
232	p = line + len;
233
234	if (len >= max_insize - 1 && p[-1] != '\n')
235	{
236	printf("Overlong line read: max permitted length is %d\n", max_insize - 1);
237	return 1;
238	}
239
240	if (line[0] == '#') continue;
241	while (p > line && isspace(p[-1])) p--;
242	*p = 0;
243	if (line[0] == 0) continue;
244
245	/* A continuation line is valid only if there was a previous first
246	line. */
247
248	if (isspace(line[0]))
249	{
250	uschar *s = line;
251	if (!started)
252	{
253	printf("Unexpected continuation line ignored\n%s\n\n", line);
254	continue;
255	}
256	while (isspace(*s)) s++;
257	*(--s) = ' ';
258
259	if (bptr - buffer + p - s >= max_outsize - 1)
260	{
261	printf("Continued set of lines is too long: max permitted length is %d\n",
262	max_outsize -1);
263	return 1;
264	}
265
266	Ustrcpy(bptr, s);
267	bptr += p - s;
268	}
269
270	/* A first line must have a name followed by a colon or whitespace or
271	end of line, but first finish with a previous line. The key is lower
272	cased by default - this is what the newaliases program for sendmail does.
273	However, there's an option not to do this. */
274
275	else
276	{
277	int i, rc;
278	uschar *s = line;
279	uschar *keystart;
280
281	if (started)
282	{
283	EXIM_DATUM_INIT(content);
284	EXIM_DATUM_DATA(content) = CS buffer;
285	EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;
286
287	switch(rc = EXIM_DBPUTB(d, key, content))
288	{
289	case EXIM_DBPUTB_OK:
290	count++;
291	break;
292
293	case EXIM_DBPUTB_DUP:
294	if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n",
295	keybuffer);
296	dupcount++;
297	if(duperr) yield = 1;
298	if (lastdup) EXIM_DBPUT(d, key, content);
299	break;
300
301	default:
302	fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
303	keybuffer, errno);
304	yield = 2;
305	goto TIDYUP;
306	}
307
308	bptr = buffer;
309	}
310
311	EXIM_DATUM_INIT(key);
312	EXIM_DATUM_DATA(key) = CS keybuffer;
313
314	/* Deal with quoted keys. Escape sequences always make one character
315	out of several, so we can re-build in place. */
316
317	if (*s == '\"')
318	{
319	uschar *t = s++;
320	keystart = t;
321	while (s != 0 && s != '\"')
322	{
323	if (s == '\\') t++ = string_interpret_escape(&s);
324	else t++ = s;
325	s++;
326	}
327	if (s != 0) s++; / Past terminating " */
328	EXIM_DATUM_SIZE(key) = t - keystart + add_zero;
329	}
330	else
331	{
332	keystart = s;
333	while (s != 0 && s != ':' && !isspace(*s)) s++;
334	EXIM_DATUM_SIZE(key) = s - keystart + add_zero;
335	}
336
337	if (EXIM_DATUM_SIZE(key) > 256)
338	{
339	printf("Keys longer than 255 characters cannot be handled\n");
340	started = 0;
341	yield = 2;
342	goto TIDYUP;
343	}
344
345	if (lowercase)
346	{
347	for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
348	keybuffer[i] = tolower(keystart[i]);
349	}
350	else
351	{
352	for (i = 0; i < EXIM_DATUM_SIZE(key) - add_zero; i++)
353	keybuffer[i] = keystart[i];
354	}
355
356	keybuffer[i] = 0;
357	started = 1;
358
359	while (isspace(*s))s++;
360	if (*s == ':')
361	{
362	s++;
363	while (isspace(*s))s++;
364	}
365	if (*s != 0)
366	{
367	Ustrcpy(bptr, s);
368	bptr += p - s;
369	}
370	else buffer[0] = 0;
371	}
372	}
373
374	if (started)
375	{
376	int rc;
377	EXIM_DATUM_INIT(content);
378	EXIM_DATUM_DATA(content) = CS buffer;
379	EXIM_DATUM_SIZE(content) = bptr - buffer + add_zero;
380
381	switch(rc = EXIM_DBPUTB(d, key, content))
382	{
383	case EXIM_DBPUTB_OK:
384	count++;
385	break;
386
387	case EXIM_DBPUTB_DUP:
388	if (warn) fprintf(stderr, "** Duplicate key \"%s\"\n", keybuffer);
389	dupcount++;
390	if (duperr) yield = 1;
391	if (lastdup) EXIM_DBPUT(d, key, content);
392	break;
393
394	default:
395	fprintf(stderr, "Error %d while writing key %s: errno=%d\n", rc,
396	keybuffer, errno);
397	yield = 2;
398	break;
399	}
400	}
401
402	/* Close files, rename or abandon the temporary files, and exit */
403
404	TIDYUP:
405
406	EXIM_DBCLOSE(d);
407	fclose(f);
408
409	/* If successful, output the number of entries and rename the temporary
410	files. */
411
412	if (yield == 0 \|\| yield == 1)
413	{
414	printf("%d entr%s written\n", count, (count == 1)? "y" : "ies");
415	if (dupcount > 0)
416	{
417	printf("%d duplicate key%s \n", dupcount, (dupcount > 1)? "s" : "");
418	}
419
420	#if defined(USE_DB) \|\| defined(USE_TDB) \|\| defined(USE_GDBM)
421	Ustrcpy(real_dbmname, temp_dbmname);
422	Ustrcpy(buffer, argv[arg+1]);
423	if (Urename(real_dbmname, buffer) != 0)
424	{
425	printf("Unable to rename %s as %s\n", real_dbmname, buffer);
426	return 1;
427	}
428	#else
429
430	/* Rename a single .db file */
431
432	if (is_db)
433	{
434	sprintf(CS real_dbmname, "%s.db", temp_dbmname);
435	sprintf(CS buffer, "%s.db", argv[arg+1]);
436	if (Urename(real_dbmname, buffer) != 0)
437	{
438	printf("Unable to rename %s as %s\n", real_dbmname, buffer);
439	return 1;
440	}
441	}
442
443	/* Rename .dir and .pag files */
444
445	else
446	{
447	sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
448	sprintf(CS buffer, "%s.dir", argv[arg+1]);
449	if (Urename(real_dbmname, buffer) != 0)
450	{
451	printf("Unable to rename %s as %s\n", real_dbmname, buffer);
452	return 1;
453	}
454
455	sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
456	sprintf(CS buffer, "%s.pag", argv[arg+1]);
457	if (Urename(real_dbmname, buffer) != 0)
458	{
459	printf("Unable to rename %s as %s\n", real_dbmname, buffer);
460	return 1;
461	}
462	}
463
464	#endif /* USE_DB \|\| USE_TDB \|\| USE_GDBM */
465	}
466
467	/* Otherwise unlink the temporary files. */
468
469	else
470	{
471	printf("dbmbuild abandoned\n");
472	#if defined(USE_DB) \|\| defined(USE_TDB) \|\| defined(USE_GDBM)
473	Uunlink(temp_dbmname);
474	#else
475	if (is_db)
476	{
477	sprintf(CS real_dbmname, "%s.db", temp_dbmname);
478	Uunlink(real_dbmname);
479	}
480	else
481	{
482	sprintf(CS real_dbmname, "%s.dir", temp_dbmname);
483	Uunlink(real_dbmname);
484	sprintf(CS real_dbmname, "%s.pag", temp_dbmname);
485	Uunlink(real_dbmname);
486	}
487	#endif /* USE_DB \|\| USE_TDB */
488	}
489
490	return yield;
491	}
492
493	/* End of exim_dbmbuild.c */