static int delete_key_data(zone_db_t* zone, db_connection_t *dbconn, int sockfd) {
int successful;
key_data_list_t* key_data_list;
key_data_t* key_data;
key_state_list_t* key_state_list;
key_state_t* key_state;
/*
* Get key data for the zone and for each key data get the key state
* and try to delete all key state then the key data
*/
if (!(key_data_list = key_data_list_new_get_by_zone_id(dbconn, zone_db_id(zone)))) {
client_printf_err(sockfd, "Unable to get key data for zone %s from database!\n", zone_db_name(zone));
return 0;
}
successful = 1;
for (key_data = key_data_list_get_next(key_data_list); key_data; key_data_free(key_data), key_data = key_data_list_get_next(key_data_list)) {
if (!(key_state_list = key_state_list_new_get_by_key_data_id(dbconn, key_data_id(key_data)))) {
client_printf_err(sockfd, "Unable to get key states for key data %s of zone %s from database!\n", key_data_role_text(key_data), zone_db_name(zone));
successful = 0;
continue;
}
for (key_state = key_state_list_get_next(key_state_list); key_state; key_state_free(key_state), key_state = key_state_list_get_next(key_state_list)) {
if (key_state_delete(key_state)) {
client_printf_err(sockfd, "Unable to delete key state %s for key data %s of zone %s from database!\n", key_state_type_text(key_state), key_data_role_text(key_data), zone_db_name(zone));
successful = 0;
continue;
}
}
key_state_list_free(key_state_list);
if (key_data_delete(key_data)) {
client_printf_err(sockfd, "Unable to delete key data %s of zone %s from database!\n", key_data_role_text(key_data), zone_db_name(zone));
successful = 0;
continue;
}
if (hsm_key_factory_release_key_id(key_data_hsm_key_id(key_data), dbconn)) {
client_printf_err(sockfd, "Unable to release HSM key for key data %s of zone %s from database!\n", key_data_role_text(key_data), zone_db_name(zone));
successful = 0;
continue;
}
}
key_data_list_free(key_data_list);
return successful;
}
static int
run(int sockfd, cmdhandler_ctx_type* context, const char *cmd)
{
db_connection_t* dbconn = getconnectioncontext(context);
engine_type* engine = getglobalcontext(context);
(void)cmd;
if (!engine) {
return 1;
}
if (!engine->config) {
return 1;
}
if (!engine->config->zonelist_filename) {
return 1;
}
if (!dbconn) {
return 1;
}
ods_log_debug("[%s] %s command", module_str, zonelist_export_funcblock.cmdname);
if (zonelist_export(sockfd, dbconn, engine->config->zonelist_filename, 1) != ZONELIST_EXPORT_OK) {
ods_log_error("[%s] zonelist exported to %s failed", module_str, engine->config->zonelist_filename);
client_printf_err(sockfd, "Exported zonelist to %s failed!\n", engine->config->zonelist_filename);
return 1;
}
ods_log_info("[%s] zonelist exported to %s successfully", module_str, engine->config->zonelist_filename);
client_printf(sockfd, "Exported zonelist to %s successfully\n", engine->config->zonelist_filename);
return 0;
}
/**
* Combined error logging and writing to a file descriptor.
*
*/
void
ods_log_error_and_printf(int fd, const char *mod, const char *format, ...)
{
va_list ap;
char fmt[128];
char buf[ODS_SE_MAXLINE];
int ok;
/* first perform the ods_log_error */
ok = (snprintf(fmt, sizeof(fmt), "[%s] %s", mod, format) < (int)sizeof(fmt));
if (!ok) {
ods_log_error("[%s] snprintf buffer too small",file_str);
client_printf_err(fd, "error: snprintf buffer too small\n");
return;
}
va_start(ap, format);
ods_log_verror(fmt, ap);
va_end(ap);
/* then perform the ods_printf */
ok = (snprintf(fmt, sizeof(fmt), "error: %s\n", format) < (int)sizeof(fmt));
if (!ok) {
ods_log_error("[%s] snprintf buffer too small",file_str);
client_printf_err(fd, "error: snprintf buffer too small\n");
return;
}
va_start(ap, format);
ok = (vsnprintf(buf, ODS_SE_MAXLINE, fmt,ap) < ODS_SE_MAXLINE);
va_end(ap);
if (!ok) {
ods_log_error("[%s] vsnprintf buffer too small",file_str);
client_printf_err(fd, "error: vsnprintf buffer too small\n");
return;
}
client_printf(fd, "%s", buf);
}
static int
run(int sockfd, cmdhandler_ctx_type* context, const char *cmd)
{
#define NARGV 6
char* buf;
const char* argv[NARGV];
int argc = 0;
const char *zone_name2 = NULL;
int all = 0;
int write_xml = 0;
int long_index = 0, opt = 0;
zone_list_db_t* zone_list;
zone_db_t* zone;
int ret = 0;
char path[PATH_MAX];
char *signconf_del = NULL;
db_connection_t* dbconn = getconnectioncontext(context);;
engine_type* engine = getglobalcontext(context);
static struct option long_options[] = {
{"zone", required_argument, 0, 'z'},
{"all", no_argument, 0, 'a'},
{"xml", no_argument, 0, 'u'},
{0, 0, 0, 0}
};
ods_log_debug("[%s] %s command", module_str, zone_del_funcblock.cmdname);
if (!(buf = strdup(cmd))) {
client_printf_err(sockfd, "memory error\n");
return -1;
}
argc = ods_str_explode(buf, NARGV, argv);
if (argc == -1) {
client_printf_err(sockfd, "too many arguments\n");
ods_log_error("[%s] too many arguments for %s command",
module_str, zone_del_funcblock.cmdname);
free(buf);
return -1;
}
optind = 0;
while ((opt = getopt_long(argc, (char* const*)argv, "z:au", long_options, &long_index)) != -1) {
switch (opt) {
case 'z':
zone_name2 = optarg;
break;
case 'a':
all = 1;
break;
case 'u':
write_xml = 1;
break;
default:
client_printf_err(sockfd, "unknown arguments\n");
ods_log_error("[%s] unknown arguments for %s command",
module_str, zone_del_funcblock.cmdname);
free(buf);
return -1;
}
}
if (zone_name2 && !all) {
if (!(zone = zone_db_new_get_by_name(dbconn, zone_name2))) {
client_printf_err(sockfd, "Unable to delete zone, zone %s not found!\n", zone_name2);
free(buf);
return 1;
}
if (!delete_key_data(zone, dbconn, sockfd)) {
zone_db_free(zone);
free(buf);
return 1;
}
if (zone_db_delete(zone)) {
client_printf_err(sockfd, "Unable to delete zone %s from database!\n", zone_name2);
zone_db_free(zone);
free(buf);
return 1;
}
signconf_del = (char*) calloc(strlen(zone_db_signconf_path(zone)) +
strlen(".ZONE_DELETED") + 1, sizeof(char));
if (!signconf_del) {
ods_log_error("[%s] malloc failed", module_str);
zone_db_free(zone);
free(buf);
return 1;
}
strncpy(signconf_del, zone_db_signconf_path(zone), strlen(zone_db_signconf_path(zone)));
strncat(signconf_del, ".ZONE_DELETED", strlen(".ZONE_DELETED"));
rename(zone_db_signconf_path(zone), signconf_del);
free(signconf_del);
signconf_del = NULL;
/* Delete all 'zone' related tasks */
schedule_purge_owner(engine->taskq, TASK_CLASS_ENFORCER, zone_name2);
ods_log_info("[%s] zone %s deleted", module_str, zone_name2);
client_printf(sockfd, "Deleted zone %s successfully\n", zone_name2);
} else if (!zone_name2 && all) {
if (!(zone_list = zone_list_db_new_get(dbconn))) {
client_printf_err(sockfd, "Unable to get list of zones from database!\n");
free(buf);
return 1;
}
for (zone = zone_list_db_get_next(zone_list); zone; zone_db_free(zone), zone = zone_list_db_get_next(zone_list)) {
if (!delete_key_data(zone, dbconn, sockfd)) {
continue;
}
if (zone_db_delete(zone)) {
client_printf_err(sockfd, "Unable to delete zone %s from database!\n", zone_db_name(zone));
continue;
}
signconf_del = (char*) calloc(strlen(zone_db_signconf_path(zone)) +
strlen(".ZONE_DELETED") + 1, sizeof(char));
if (!signconf_del) {
ods_log_error("[%s] malloc failed", module_str);
zone_db_free(zone);
zone_list_db_free(zone_list);
free(buf);
return 1;
}
strncpy(signconf_del, zone_db_signconf_path(zone), strlen(zone_db_signconf_path(zone)));
strncat(signconf_del, ".ZONE_DELETED", strlen(".ZONE_DELETED"));
rename(zone_db_signconf_path(zone), signconf_del);
free(signconf_del);
signconf_del = NULL;
/* Delete all 'zone' related tasks */
schedule_purge_owner(engine->taskq, TASK_CLASS_ENFORCER, zone_db_name(zone));
ods_log_info("[%s] zone %s deleted", module_str, zone_db_name(zone));
client_printf(sockfd, "Deleted zone %s successfully\n", zone_db_name(zone));
}
zone_list_db_free(zone_list);
zone = NULL;
client_printf(sockfd, "All zones deleted successfully\n");
} else {
client_printf_err(sockfd, "expected either --zone <zone> or --all\n");
free(buf);
return -1;
}
free(buf);
if (write_xml) {
if (zone) {
if (zonelist_update_delete(sockfd, engine->config->zonelist_filename, zone, 1) != ZONELIST_UPDATE_OK) {
ods_log_error("[%s] zonelist %s updated failed", module_str, engine->config->zonelist_filename);
client_printf_err(sockfd, "Zonelist %s update failed!\n", engine->config->zonelist_filename);
ret = 1;
} else {
ods_log_info("[%s] zonelist %s updated successfully", module_str, engine->config->zonelist_filename);
client_printf(sockfd, "Zonelist %s updated successfully\n", engine->config->zonelist_filename);
}
} else {
if (zonelist_export(sockfd, dbconn, engine->config->zonelist_filename, 1) != ZONELIST_EXPORT_OK) {
ods_log_error("[%s] zonelist exported to %s failed", module_str, engine->config->zonelist_filename);
client_printf_err(sockfd, "Exported zonelist to %s failed!\n", engine->config->zonelist_filename);
ret = 1;
} else {
ods_log_info("[%s] zonelist exported to %s successfully", module_str, engine->config->zonelist_filename);
client_printf(sockfd, "Exported zonelist to %s successfully\n", engine->config->zonelist_filename);
}
}
}
if (zone) {
if (snprintf(path, sizeof(path), "%s/%s", engine->config->working_dir, OPENDNSSEC_ENFORCER_ZONELIST) >= (int)sizeof(path)
|| zonelist_update_delete(sockfd, path, zone, 0) != ZONELIST_UPDATE_OK)
{
ods_log_error("[%s] internal zonelist update failed", module_str);
client_printf_err(sockfd, "Unable to update the internal zonelist %s, updates will not reach the Signer!\n", path);
ret = 1;
} else {
ods_log_info("[%s] internal zonelist updated successfully", module_str);
}
} else {
if (snprintf(path, sizeof(path), "%s/%s", engine->config->working_dir, OPENDNSSEC_ENFORCER_ZONELIST) >= (int)sizeof(path)
|| zonelist_export(sockfd, dbconn, path, 0) != ZONELIST_EXPORT_OK)
{
ods_log_error("[%s] internal zonelist update failed", module_str);
client_printf_err(sockfd, "Unable to update the internal zonelist %s, updates will not reach the Signer!\n", path);
ret = 1;
} else {
ods_log_info("[%s] internal zonelist updated successfully", module_str);
}
}
zone_db_free(zone);
return ret;
}
static int
perform_keystate_list(int sockfd, db_connection_t *dbconn,
const char* filterZone, char** filterKeytype, char** filterKeystate,
void (printheader)(int sockfd),
void (printkey)(int sockfd, zone_t* zone, key_data_t* key, char*tchange, hsm_key_t* hsmKey)) {
key_data_list_t* key_list;
key_data_t* key;
zone_t *zone = NULL;
char* tchange;
hsm_key_t *hsmkey;
int cmp;
int i, skipPrintKey;
if (!(key_list = key_data_list_new_get(dbconn))) {
client_printf_err(sockfd, "Unable to get list of keys, memory "
"allocation or database error!\n");
return 1;
}
if (printheader) {
(*printheader)(sockfd);
}
while ((key = key_data_list_get_next(key_list))) {
/* only refetches zone if different from previous */
if (zone
&& (db_value_cmp(zone_id(zone), key_data_zone_id(key), &cmp)
|| cmp)) {
zone_free(zone);
zone = NULL;
}
if (!zone) {
zone = key_data_get_zone(key);
}
hsmkey = key_data_get_hsm_key(key);
key_data_cache_key_states(key);
tchange = map_keytime(zone, key); /* allocs */
skipPrintKey = 0;
if(printkey == NULL)
skipPrintKey = 1;
if(filterZone != NULL && strcmp(zone_name(zone), filterZone))
skipPrintKey = 1;
for(i=0; filterKeytype && filterKeytype[i]; i++)
if(!strcasecmp(filterKeytype[i],key_data_role_text(key)))
break;
if(filterKeytype && filterKeytype[i] == NULL)
skipPrintKey = 1;
for(i=0; filterKeystate && filterKeystate[i]; i++)
if(!strcasecmp(filterKeystate[i],map_keystate(key)))
break;
if(filterKeystate && filterKeystate[i] == NULL)
skipPrintKey = 1;
if (!skipPrintKey) {
(*printkey)(sockfd, zone, key, tchange, hsmkey);
}
free(tchange);
hsm_key_free(hsmkey);
key_data_free(key);
}
zone_free(zone);
key_data_list_free(key_list);
return 0;
}
