int main(int argc, char *argv[])
{
if (argc != 3)
invocation_error(argv[0], "[output file] [size]");
char *output_file = argv[1];
size_t records = atol(argv[2]);
size_t i, part_number, noun_count, adj_count;
char *nouns[NOUN_MAX], noun_file_content[NOUN_BYTES];
char *adjectives[ADJ_MAX], adj_file_content[ADJ_BYTES];
int rc;
Part p;
Parts db = new_db(CHUNK_SIZE);
noun_count = get_word_pointers(nouns, NOUN_FILE, noun_file_content, NOUN_BYTES);
adj_count = get_word_pointers(adjectives, ADJ_FILE, adj_file_content, ADJ_BYTES);
init_locale();
srand((unsigned int) time(NULL));
remove(output_file);
for (part_number = 0, i = 0; i < records; i++) {
part_number = jagged_sequence(part_number);
p = set_part(part_number,
random_part_name(nouns, noun_count, adjectives, adj_count),
random_int(),
random_int());
printf("%9ld: ", i + 1);
print_part(p);
if ((rc = insert_part(db, p))) {
fprintf(stderr, "%s: %d insert_part() failed: return code %d on iteration %ld\n",
__FILE__, __LINE__, rc, i);
destroy_db(db);
exit(EXIT_FAILURE);
}
if (i % CHUNK_SIZE == 0) {
if (flush_to_disk(output_file, db) != 0) {
destroy_db(db);
exit_error(argv[0], output_file);
}
}
}
if (flush_to_disk(output_file, db) != 0) {
destroy_db(db);
exit_error(argv[0], output_file);
}
destroy_db(db);
return 0;
}
krb5_error_code
krb5_db2_destroy(krb5_context context, char *conf_section, char **db_args)
{
krb5_error_code status = 0;
krb5_db2_context *db_ctx;
char *db_name;
if (k5db2_inited(context)) {
status = krb5_db2_fini(context);
if (status != 0)
return status;
}
krb5_clear_error_message(context);
status = configure_context(context, conf_section, db_args);
if (status != 0)
return status;
status = check_openable(context);
if (status != 0)
return status;
db_ctx = context->dal_handle->db_context;
db_name = gen_dbsuffix(db_ctx->db_name, db_ctx->tempdb ? "~" : "");
if (db_name == NULL)
return ENOMEM;
status = destroy_db(context, db_name);
free(db_name);
return status;
}
int
cmd_interactive(struct arguments *args)
{
int rc;
struct db *db;
char pass[MAX_PASS_LENGTH + 1];
rc = -1;
db = NULL;
if (!args->dbfile) {
fprintf(stderr, "missing db path\n");
goto out;
}
if (get_pass(PASS_PROMPT, pass, MAX_PASS_LENGTH + 1, stdin)) {
fprintf(stderr, "%s\n", GET_PASS_FAIL);
goto out;
}
if (!(db = pwsdb_open(pass, args->dbfile))) {
fprintf(stderr, "couldn't open db\n");
goto out;
}
rc = pwcurs_start(args->dbfile, pass, db);
print_db(db);
out:
destroy_db(db);
free(db);
return rc;
}
int
cmd_list(struct arguments *args)
{
int rc;
struct db *db;
char pass[MAX_PASS_LENGTH + 1];
rc = -1;
db = NULL;
if (!args->dbfile) {
fprintf(stderr, "%s\n", NO_DB_FILE);
goto out;
}
if (get_pass(PASS_PROMPT, pass, MAX_PASS_LENGTH + 1, stdin)) {
fprintf(stderr, "%s\n", GET_PASS_FAIL);
goto out;
}
if (!(db = pwsdb_open(pass, args->dbfile))) {
fprintf(stderr, "bad list\n");
goto out;
}
print_db(db);
rc = 0;
out:
destroy_db(db);
return rc;
}
void test_db(int n)
{
char *dir = Option.dir;
struct db db;
u64 key;
struct lump val;
u64 i;
int rc;
if (1) set_cleanup(cleanup);
create_db(dir);
db = open_db(dir);
for (i = 0; i < n; i++) {
key = randkey();
if (0) val = randlump();
if (1) val = key2lump(key);
//printf("%lld %*s %zd\n", key, val.size, (char *)val.d, strlen(val.d));
insert_db(&db, key, val);
}
if (1)
for (i = 0; i < n + 1; i++) {
rc = next_log(db.r);
if (rc == DONE)
break;
//printf("%lld %s\n", key_log(db.r), (char *)val_log(db.r).d);
}
if (1) merge_db(&db);
close_db(&db);
destroy_db(dir);
}
void
handle_signal(int signum)
{
int i;
putchar('\n');
if (signum) {
fprintf(stderr,
"WARNING: signal caught [code %i: %s]\n",
signum, strsignal(signum));
}
/* Perform a graceful shutdown of the system */
session_data.caught_signal = signum;
/* Send SIGTERM to every worker */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
if (session_data.thread_data[i].id != (pthread_t)(BANKING_FAILURE)) {
#ifndef NDEBUG
fprintf(stderr, "INFO: sending kill signal to worker thread\n");
#endif
pthread_kill(session_data.thread_data[i].id, SIGUSR1);
}
}
/* Now collect them */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
if (session_data.thread_data[i].id != (pthread_t)(BANKING_FAILURE)) {
if (pthread_join(session_data.thread_data[i].id, NULL)) {
session_data.thread_data[i].id = (pthread_t)(BANKING_FAILURE);
fprintf(stderr, "ERROR: failed to collect worker thread\n");
} else {
session_data.thread_data[i].id = (pthread_t)(BANKING_SUCCESS);
#ifndef NDEBUG
fprintf(stderr, "INFO: collected worker thread\n");
#endif
}
}
}
/* Do remaining housekeeping */
gcry_pthread_mutex_destroy((void **)(&session_data.accept_mutex));
gcry_pthread_mutex_destroy((void **)(&session_data.keystore_mutex));
destroy_socket(session_data.sock);
/* TODO remove shared memory code */
shutdown_crypto(old_shmid(&i));
if (shmctl(i, IPC_RMID, NULL)) {
fprintf(stderr, "WARNING: unable to remove shared memory segment\n");
}
destroy_db(BANKING_DB_FILE, session_data.db_conn);
/* Re-raise proper signals */
if (signum == SIGINT || signum == SIGTERM) {
sigemptyset(&session_data.signal_action.sa_mask);
session_data.signal_action.sa_handler = SIG_DFL;
sigaction(signum, &session_data.signal_action, NULL);
raise(signum);
}
}
int
cmd_insert(struct arguments *args)
{
int rc;
struct db *db;
char master_pass[MAX_PASS_LENGTH + 1];
char new_pass[MAX_PASS_LENGTH + 1];
uuid_t uuid;
rc = -1;
db = NULL;
if (!args->title || !args->dbfile) {
fprintf(stderr, "missing arguments for insert\n");
goto out;
}
if (get_pass(PASS_PROMPT, master_pass, MAX_PASS_LENGTH + 1, stdin)) {
fprintf(stderr, "%s\n", GET_PASS_FAIL);
goto out;
}
if (!(db = pwsdb_open(master_pass, args->dbfile))) {
perror("failed to open db");
goto out;
}
if (args->gen_pass) {
if (gen_pass(new_pass, DEFAULT_PASS_LENGTH, true)) {
fprintf(stderr, "failed to gen pass\n");
goto out;
}
} else if (get_pass("enter password for account:",
new_pass,
sizeof(new_pass)/sizeof(*new_pass),
stdin))
goto out;
if (pwsdb_add_record(db, args->title, new_pass, args->user, args->url, uuid)) {
fprintf(stderr, "failed to insert into db\n");
goto out;
}
if (pwsdb_save(db, master_pass, args->dbfile)) {
fprintf(stderr, "couldn't save db\n");
goto out;
}
rc = 0;
out:
destroy_db(db);
free(db);
return rc;
}
/*! \brief
* Module destroy function
*/
static void destroy(void)
{
free_all_udomains();
ul_destroy_locks();
/* free callbacks list */
destroy_ulcb_list();
free_service_route_buf();
free_impu_buf();
if (db_mode)
destroy_db();
}
int
cmd_kill(struct arguments *args)
{
int rc;
struct db *db;
char pass[MAX_PASS_LENGTH + 1];
rc = -1;
db = NULL;
if (uuid_is_null(args->uuid) || !args->dbfile) {
fprintf(stderr, "missing arguments for kill\n");
goto out;
}
if (get_pass(PASS_PROMPT, pass, MAX_PASS_LENGTH + 1, stdin)) {
fprintf(stderr, "%s\n", GET_PASS_FAIL);
goto out;
}
if (!(db = pwsdb_open(pass, args->dbfile))) {
fprintf(stderr, "couldn't open db\n");
goto out;
}
if (pwsdb_remove_record(db, args->uuid)) {
fprintf(stderr, "failed to remove entry from db\n");
goto out;
}
if (pwsdb_save(db, pass, args->dbfile)) {
fprintf(stderr, "couldn't save db");
goto out;
}
rc = 0;
out:
destroy_db(db);
free(db);
return rc;
}
int
cmd_retrieve(struct arguments *args)
{
int rc;
struct db *db;
char pass[MAX_PASS_LENGTH + 1], *fndpass;
rc = -1;
db = NULL;
if (uuid_is_null(args->uuid) || !args->dbfile) {
fprintf(stderr, "missing arguments for retrieve\n");
goto out;
}
if (get_pass(PASS_PROMPT, pass, MAX_PASS_LENGTH + 1, stdin)) {
fprintf(stderr, "%s\n", GET_PASS_FAIL);
goto out;
}
if (!(db = pwsdb_open(pass, args->dbfile))) {
fprintf(stderr, "couldn't open db\n");
goto out;
}
if (!(fndpass = pwsdb_get_pass(db, args->uuid))) {
fprintf(stderr, "couldn't find pass\n");
goto out;
}
pb_write(fndpass);
rc = 0;
out:
destroy_db(db);
free(db);
return rc;
}
int
main(int argc, char ** argv)
{
command_t cmd; int i;
char * in, * args, buffer[MAX_COMMAND_LENGTH];
struct sigaction thread_signal_action, old_signal_action;
struct thread_data_t * thread_datum;
/* Sanitize input */
if (argc != 2) {
fprintf(stderr, "USAGE: %s port\n", argv[0]);
return EXIT_FAILURE;
}
/* Crypto initialization */
if (init_crypto(new_shmid(&i))) {
fprintf(stderr, "FATAL: unable to enter secure mode\n");
return EXIT_FAILURE;
}
/* Database initialization */
if (init_db(BANKING_DB_FILE, &session_data.db_conn)) {
fprintf(stderr, "FATAL: unable to connect to database\n");
shutdown_crypto(old_shmid(&i));
return EXIT_FAILURE;
}
/* Socket initialization */
if ((session_data.sock = init_server_socket(argv[1])) < 0) {
fprintf(stderr, "FATAL: unable to start server\n");
destroy_db(BANKING_DB_FILE, session_data.db_conn);
shutdown_crypto(old_shmid(&i));
return EXIT_FAILURE;
}
/* Thread initialization */
gcry_pthread_mutex_init((void **)(&session_data.accept_mutex));
gcry_pthread_mutex_init((void **)(&session_data.keystore_mutex));
/* Save the old list of blocked signals for later */
pthread_sigmask(SIG_SETMASK, NULL, &old_signal_action.sa_mask);
/* Worker threads inherit this mask (ignore everything except SIGUSRs) */
memset(&thread_signal_action, '\0', sizeof(struct sigaction));
sigfillset(&thread_signal_action.sa_mask);
sigdelset(&thread_signal_action.sa_mask, SIGUSR1);
sigdelset(&thread_signal_action.sa_mask, SIGUSR2);
thread_signal_action.sa_handler = &handle_interruption;
pthread_sigmask(SIG_SETMASK, &thread_signal_action.sa_mask, NULL);
/* Afterwhich, all signals should be ignored in the handler */
sigfillset(&thread_signal_action.sa_mask);
/* Kick off the workers */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
/* Thread data initialization */
thread_datum = &session_data.thread_data[i];
memset(thread_datum, '\0', sizeof(struct thread_data_t));
thread_datum->sock = BANKING_FAILURE;
thread_datum->remote_addr_len = sizeof(thread_datum->remote_addr);
thread_datum->signal_action = &thread_signal_action;
if (pthread_create(&thread_datum->id, NULL, &handle_client,
thread_datum)) {
thread_datum->id = (pthread_t)(BANKING_FAILURE);
fprintf(stderr, "WARNING: unable to start worker thread\n");
}
}
/* Reset the signal mask to the prior behavior, and ignore SIGUSRs */
sigaddset(&old_signal_action.sa_mask, SIGUSR1);
sigaddset(&old_signal_action.sa_mask, SIGUSR2);
pthread_sigmask(SIG_SETMASK, &old_signal_action.sa_mask, NULL);
/* Session Signal initialization */
memset(&session_data.signal_action, '\0', sizeof(struct sigaction));
/* The signal handler should ignore SIGTERM and SIGINT */
sigemptyset(&session_data.signal_action.sa_mask);
sigaddset(&session_data.signal_action.sa_mask, SIGTERM);
sigaddset(&session_data.signal_action.sa_mask, SIGINT);
session_data.signal_action.sa_handler = &handle_signal;
/* Make sure any ignored signals remain ignored */
sigaction(SIGTERM, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGTERM, &session_data.signal_action, NULL);
}
sigaction(SIGINT, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGINT, &session_data.signal_action, NULL);
}
session_data.caught_signal = 0;
/* TODO tab-completion for commands */
rl_bind_key('\t', rl_insert);
/* Issue an interactive prompt, only quit on signal */
while (!session_data.caught_signal && (in = readline(SHELL_PROMPT))) {
/* Ignore empty strings */
if (*in != '\0') {
/* Add the original command to the shell history */
memset(buffer, '\0', MAX_COMMAND_LENGTH);
strncpy(buffer, in, MAX_COMMAND_LENGTH);
buffer[MAX_COMMAND_LENGTH - 1] = '\0';
for (i = 0; buffer[i] == ' '; ++i);
add_history(buffer + i);
/* Catch invalid commands prior to invocation */
if (validate_command(in, &cmd, &args)) {
fprintf(stderr, "ERROR: invalid command '%s'\n", in);
rl_ding();
} else {
/* Hook the command's return value to this signal */
session_data.caught_signal = ((cmd == NULL) || cmd(args));
}
}
free(in);
in = NULL;
}
/* Teardown */
handle_signal(0);
return EXIT_SUCCESS;
}
