* Open the database specified in the 'v' global struct,

 * setting the file descriptor.  Returns 0 on success.

short int

	/* only re-open the db at most every 10 seconds */

	time_t now = time( NULL );

	if ( v.timer.db_lastcheck > 0 ) {

		if ( now - v.timer.db_lastcheck >= 10 ) {

			close( v.db_fd );

			return( 0 );

	debug( 2, LOC, "(Re)attaching to database '%s'\n", v.dbname );

	/* db filename not set? */

	if ( strlen(v.dbname) == 0 ) {

		debug( 1, LOC, "Error when attaching to database: DB filename unset?\n" );

	if ( (v.db_fd = open( v.dbname, O_RDONLY )) == -1 ) {

		debug( 1, LOC, "Error when attaching to database: %s\n", strerror(errno) );

		return( -1 );

	}

	v.timer.db_lastcheck = now;

	return( 0 );

 * Given a rule file in ascii specified by the -c command line arg,

 * convert it to a cdb after checking rules for validity.

db_create_new( char *txt )

	struct cdb_make cdbm;

	char buf[ LINE_BUFSIZE*10 ];

	char tmpfile[25];

	int  tmp_fd;

	FILE *txt_f = NULL;

	int  linenum = 0, parsed = 0;

	struct db_input *dbline;

	/* open temporary file */

	debug( 0, LOC, "Creating/updating database (%s) using rules in \"%s\"\n", v.dbname, txt );

	sprintf( tmpfile, "/tmp/volta-db-%d.tmp", getpid() );

	if ( (tmp_fd = open( tmpfile,

						 O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH )) == -1 ) {

		debug( 0, LOC, "Error writing temporary file: %s\n", strerror(errno) );

		return( 1 );

	}

	/* open rules file */

	if ( (txt_f = fopen( txt, "r" )) == NULL ) {

		debug( 0, LOC, "Error reading rules file: %s\n", strerror(errno) );

		return( 1 );

	/* init struct and start parsing lines */

	cdb_make_start( &cdbm, tmp_fd );

	while ( fgets( buf, LINE_BUFSIZE*10, txt_f ) != NULL ) {

		linenum++;

		/* skip blank lines and comments */

		if ( strlen(buf) == 1 || buf[0] == '#' ) continue;

		/* validate and add! */

		dbline = parse_dbinput( buf );

		if ( dbline == NULL ) {

			debug( 0, LOC, "Invalid rule (line %d), skipping: %s", linenum, buf );

			continue;

		}

		cdb_make_add( &cdbm, dbline->key, dbline->klen, dbline->val, dbline->vlen );

		parsed++;

		free( dbline->key );

		free( dbline->val );

		free( dbline );

	}

	/* write indexes */

	fclose( txt_f );

	cdb_make_finish( &cdbm );

	close( tmp_fd );

	/* move cdb into place */

	if ( (rename( tmpfile, v.dbname )) == -1 ) {

		debug( 1, LOC, "Unable to move temp cdb into place: %s", strerror(errno) );

		return( 1 );

	}

	debug( 0, LOC, "Added %d rules to %s.\n", parsed, v.dbname );

	return( 0 );

/* Fast single record lookup.

 * Returns a pointer to the found value or NULL if there is no match.

 *

 * The returned pointer should be freed after use.

char *

find_record( char *key )

	if ( key == NULL ) return( NULL );

	char *val = NULL;

	cdbi_t vlen;

	if ( cdb_seek( v.db_fd, key, (int)strlen(key), &vlen) > 0 ) {

		if ( (val = malloc( vlen + 1 )) == NULL ) {

			debug( 5, LOC, "Unable to allocate memory for value storage: %s\n", strerror(errno) );

			return( NULL );

		}

		cdb_bread( v.db_fd, val, vlen );

		val[vlen] = '\0';

		debug( 4, LOC, "Match for key '%s': %s\n", key, val );

	return val;

/* 

 * Search the CDB for all occurences of the given +key+,

 * populating the +results+ array with pointers to parsed rule structs.

 *

 * Returns the number of successful matches.  reset_results()

 * should be called after the result set is examined.

unsigned int

find_records( char *key, parsed **results )

	if ( key == NULL ) return( 0 );

	struct cdb cdb;

	struct cdb_find cdbf; /* structure to hold current find position */

	unsigned int match = 0;

	parsed *result     = NULL;

	char *val          = NULL;

	unsigned int vlen, vpos;

	/* initialize search structs */

	if ( db_attach() == -1 ) return( 0 );

	cdb_init( &cdb, v.db_fd );

	cdb_findinit( &cdbf, &cdb, key, (int)strlen(key) );

	while ( cdb_findnext( &cdbf ) > 0 && match < DB_RESULTS_MAX ) {

		vpos = cdb_datapos( &cdb );

		vlen = cdb_datalen( &cdb );

		/* pull the value from the db */

		if ( (val = calloc( vlen, sizeof(char) )) == NULL ) {

			debug( 5, LOC, "Unable to allocate memory for DB value storage: %s\n",

					strerror(errno) );

			return( 0 );

		}

		cdb_read( &cdb, val, vlen, vpos );

		/* if it parses properly, add it to the result set. */

		result = parse_rule( val );

		if ( result != NULL ) {

			results[match] = result;

			debug( 4, LOC, "DB match %d for key '%s': %s\n", match+1, key, val );

		}

		match++;

		free( val );

	}

	cdb_free( &cdb );

	return match;