tacit/minix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f238ccc5e5
minix/external/bsd/bind/dist/contrib/dlz/bin/dlzbdb/dlzbdb.c
David van Moolenbroek 00b67f09dd Import NetBSD named(8) 
Also known as ISC bind.  This import adds utilities such as host(1),
dig(1), and nslookup(1), as well as many other tools and libraries.

Change-Id: I035ca46e64f1965d57019e773f4ff0ef035e4aa3
2017-03-21 22:00:06 +00:00

1276 lines
35 KiB
C
Raw Blame History

/* $NetBSD: dlzbdb.c,v 1.3 2014/12/10 04:37:55 christos Exp $ */
/*
* Copyright (C) 2002 Stichting NLnet, Netherlands, stichting@nlnet.nl.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND STICHTING NLNET
* DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
* STICHTING NLNET BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
* USE OR PERFORMANCE OF THIS SOFTWARE.
*
* The development of Dynamically Loadable Zones (DLZ) for Bind 9 was
* conceived and contributed by Rob Butler.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ROB BUTLER
* DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
* ROB BUTLER BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
* USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Copyright (C) 1999-2001 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
* DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
* INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef DLZ_BDB
/*
* exit codes
* 0 everything ok
* 1 error parsing command line
* 2 Missing, too many or invalid combination of command line parameters
* 3 Unable to open BDB database.
* 4 Unable to allocate memory for, or create lexer.
* 5 unable to perform BDB cursor operation
*/
#include <config.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <isc/buffer.h>
#include <isc/commandline.h>
#include <isc/formatcheck.h>
#include <isc/lex.h>
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/string.h>
#include <isc/util.h>
#include <db.h>
/* shut up compiler warnings about no previous prototype */
static void
show_usage(void);
int
getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
int
gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey);
void
bdb_cleanup(void);
isc_result_t
bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name, int flags);
void
put_data(isc_boolean_t dns_data, char *input_key, char *input_data);
void
insert_data(void);
isc_result_t
openBDB(void);
isc_result_t
open_lexer(void);
void
close_lexer(void);
isc_result_t
bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey, DBT *bdbdata);
void
operation_add(void);
void
operation_bulk(void);
void
operation_listOrDelete(isc_boolean_t dlt);
/*%
* Maximum length of a single data line that
* may be inserted into database by this program.
* If you need to insert a line of data that is more
* than 10,000 characters change this definition.
*/
#define max_data_len 10000
/*%
* BDB database names. If you want to use different
* database names change them here.
*/
#define dlz_data "dns_data"
#define dlz_zone "dns_zone"
#define dlz_host "dns_host"
#define dlz_client "dns_client"
/*%
* Error code returned by BDB secondary index callback functions.
* This error is returned if the callback function could not create
* the secondary index for any reason.
*/
#define BDBparseErr 1
/* A struct to hold all the relevant info about the database */
typedef struct bdb_instance {
DB_ENV *dbenv; /* BDB environment */
DB *data; /* dns_data database handle */
DBC *cursor; /* database cursor */
DBC *cursor2; /* second cursor used during list operation. */
DBC *cursor3; /* third cursor used during list operation */
DBC *cursor4; /* fourth cursor used during list operation */
DB *zone; /* zone database handle */
DB *host; /* host database handle */
DB *client; /* client database handle */
} bdb_instance_t;
/* Possible operations */
#define list 1 /* list data */
#define dele 2 /* delete data */
#define add 3 /* add a single piece of data */
#define bulk 4 /* bulk load data */
/*%
* quit macro is used instead of exit. quit always trys to close the lexer
* and the BDB database before exiting.
*/
#define quit(i) close_lexer(); bdb_cleanup(); exit(i);
/*%
* checkOp is used to verify that only one operation (list, del, add,
* bulk from file, bulk from stdin) is specified on the command line.
* This prevents a user from specifying two operations on the command
* line, which would make no sense anyway.
*/
#define checkOp(x) if (x != 0) {fprintf(stderr, "\nonly one operation "\
"(l e d a f s) may be specified\n"); quit(2);}
/*%
* checkParam is used to only allow a parameter to be specified once.
* I.E. the parameter key can only be used on the command line once.
* any attempt to use it twice causes an error.
*/
#define checkParam(x, y) if (x != NULL) {fprintf(stderr, "\n%s may only "\
"be specified once\n", y); quit(2);}
/*%
* checkInvalidParam is used to only allow paramters which make sense for
* the operation selected. I.E. passing the key parameter makes no sense
* for the add operation, and thus it isn't allowed.
*/
#define checkInvalidParam(x, y, z) if (x != NULL) {fprintf(stderr, "\n%s "\
"may not be specified %s\n", y, z); quit(2);}
/*%
* checkInvalidOption is used to only allow paramters which make sense for
* the operation selected - but checks boolean options.
* I.E. passing the "b" bare_list parameter makes no sense for the add
* operation, and thus it isn't allowed.
* if w == x then output error message "flag", "message"
*/
#define checkInvalidOption(w, x, y, z) if (w == x) {fprintf(stderr, "\n%s "\
"may not be specified %s\n", y, z); quit(2);}
/* Global Variables */
int operation = 0; /*%< operation to perform. */
/*% allow new lock files or DB to be created. */
isc_boolean_t create_allowed = isc_boolean_false;
char *key = NULL; /*%< key to use in list & del operations */
/*% dump DB in DLZBDB bulk format */
isc_boolean_t list_everything = isc_boolean_false;
unsigned int key_val; /*%< key as unsigned int used in list & del operations */
char *zone = NULL; /*%< zone to use in list operations */
char *host = NULL; /*%< host to use in list operations */
char *c_zone = NULL; /*%< client zone to use in list operations */
char *c_ip = NULL; /*%< client IP to use in list operations */
char *a_data = NULL; /*%< data in add operation */
char *bulk_file = NULL; /*%< bulk data file to load */
char *db_envdir = NULL; /*%< BDB environment location */
char *db_file = NULL; /*%< BDB database file location. */
bdb_instance_t db; /* BDB instance we are operating on */
isc_lex_t *lexer = NULL; /*%< lexer for use to use in parsing input */
isc_mem_t *lex_mctx = NULL; /*%< memory context for lexer */
char lex_data_buf[max_data_len]; /*%< data array to use for lex_buffer below */
isc_buffer_t lex_buffer; /*%< buffer for lexer during add operation */
/*%
* Displays usage message
*/
static void
show_usage(void) {
fprintf(stderr, "\n\n\
---Usage:---------------------------------------------------------------------\
\n\n\
List data:\n\
dlzbdb -l [-k key] [-z zone] [-h host] [-c client_zone] [-i client_ip]\n\
BDB_environment BDB_database\n\n\
Delete data:\n\
dlzbdb -d [-k key] [-c client_zone] [-i client_ip]\n\
BDB_environment BDB_database\n\n\
Bulk load data from file:\n\
dlzbdb -f file_to_load BDB_environment BDB_database\n\n\
Bulk load data from stdin\n\
dlzbdb -s BDB_environment BDB_database\n\n\
Add data:\n\
dlzbdb -a \"dns data to be added\" BDB_environment BDB_database\n\n\
Export data:\n\
dlzbdb -e BDB_environment BDB_database\n\n\
Normally operations can only be performed on an existing database files.\n\
Use the -n flag with any operation to allow files to be created.\n\
Existing files will NOT be truncated by using the -n flag.\n\
The -n flag will allow a new database to be created, or allow new\n\
environment files to be created for an existing database.\n\n\
---Format for -f & -a options:------------------------------------------------\
\n\n\
db_type zone host dns_type ttl ip\n\
db_type zone host dns_type ttl mx_priority mail_host\n\
db_type zone host dns_type ttl nm_svr resp_psn serial refresh retry expire min\
\n\
db_type zone client_ip\n\n\
---Examples:------------------------------------------------------------------\
\n\n\
d mynm.com www A 10 127.0.0.1\n\
d mynm.com @ MX 10 5 mail\n\
d mynm.com @ SOA 10 ns1.mynm.com. root.mynm.com. 2 28800 7200 604800 86400\n\
c mynm.com 127.0.0.1\n\
c mynm.com 192.168.0.10\n\
");
quit(1);
}
/*% BDB callback to create zone secondary index */
int
getzone(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey) {
char *tmp;
char *left;
char *right;
int result=0;
UNUSED(dbp);
UNUSED(pkey);
/* Allocate memory to use in parsing the string */
tmp = right = malloc(pdata->size + 1);
/* verify memory was allocated */
if (right == NULL) {
result = BDBparseErr;
goto getzone_cleanup;
}
/* copy data string into newly allocated memory */
strncpy(right, pdata->data, pdata->size);
right[pdata->size] = '\0';
/* split string at the first space */
left = isc_string_separate(&right, " ");
/* copy string for "zone" secondary index */
skey->data = strdup(left);
if (skey->data == NULL) {
result = BDBparseErr;
goto getzone_cleanup;
}
/* set required values for BDB */
skey->size = strlen(skey->data);
skey->flags = DB_DBT_APPMALLOC;
getzone_cleanup:
/* cleanup memory */
if (tmp != NULL)
free(tmp);
return result;
}
/*%
* BDB callback to create host secondary index
*/
int
gethost(DB *dbp, const DBT *pkey, const DBT *pdata, DBT *skey) {
char *tmp;
char *left;
char *right;
int result=0;
UNUSED(dbp);
UNUSED(pkey);
/* allocate memory to use in parsing the string */
tmp = right = malloc(pdata->size + 1);
/* verify memory was allocated */
if (tmp == NULL) {
result = BDBparseErr;
goto gethost_cleanup;
}
/* copy data string into newly allocated memory */
strncpy(right, pdata->data, pdata->size);
right[pdata->size] = '\0';
/* we don't care about left string. */
/* memory of left string will be freed when tmp is freed. */
isc_string_separate(&right, " ");
/* verify right still has some characters left */
if (right == NULL) {
result = BDBparseErr;
goto gethost_cleanup;
}
/* get "host" from data string */
left = isc_string_separate(&right, " ");
/* copy string for "host" secondary index */
skey->data = strdup(left);
if (skey->data == NULL) {
result = BDBparseErr;
goto gethost_cleanup;
}
/* set required values for BDB */
skey->size = strlen(skey->data);
skey->flags = DB_DBT_APPMALLOC;
gethost_cleanup:
/* cleanup memory */
if (tmp != NULL)
free(tmp);
return result;
}
/*%
* Performs BDB cleanup. Close each database that we opened.
* Close environment. Set each var to NULL so we know they
* were closed and don't accidentally try to close them twice.
*/
void
bdb_cleanup(void) {
/* close cursors */
if (db.cursor4 != NULL) {
db.cursor4->c_close(db.cursor4);
db.cursor4 = NULL;
}
if (db.cursor3 != NULL) {
db.cursor3->c_close(db.cursor3);
db.cursor3 = NULL;
}
if (db.cursor2 != NULL) {
db.cursor2->c_close(db.cursor2);
db.cursor2 = NULL;
}
if (db.cursor != NULL) {
db.cursor->c_close(db.cursor);
db.cursor = NULL;
}
/* close databases */
if (db.data != NULL) {
db.data->close(db.data, 0);
db.data = NULL;
}
if (db.host != NULL) {
db.host->close(db.host, 0);
db.host = NULL;
}
if (db.zone != NULL) {
db.zone->close(db.zone, 0);
db.zone = NULL;
}
if (db.client != NULL) {
db.client->close(db.client, 0);
db.client = NULL;
}
/* close environment */
if (db.dbenv != NULL) {
db.dbenv->close(db.dbenv, 0);
db.dbenv = NULL;
}
}
/*% Initializes, sets flags and then opens Berkeley databases. */
isc_result_t
bdb_opendb(DBTYPE db_type, DB **db_out, const char *db_name, int flags) {
int result;
int createFlag = 0;
/* Initialize the database. */
if ((result = db_create(db_out, db.dbenv, 0)) != 0) {
fprintf(stderr, "BDB could not initialize %s database. BDB error: %s",
db_name, db_strerror(result));
return ISC_R_FAILURE;
}
/* set database flags. */
if ((result = (*db_out)->set_flags(*db_out, flags)) != 0) {
fprintf(stderr, "BDB could not set flags for %s database. BDB error: %s",
db_name, db_strerror(result));
return ISC_R_FAILURE;
}
if (create_allowed == isc_boolean_true) {
createFlag = DB_CREATE;
}
/* open the database. */
if ((result = (*db_out)->open(*db_out, NULL, db_file, db_name, db_type,
createFlag, 0)) != 0) {
fprintf(stderr, "BDB could not open %s database in %s. BDB error: %s",
db_name, db_file, db_strerror(result));
return ISC_R_FAILURE;
}
return ISC_R_SUCCESS;
}
/*%
* parses input and adds it to the BDB database
* Lexer should be instantiated, and either a file or buffer opened for it.
* The insert_data function is used by both the add, and bulk insert
* operations
*/
void
put_data(isc_boolean_t dns_data, char *input_key, char *input_data) {
int bdbres;
DBT key, data;
/* make sure key & data are completely empty */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
/* if client data, setup key for insertion */
if (!dns_data && input_key != NULL) {
key.data = input_key;
key.size = strlen(input_key);
key.flags = 0;
}
/* always setup data for insertion */
data.data = input_data;
data.size = strlen(input_data);
data.flags = 0;
/* execute insert against appropriate database. */
if (dns_data) {
bdbres = db.data->put(db.data, NULL, &key, &data, DB_APPEND);
} else {
bdbres = db.client->put(db.client, NULL, &key, &data, 0);
}
/* if something went wrong, log error and quit */
if (bdbres != 0) {
fprintf(stderr, "BDB could not insert data. Error: %s",
db_strerror(bdbres));
quit(5);
}
}
void
insert_data(void) {
unsigned int opt =
ISC_LEXOPT_EOL | /* Want end-of-line token. */
ISC_LEXOPT_EOF | /* Want end-of-file token. */
ISC_LEXOPT_QSTRING | /* Recognize qstrings. */
ISC_LEXOPT_QSTRINGMULTILINE; /* Allow multiline "" strings */
isc_result_t result;
isc_token_t token; /* token from lexer */
isc_boolean_t loop = isc_boolean_true;
isc_boolean_t have_czone = isc_boolean_false;
char data_arr[max_data_len];
isc_buffer_t buf;
char data_arr2[max_data_len];
isc_buffer_t buf2;
char data_type = 'u'; /* u =unknown, b =bad token, d/D =DNS, c/C =client IP */
/* Initialize buffers */
isc_buffer_init(&buf, &data_arr, max_data_len);
isc_buffer_init(&buf2, &data_arr2, max_data_len);
while (loop) {
result = isc_lex_gettoken(lexer, opt, &token);
if (result != ISC_R_SUCCESS)
goto data_cleanup;
switch(token.type) {
case isc_tokentype_string:
if (data_type == 'u') {
/* store data_type */
strncpy(&data_type, token.value.as_pointer, 1);
/* verify data_type was specified correctly on input */
if (strlen(token.value.as_pointer) > 1 || (
data_type != 'd' && data_type != 'D' &&
data_type != 'c' && data_type != 'C') ) {
/* if not, set to 'b' so this line is ignored. */
data_type = 'b';
}
} else if (data_type == 'c' || data_type == 'C') {
if (have_czone == isc_boolean_true) {
isc_buffer_putstr(&buf2, token.value.as_pointer);
/* add string terminator to buffer */
isc_buffer_putmem(&buf2, "\0", 1);
} else {
isc_buffer_putstr(&buf, token.value.as_pointer);
/* add string terminator to buffer */
isc_buffer_putmem(&buf, "\0", 1);
have_czone = isc_boolean_true;
}
} else {
isc_buffer_putstr(&buf, token.value.as_pointer);
isc_buffer_putstr(&buf, " ");
}
break;
case isc_tokentype_qstring:
isc_buffer_putstr(&buf, "\"");
isc_buffer_putstr(&buf, token.value.as_pointer);
isc_buffer_putstr(&buf, "\" ");
break;
case isc_tokentype_eol:
case isc_tokentype_eof:
if ((data_type != 'u' && isc_buffer_usedlength(&buf) > 0) || data_type == 'b') {
/* perform insert operation */
if (data_type == 'd' || data_type == 'D') {
/* add string terminator to buffer */
isc_buffer_putmem(&buf, "\0", 1);
put_data(isc_boolean_true, NULL, (char *) &data_arr);
} else if (data_type == 'c' || data_type == 'C') {
put_data(isc_boolean_false, (char *) &data_arr,
(char *) &data_arr2);
} else if (data_type == 'b') {
fprintf(stderr, "Bad / unknown token encountered on line %lu."\
" Skipping line.", isc_lex_getsourceline(lexer) - 1);
} else {
fprintf(stderr, "Bad / unknown db data type encountered on " \
"line %lu. Skipping line\n", isc_lex_getsourceline(lexer) - 1);
}
}
if (token.type == isc_tokentype_eof) {
loop = isc_boolean_false;
}
/* reset buffer for next insert */
isc_buffer_clear(&buf);
isc_buffer_clear(&buf2);
have_czone = isc_boolean_false;
data_type ='u';
break;
default:
data_type = 'b';
break;
}
}
return;
data_cleanup:
/* let user know we had problems */
fprintf(stderr, "Unknown error processing tokens during \"add\" or " \
"\"bulk\" operation.\nStoped processing on line %lu.",
isc_lex_getsourceline(lexer));
}
isc_result_t
openBDB(void) {
int bdbres;
isc_result_t result;
/* create BDB environment */
/* Basically BDB allocates and assigns memory to db->dbenv */
bdbres = db_env_create(&db.dbenv, 0);
if (bdbres != 0) {
fprintf(stderr, "BDB environment could not be created. BDB error: %s",
db_strerror(bdbres));
result = ISC_R_FAILURE;
goto openBDB_cleanup;
}
/* open BDB environment */
if (create_allowed == isc_boolean_true) {
/* allowed to create new files */
bdbres = db.dbenv->open(db.dbenv, db_envdir,
DB_INIT_CDB | DB_INIT_MPOOL | DB_CREATE, 0);
} else { /* not allowed to create new files. */
bdbres = db.dbenv->open(db.dbenv, db_envdir,
DB_INIT_CDB | DB_INIT_MPOOL, 0);
}
if (bdbres != 0) {
fprintf(stderr, "BDB environment at '%s' could not be opened. BDB " \
"error: %s", db_envdir, db_strerror(bdbres));
result = ISC_R_FAILURE;
goto openBDB_cleanup;
}
/* open dlz_data database. */
result = bdb_opendb(DB_RECNO, &db.data, dlz_data, 0);
if (result != ISC_R_SUCCESS)
goto openBDB_cleanup;
/* open dlz_host database */
result = bdb_opendb(DB_BTREE, &db.host, dlz_host, DB_DUP | DB_DUPSORT);
if (result != ISC_R_SUCCESS)
goto openBDB_cleanup;
/* open dlz_zone database. */
result = bdb_opendb(DB_BTREE, &db.zone, dlz_zone, DB_DUP | DB_DUPSORT);
if (result != ISC_R_SUCCESS)
goto openBDB_cleanup;
/* open dlz_client database. */
result = bdb_opendb(DB_BTREE, &db.client, dlz_client, DB_DUP | DB_DUPSORT);
if (result != ISC_R_SUCCESS)
goto openBDB_cleanup;
/* associate the host secondary database with the primary database */
bdbres = db.data->associate(db.data, NULL, db.host, gethost, 0);
if (bdbres != 0) {
fprintf(stderr, "BDB could not associate %s database with %s. BDB "\
"error: %s", dlz_host, dlz_data, db_strerror(bdbres));
result = ISC_R_FAILURE;
goto openBDB_cleanup;
}
/* associate the zone secondary database with the primary database */
bdbres = db.data->associate(db.data, NULL, db.zone, getzone, 0);
if (bdbres != 0) {
fprintf(stderr, "BDB could not associate %s database with %s. BDB "\
"error: %s", dlz_zone, dlz_data, db_strerror(bdbres));
result = ISC_R_FAILURE;
goto openBDB_cleanup;
}
return result;
openBDB_cleanup:
bdb_cleanup();
return result;
}
/*% Create & open lexer to parse input data */
isc_result_t
open_lexer(void) {
isc_result_t result;
/* check if we already opened the lexer, if we did, return success */
if (lexer != NULL)
return ISC_R_SUCCESS;
/* allocate memory for lexer, and verify it was allocated */
result = isc_mem_create(0, 0, &lex_mctx);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "unexpected error creating lexer\n");
return result;
}
/* create lexer */
result = isc_lex_create(lex_mctx, 1500, &lexer);
if (result != ISC_R_SUCCESS)
fprintf(stderr, "unexpected error creating lexer\n");
/* set allowed commenting style */
isc_lex_setcomments(lexer, ISC_LEXCOMMENT_C | /* Allow C comments */
ISC_LEXCOMMENT_CPLUSPLUS | /* Allow C++ comments */
ISC_LEXCOMMENT_SHELL); /* Allow shellcomments */
isc_buffer_init(&lex_buffer, &lex_data_buf, max_data_len);
return result;
}
/*% Close the lexer, and cleanup memory */
void
close_lexer(void) {
/* If lexer is still open, close it & destroy it. */
if (lexer != NULL) {
isc_lex_close(lexer);
isc_lex_destroy(&lexer);
}
/* if lexer memory is still allocated, destroy it. */
if (lex_mctx != NULL)
isc_mem_destroy(&lex_mctx);
}
/*% Perform add operation */
void
operation_add(void) {
/* check for any parameters that are not allowed during add */
checkInvalidParam(key, "k", "for add operation");
checkInvalidParam(zone, "z", "for add operation");
checkInvalidParam(host, "h", "for add operation");
checkInvalidParam(c_zone, "c", "for add operation");
checkInvalidParam(c_ip, "i", "for add operation");
checkInvalidOption(list_everything, isc_boolean_true, "e",
"for add operation");
/* if open lexer fails it alread prints error messages. */
if (open_lexer() != ISC_R_SUCCESS) {
quit(4);
}
/* copy input data to buffer */
isc_buffer_putstr(&lex_buffer, a_data);
/* tell lexer to use buffer as input */
if (isc_lex_openbuffer(lexer, &lex_buffer) != ISC_R_SUCCESS) {
fprintf(stderr, "unexpected error opening lexer buffer");
quit(4);
}
/*common logic for "add" & "bulk" operations are handled by insert_data */
insert_data();
}
/*% Perform bulk insert operation */
void
operation_bulk(void) {
/* check for any parameters that are not allowed during bulk */
checkInvalidParam(key, "k", "for bulk load operation");
checkInvalidParam(zone, "z", "for bulk load operation");
checkInvalidParam(host, "h", "for bulk load operation");
checkInvalidParam(c_zone, "c", "for bulk load operation");
checkInvalidParam(c_ip, "i", "for bulk load operation");
checkInvalidOption(list_everything, isc_boolean_true, "e",
"for bulk load operation");
/* if open lexer fails it already prints error messages. */
if (open_lexer() != ISC_R_SUCCESS) {
quit(4);
}
if (bulk_file == NULL) {
if (isc_lex_openstream(lexer, stdin) != ISC_R_SUCCESS) {
fprintf(stderr, "unexpected error opening stdin by lexer.");
quit(4);
}
} else if (isc_lex_openfile(lexer, bulk_file) != ISC_R_SUCCESS) {
fprintf(stderr, "unexpected error opening %s by lexer.", bulk_file);
quit(4);
}
/* common logic for "add" & "bulk" operations are handled by insert_data */
insert_data();
}
isc_result_t
bulk_write(char type, DB *database, DBC *dbcursor, DBT *bdbkey, DBT *bdbdata) {
int bdbres;
db_recno_t recNum;
char *retkey = NULL, *retdata;
size_t retklen = 0, retdlen;
void *p;
/* use a 5MB buffer for the bulk dump */
int buffer_size = 5 * 1024 * 1024;
/* try to allocate a 5 MB buffer, if we fail write err msg, die. */
bdbdata->data = malloc(buffer_size);
if (bdbdata->data == NULL) {
fprintf(stderr,
"Unable to allocate 5 MB buffer for bulk database dump\n");
return ISC_R_FAILURE;
}
bdbdata->ulen = buffer_size;
bdbdata->flags = DB_DBT_USERMEM;
/* get a cursor, make sure it worked. */
bdbres = database->cursor(database, NULL, &dbcursor, 0);
if (bdbres != 0) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",db_strerror(bdbres));
free(bdbdata->data);
return ISC_R_FAILURE;
}
/* loop and dump all data */
for (;;) {
/* loop through data until DB_NOTFOUND is returned */
bdbres = dbcursor->c_get(dbcursor, bdbkey, bdbdata,
DB_MULTIPLE_KEY | DB_NEXT);
/* if not successful did we encounter DB_NOTFOUND, or */
/* have a different problem. */
if (bdbres != 0) {
if (bdbres != DB_NOTFOUND) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
free(bdbdata->data);
return ISC_R_FAILURE;
}
/* Hit DB_NOTFOUND which means end of data. */
break;
} /* end of if (bdbres !=0) */
for (DB_MULTIPLE_INIT(p, bdbdata);;) {
if (type == 'c')
DB_MULTIPLE_KEY_NEXT(p, bdbdata, retkey, retklen, retdata, retdlen);
else
DB_MULTIPLE_RECNO_NEXT(p, bdbdata, recNum, retdata, retdlen);
if (p == NULL)
break;
if (type == 'c')
printf("c %.*s %.*s\n",(int)retklen, retkey,(int)retdlen, retdata);
else
printf("d %.*s\n", (int)retdlen, retdata);
} /* end of for (DB_MULTIPLE_INIT....) */
} /* end of for (;;) */
/* free the buffer we created earlier */
free(bdbdata->data);
return ISC_R_SUCCESS;
}
/*%
* Perform listOrDelete operation
* if dlt == true, delete data
* else list data
*/
void
operation_listOrDelete(isc_boolean_t dlt) {
int bdbres = 0;
DBC *curList[3];
DBT bdbkey, bdbdata;
db_recno_t recno;
int curIndex = 0;
/* verify that only allowed parameters were passed. */
if (dlt == isc_boolean_true) {
checkInvalidParam(zone, "z", "for delete operation");
checkInvalidParam(host, "h", "for delete operation");
checkInvalidOption(list_everything, isc_boolean_true, "e",
"for delete operation");
checkInvalidOption(create_allowed, isc_boolean_true, "n",
"for delete operation");
} else if (key != NULL || zone != NULL || host != NULL) {
checkInvalidParam(c_zone, "c", "for list when k, z or h are specified");
checkInvalidParam(c_ip, "i", "for list when k, z, or h are specified");
checkInvalidOption(list_everything, isc_boolean_true, "e",
"for list when k, z, or h are specified");
checkInvalidOption(create_allowed, isc_boolean_true, "n",
"for list operation");
} else if (c_ip != NULL || c_zone != NULL) {
checkInvalidOption(list_everything, isc_boolean_true, "e",
"for list when c or i are specified");
checkInvalidOption(create_allowed, isc_boolean_true, "n",
"for list operation");
}
memset(&bdbkey, 0, sizeof(bdbkey));
memset(&bdbdata, 0, sizeof(bdbdata));
/* Dump database in "dlzbdb" bulk format */
if (list_everything == isc_boolean_true) {
if (bulk_write('c', db.client, db.cursor, &bdbkey, &bdbdata)
!= ISC_R_SUCCESS)
return;
memset(&bdbkey, 0, sizeof(bdbkey));
memset(&bdbdata, 0, sizeof(bdbdata));
bulk_write('d', db.data, db.cursor2, &bdbkey, &bdbdata);
return;
} /* end if (list_everything) */
/* set NULL the 2nd and 3rd positions in curList. */
/* that way later when add cursors to the join list */
/* it is already null terminated. */
curList[1] = curList[2] = NULL;
if (key != NULL) {
/* make sure other parameters weren't */
checkInvalidParam(zone, "z", "when k is specified");
checkInvalidParam(host, "h", "when k is specified");
recno = key_val;
bdbkey.data = &recno;
bdbkey.size = sizeof(recno);
if (dlt == isc_boolean_true) {
bdbres = db.data->del(db.data, NULL, &bdbkey, 0);
} else {
bdbdata.flags = DB_DBT_REALLOC;
bdbres = db.data->get(db.data, NULL, &bdbkey, &bdbdata, 0);
if (bdbres == 0) {
printf("KEY | DATA\n");
printf("%lu | %.*s\n", *(u_long *) bdbkey.data,
(int)bdbdata.size, (char *)bdbdata.data);
}
} /* closes else of if (dlt == isc_boolean_true) */
if (bdbres == DB_NOTFOUND) {
printf("Key not found in database");
}
} /* closes if (key != NULL) */
/* if zone is passed */
if (zone != NULL) {
/* create a cursor and make sure it worked */
bdbres = db.zone->cursor(db.zone, NULL, &db.cursor2, 0);
if (bdbres != 0) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
return;
}
bdbkey.data = zone;
bdbkey.size = strlen(zone);
bdbres = db.cursor2->c_get(db.cursor2, &bdbkey, &bdbdata, DB_SET);
if (bdbres != 0) {
if (bdbres != DB_NOTFOUND) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
} else {
printf("Zone not found in database");
}
return;
}
/* add cursor to cursor list for later use in join */
curList[curIndex++] = db.cursor2;
}
/* if host is passed */
if (host != NULL) {
/* create a cursor and make sure it worked. */
bdbres = db.host->cursor(db.host, NULL, &db.cursor3, 0);
if (bdbres != 0) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
return;
}
bdbkey.data = host;
bdbkey.size = strlen(host);
bdbres = db.cursor3->c_get(db.cursor3, &bdbkey, &bdbdata, DB_SET);
if (bdbres != 0) {
if (bdbres != DB_NOTFOUND) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
} else {
printf("Host not found in database");
}
return;
}
/* add cursor to cursor list for later use in join */
curList[curIndex++] = db.cursor3;
}
if (zone != NULL || host != NULL) {
/* join any cursors */
bdbres = db.data->join(db.data, curList, &db.cursor4, 0);
if (bdbres != 0) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
return;
}
memset(&bdbkey, 0, sizeof(bdbkey));
bdbkey.flags = DB_DBT_REALLOC;
memset(&bdbdata, 0, sizeof(bdbdata));
bdbdata.flags = DB_DBT_REALLOC;
/* print a header to explain the output */
printf("KEY | DATA\n");
/* loop and list all results. */
while (bdbres == 0) {
/* get data */
bdbres = db.cursor4->c_get(db.cursor4, &bdbkey, &bdbdata, 0);
/* verify call had no errors */
if (bdbres != 0) {
break;
}
printf("%lu | %.*s\n", *(u_long *) bdbkey.data,
(int)bdbdata.size, (char *)bdbdata.data);
} /* closes while loop */
}
if (c_ip != NULL && c_zone == NULL) {
fprintf(stderr, "i may only be specified when c is also specified\n");
quit(2);
}
/* if client_zone was passed */
if (c_zone != NULL) {
/* create a cursor and make sure it worked. */
if (dlt == isc_boolean_true) {
/* open read-write cursor */
bdbres = db.client->cursor(db.client, NULL, &db.cursor,
DB_WRITECURSOR);
} else {
/* open read only cursor */
bdbres = db.client->cursor(db.client, NULL, &db.cursor, 0);
/* print a header to explain the output */
printf("CLIENT_ZONE | CLIENT_IP\n");
}
bdbkey.data = c_zone;
bdbkey.size = strlen(c_zone);
if (c_ip != NULL) {
bdbdata.data = c_ip;
bdbdata.size = strlen(c_ip);
bdbres = db.cursor->c_get(db.cursor, &bdbkey, &bdbdata, DB_GET_BOTH);
if (bdbres == DB_NOTFOUND) {
printf("Client zone & IP not found in database");
}
} else {
bdbdata.flags = DB_DBT_REALLOC;
bdbres = db.cursor->c_get(db.cursor, &bdbkey, &bdbdata, DB_SET);
if (bdbres == DB_NOTFOUND) {
printf("Client zone not found in database");
}
}
while (bdbres == 0) {
if (dlt == isc_boolean_false) {
printf("%.*s | %.*s\n", (int)bdbkey.size, (char *) bdbkey.data,
(int)bdbdata.size, (char *) bdbdata.data);
} else {
/* delete record. */
bdbres = db.cursor->c_del(db.cursor, 0);
if (bdbres != 0) {
fprintf(stderr, "Unexpected error. BDB Error: %s\n",
db_strerror(bdbres));
break;
}
}
if (c_ip != NULL) {
break;
}
bdbres = db.cursor->c_get(db.cursor, &bdbkey, &bdbdata, DB_NEXT_DUP);
if (bdbres != 0) {
break;
}
} /* end while loop */
}
if (bdbres != 0 && bdbres != DB_NOTFOUND) {
fprintf(stderr, "Unexpected error during list operation " \
"BDB error: %s", db_strerror(bdbres));
}
if (bdbkey.flags == DB_DBT_REALLOC && bdbkey.data != NULL) {
free(bdbkey.data);
}
if (bdbdata.flags == DB_DBT_REALLOC && bdbdata.data != NULL) {
free(bdbdata.data);
}
}
int
main(int argc, char **argv) {
int ch;
char *endp;
/* there has to be at least 2 args, some operations require more */
if (argc < 2)
show_usage();
/* use the ISC commandline parser to get all the program arguments */
while ((ch= isc_commandline_parse(argc, argv, "ldesna:f:k:z:h:c:i:")) != -1) {
switch (ch) {
case 'n':
create_allowed = isc_boolean_true;
break;
case 'l':
checkOp(operation);
operation = list;
break;
case 'd':
checkOp(operation);
operation = dele;
break;
case 'a':
checkOp(operation);
operation = add;
a_data = isc_commandline_argument;
break;
case 'f':
checkOp(operation);
operation = bulk;
bulk_file = isc_commandline_argument;
break;
case 's':
checkOp(operation);
operation = bulk;
break;
case 'k':
checkParam(key, "k");
key = isc_commandline_argument;
key_val = strtoul(key, &endp, 10);
if (*endp != '\0' || key_val < 1) {
fprintf(stderr, "Error converting key to integer");
}
break;
case 'z':
checkParam(zone, "z");
zone = isc_commandline_argument;
break;
case 'h':
checkParam(host, "h");
host = isc_commandline_argument;
break;
case 'c':
checkParam(c_zone, "c");
c_zone = isc_commandline_argument;
break;
case 'i':
checkParam(c_ip, "i");
c_ip = isc_commandline_argument;
break;
case 'e':
checkOp(operation);
operation = list;
list_everything = isc_boolean_true;
break;
case '?':
show_usage();
break;
default:
/* should never reach this point */
fprintf(stderr, "unexpected error parsing command arguments\n");
quit(1);
break;
}
}
argc -= isc_commandline_index;
argv += isc_commandline_index;
/* argc & argv have been modified, so now only "extra" parameters are */
/* left in argc & argv. "Extra" parameters are any parameters that were */
/* not passed using a command line flag. Exactly 2 args should be left. */
/* The first should be the BDB environment path, the second should be the */
/* BDB database. The BDB database path can be either relative to the */
/* BDB environment path, or absolute. */
if (argc < 2) {
fprintf(stderr, "Both a Berkeley DB environment and file "\
"must be specified");
quit(2);
} else if (argc > 2) {
fprintf(stderr, "Too many parameters. Check command line for errors.");
quit(2);
}
/* get db_file to operate on */
db_envdir = argv[0];
db_file = argv[1];
if (openBDB() != ISC_R_SUCCESS) {
/* openBDB already prints error messages, don't do it here. */
bdb_cleanup();
quit(3);
}
switch(operation) {
case list:
operation_listOrDelete(isc_boolean_false);
break;
case dele:
operation_listOrDelete(isc_boolean_true);
break;
case add:
operation_add();
break;
case bulk:
operation_bulk();
break;
default:
fprintf(stderr, "\nNo operation was selected. "\
"Select an operation (l d a f)");
quit(2);
break;
}
quit(0);
}
#endif
Reference in New Issue View Git Blame Copy Permalink