// журнал
cli_result_t parse4journal ( void *Journal, int argc, char **argv )
{
cli_arg_t JournalArgs[] =
{
{ "journal_file", 0, CLI_OPTIONAL_ARG, CLI_REQUIRED_VAL, __parse4journal_file, Journal },
{ "journal_flashback", 0, CLI_OPTIONAL_ARG, CLI_REQUIRED_VAL, __parse4journal_flashback, Journal },
CLI_LAST_ARG
};
return cli_parse ( JournalArgs, argc, argv );
}
// разбор флагов
static
cli_result_t parse4flag ( void *Flags, int argc, char **argv )
{
cli_arg_t FlagArgs[] =
{
{ "verbose", 0, CLI_OPTIONAL_ARG, CLI_NO_VAL, parse4flag_verbose, Flags },
{ "protocol", 0, CLI_OPTIONAL_ARG, CLI_NO_VAL, parse4flag_protocol, Flags },
{ "debug", 0, CLI_OPTIONAL_ARG, CLI_NO_VAL, parse4flag_debug, Flags },
CLI_LAST_ARG
};
return cli_parse ( FlagArgs, argc, argv );
}
static int multiple_in_flags()
{
const char *argv[] = {"exec_filename", "--force", "in_filename", "-o", "out_filename", "other_in_filename"};
int argc = 6;
cli_parse(argc, argv);
mu_assert(
strcmp(options->in_filename, "other_in_filename") == 0 &&
strcmp(options->out_filename, "out_filename") == 0 &&
options->gnuplot == 0 &&
options->force == 1 &&
options->quiet == 0
);
}
static int valid_mixed_flags()
{
const char *argv[] = {"exec_filename", "--force", "in_filename", "-g"};
int argc = 4;
cli_parse(argc, argv);
mu_assert(
strcmp(options->in_filename, "in_filename") == 0 &&
options->out_filename == NULL &&
options->gnuplot == 1 &&
options->force == 1 &&
options->quiet == 0
);
}
static int valid_simple_flags()
{
const char *argv[] = {"exec_filename", "-f", "-q", "--out", "out_filename"};
int argc = 5;
cli_parse(argc, argv);
mu_assert(
options->in_filename == NULL &&
strcmp(options->out_filename, "out_filename") == 0 &&
options->gnuplot == 0 &&
options->force == 1 &&
options->quiet == 1
);
}
static void
cli_command(struct cli *c)
{
struct config f;
int res;
if (config->cli_debug > 1)
log(L_TRACE "CLI: %s", c->rx_buf);
bzero(&f, sizeof(f));
f.mem = c->parser_pool;
cf_read_hook = cli_cmd_read_hook;
cli_rh_pos = c->rx_buf;
cli_rh_len = strlen(c->rx_buf);
cli_rh_trick_flag = 0;
this_cli = c;
lp_flush(c->parser_pool);
res = cli_parse(&f);
if (!res)
cli_printf(c, 9001, f.err_msg);
}
int
main(int argc, char * const argv[])
{
struct qnetd_instance instance;
struct qnetd_advanced_settings advanced_settings;
char *host_addr;
uint16_t host_port;
int foreground;
int debug_log;
int bump_log_priority;
enum tlv_tls_supported tls_supported;
int client_cert_required;
size_t max_clients;
PRIntn address_family;
int lock_file;
int another_instance_running;
if (qnetd_advanced_settings_init(&advanced_settings) != 0) {
errx(1, "Can't alloc memory for advanced settings");
}
cli_parse(argc, argv, &host_addr, &host_port, &foreground, &debug_log, &bump_log_priority,
&tls_supported, &client_cert_required, &max_clients, &address_family, &advanced_settings);
if (foreground) {
qnetd_log_init(QNETD_LOG_TARGET_STDERR);
} else {
qnetd_log_init(QNETD_LOG_TARGET_SYSLOG);
}
qnetd_log_set_debug(debug_log);
qnetd_log_set_priority_bump(bump_log_priority);
/*
* Daemonize
*/
if (!foreground) {
utils_tty_detach();
}
if ((lock_file = utils_flock(advanced_settings.lock_file, getpid(),
&another_instance_running)) == -1) {
if (another_instance_running) {
qnetd_log(LOG_ERR, "Another instance is running");
} else {
qnetd_log_err(LOG_ERR, "Can't acquire lock");
}
exit(1);
}
qnetd_log(LOG_DEBUG, "Initializing nss");
if (nss_sock_init_nss((tls_supported != TLV_TLS_UNSUPPORTED ?
advanced_settings.nss_db_dir : NULL)) != 0) {
qnetd_err_nss();
}
if (SSL_ConfigServerSessionIDCache(0, 0, 0, NULL) != SECSuccess) {
qnetd_err_nss();
}
if (qnetd_instance_init(&instance, tls_supported, client_cert_required,
max_clients, &advanced_settings) == -1) {
qnetd_log(LOG_ERR, "Can't initialize qnetd");
exit(1);
}
instance.host_addr = host_addr;
instance.host_port = host_port;
if (tls_supported != TLV_TLS_UNSUPPORTED && qnetd_instance_init_certs(&instance) == -1) {
qnetd_err_nss();
}
qnetd_log(LOG_DEBUG, "Initializing local socket");
if (qnetd_ipc_init(&instance) != 0) {
return (1);
}
qnetd_log(LOG_DEBUG, "Creating listening socket");
instance.server.socket = nss_sock_create_listen_socket(instance.host_addr,
instance.host_port, address_family);
if (instance.server.socket == NULL) {
qnetd_err_nss();
}
if (nss_sock_set_non_blocking(instance.server.socket) != 0) {
qnetd_err_nss();
}
if (PR_Listen(instance.server.socket, instance.advanced_settings->listen_backlog) !=
PR_SUCCESS) {
qnetd_err_nss();
}
global_instance = &instance;
signal_handlers_register();
qnetd_log(LOG_DEBUG, "Registering algorithms");
if (qnetd_algorithm_register_all() != 0) {
exit(1);
}
qnetd_log(LOG_DEBUG, "QNetd ready to provide service");
/*
* MAIN LOOP
*/
while (qnetd_poll(&instance) == 0) {
}
/*
* Cleanup
*/
qnetd_ipc_destroy(&instance);
if (PR_Close(instance.server.socket) != PR_SUCCESS) {
qnetd_warn_nss();
}
CERT_DestroyCertificate(instance.server.cert);
SECKEY_DestroyPrivateKey(instance.server.private_key);
SSL_ClearSessionCache();
SSL_ShutdownServerSessionIDCache();
qnetd_instance_destroy(&instance);
qnetd_advanced_settings_destroy(&advanced_settings);
if (NSS_Shutdown() != SECSuccess) {
qnetd_warn_nss();
}
if (PR_Cleanup() != PR_SUCCESS) {
qnetd_warn_nss();
}
qnetd_log_close();
return (0);
}
int
main(int argc, char * const argv[])
{
struct qdevice_instance instance;
struct qdevice_advanced_settings advanced_settings;
int foreground;
int force_debug;
int lock_file;
int another_instance_running;
if (qdevice_advanced_settings_init(&advanced_settings) != 0) {
errx(1, "Can't alloc memory for advanced settings");
}
cli_parse(argc, argv, &foreground, &force_debug, &advanced_settings);
qdevice_instance_init(&instance, &advanced_settings);
qdevice_cmap_init(&instance);
qdevice_log_init(&instance, force_debug);
/*
* Daemonize
*/
if (!foreground) {
utils_tty_detach();
}
if ((lock_file = utils_flock(advanced_settings.lock_file, getpid(),
&another_instance_running)) == -1) {
if (another_instance_running) {
qdevice_log(LOG_ERR, "Another instance is running");
} else {
qdevice_log_err(LOG_ERR, "Can't acquire lock");
}
exit(1);
}
qdevice_log(LOG_DEBUG, "Initializing votequorum");
qdevice_votequorum_init(&instance);
qdevice_log(LOG_DEBUG, "Initializing local socket");
if (qdevice_ipc_init(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Registering qdevice models");
qdevice_model_register_all();
qdevice_log(LOG_DEBUG, "Configuring qdevice");
if (qdevice_instance_configure_from_cmap(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Configuring master_wins");
if (qdevice_votequorum_master_wins(&instance, (advanced_settings.master_wins ==
QDEVICE_ADVANCED_SETTINGS_MASTER_WINS_FORCE_ON ? 1 : 0)) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Getting configuration node list");
if (qdevice_cmap_store_config_node_list(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Initializing qdevice model");
if (qdevice_model_init(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Initializing cmap tracking");
if (qdevice_cmap_add_track(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Waiting for ring id");
if (qdevice_votequorum_wait_for_ring_id(&instance) != 0) {
return (1);
}
global_instance = &instance;
signal_handlers_register();
qdevice_log(LOG_DEBUG, "Running qdevice model");
if (qdevice_model_run(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Removing cmap tracking");
if (qdevice_cmap_del_track(&instance) != 0) {
return (1);
}
qdevice_log(LOG_DEBUG, "Destroying qdevice model");
qdevice_model_destroy(&instance);
qdevice_ipc_destroy(&instance);
qdevice_votequorum_destroy(&instance);
qdevice_cmap_destroy(&instance);
qdevice_log_close(&instance);
qdevice_instance_destroy(&instance);
qdevice_advanced_settings_destroy(&advanced_settings);
return (0);
}
/********************************************************************
* FUNCTION agt_cli_process_input
*
* Process the param line parameters against the hardwired
* parmset for the netconfd program
*
* INPUTS:
* argc == argument count
* argv == array of command line argument strings
* agt_profile == agent profile struct to fill in
* showver == address of version return quick-exit status
* showhelpmode == address of help return quick-exit status
*
* OUTPUTS:
* *agt_profile is filled in, with parms gathered or defaults
* *showver == TRUE if user requsted version quick-exit mode
* *showhelpmode == requested help mode
* (none, breief, normal, full)
*
* RETURNS:
* NO_ERR if all goes well
*********************************************************************/
status_t
agt_cli_process_input (int argc,
char *argv[],
agt_profile_t *agt_profile,
boolean *showver,
help_mode_t *showhelpmode)
{
ncx_module_t *mod;
obj_template_t *obj;
val_value_t *valset, *val;
FILE *fp;
status_t res;
boolean test;
#ifdef DEBUG
if (!argv || !agt_profile || !showver || !showhelpmode) {
return SET_ERROR(ERR_INTERNAL_PTR);
}
#endif
*showver = FALSE;
*showhelpmode = HELP_MODE_NONE;
/* find the parmset definition in the registry */
obj = NULL;
mod = ncx_find_module(AGT_CLI_MODULE, NULL);
if (mod) {
obj = ncx_find_object(mod, AGT_CLI_CONTAINER);
}
if (!obj) {
log_error("\nError: netconfd module with CLI definitions not loaded");
return ERR_NCX_NOT_FOUND;
}
/* parse the command line against the object template */
res = NO_ERR;
valset = NULL;
if (argc > 0) {
valset = cli_parse(NULL,
argc,
argv,
obj,
FULLTEST,
PLAINMODE,
TRUE,
CLI_MODE_PROGRAM,
&res);
if (res != NO_ERR) {
if (valset) {
val_free_value(valset);
}
return res;
}
}
if (valset != NULL) {
/* transfer the parmset values */
set_server_profile(valset, agt_profile);
/* next get any params from the conf file */
val = val_find_child(valset,
AGT_CLI_MODULE,
NCX_EL_CONFIG);
if (val) {
if (val->res == NO_ERR) {
/* try the specified config location */
agt_profile->agt_conffile = VAL_STR(val);
res = conf_parse_val_from_filespec(VAL_STR(val),
valset,
TRUE,
TRUE);
if (res != NO_ERR) {
val_free_value(valset);
return res;
} else {
/* transfer the parmset values again */
set_server_profile(valset, agt_profile);
}
}
} else {
fp = fopen((const char *)AGT_DEF_CONF_FILE, "r");
if (fp != NULL) {
fclose(fp);
/* use default config location */
res = conf_parse_val_from_filespec(AGT_DEF_CONF_FILE,
valset,
TRUE,
TRUE);
if (res != NO_ERR) {
val_free_value(valset);
return res;
} else {
/* transfer the parmset values again */
set_server_profile(valset, agt_profile);
}
}
}
/* set the logging control parameters */
val_set_logging_parms(valset);
/* audit-log-append param */
val = val_find_child(valset,
AGT_CLI_MODULE,
NCX_EL_AUDIT_LOG_APPEND);
if (val && val->res == NO_ERR) {
test = TRUE;
} else {
test = FALSE;
}
/* audit-log param */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_AUDIT_LOG);
if (val && val->res == NO_ERR) {
xmlChar *filespec = ncx_get_source(VAL_STR(val), &res);
if (filespec == NULL) {
log_error("\nError: get source for audit log failed");
return res;
}
res = log_audit_open((const char *)filespec, test, TRUE);
if (res == NO_ERR) {
if (LOGDEBUG) {
log_debug("\nAudit log '%s' opened for %s",
filespec,
(test) ? "append" : "write");
}
} else {
log_error("\nError: open audit log '%s' failed",
filespec);
}
m__free(filespec);
if (res != NO_ERR) {
return res;
}
}
/* set the file search path parms */
res = val_set_path_parms(valset);
if (res != NO_ERR) {
return res;
}
/* set the warning control parameters */
res = val_set_warning_parms(valset);
if (res != NO_ERR) {
return res;
}
/* set the feature code generation parameters */
res = val_set_feature_parms(valset);
if (res != NO_ERR) {
return res;
}
/* check the subdirs parameter */
res = val_set_subdirs_parm(valset);
if (res != NO_ERR) {
return res;
}
/* check the protocols parameter */
res = val_set_protocols_parm(valset);
if (res != NO_ERR) {
return res;
}
/* check the system-sorted param */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_SYSTEM_SORTED);
if (val && val->res == NO_ERR) {
agt_profile->agt_system_sorted = VAL_BOOL(val);
}
/* version param handled externally */
/* check if version mode requested */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_VERSION);
*showver = (val) ? TRUE : FALSE;
/* check if help mode requested */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_HELP);
if (val) {
*showhelpmode = HELP_MODE_NORMAL;
/* help submode parameter (brief/normal/full) */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_BRIEF);
if (val) {
*showhelpmode = HELP_MODE_BRIEF;
} else {
/* full parameter */
val = val_find_child(valset, AGT_CLI_MODULE, NCX_EL_FULL);
if (val) {
*showhelpmode = HELP_MODE_FULL;
}
}
}
}
/* cleanup and exit
* handoff the malloced 'valset' memory here
*/
cli_val = valset;
return res;
} /* agt_cli_process_input */
int
main(int argc, char * const argv[])
{
enum qnetd_tool_operation operation;
int verbose;
char *cluster_name;
char *socket_path;
int sock_fd;
FILE *sock;
struct dynar send_str;
int res;
int exit_code;
exit_code = QNETD_TOOL_EXIT_CODE_NO_ERROR;
cli_parse(argc, argv, &operation, &verbose, &cluster_name, &socket_path);
dynar_init(&send_str, QNETD_DEFAULT_IPC_MAX_RECEIVE_SIZE);
sock_fd = unix_socket_client_create(socket_path, 0);
if (sock_fd == -1) {
err(QNETD_TOOL_EXIT_CODE_SOCKET_CONNECT,
"Can't connect to qnetd socket (is QNetd running?)");
}
sock = fdopen(sock_fd, "w+t");
if (sock == NULL) {
err(QNETD_TOOL_EXIT_CODE_INTERNAL_ERROR, "Can't open QNetd socket fd");
}
if (store_command(&send_str, operation, verbose, cluster_name) != 0) {
errx(QNETD_TOOL_EXIT_CODE_INTERNAL_ERROR, "Can't store command");
}
if (fprintf(sock, "%s", dynar_data(&send_str)) != strlen(dynar_data(&send_str)) ||
fflush(sock) != 0) {
errx(QNETD_TOOL_EXIT_CODE_INTERNAL_ERROR, "Can't send command");
}
res = read_ipc_reply(sock);
switch (res) {
case -1:
errx(QNETD_TOOL_EXIT_CODE_INTERNAL_ERROR, "Internal error during IPC status line read");
break;
case 0:
break;
case 1:
exit_code = QNETD_TOOL_EXIT_CODE_QNETD_RETURNED_ERROR;
break;
case 2:
errx(QNETD_TOOL_EXIT_CODE_SOCKET_CONNECT, "Unknown status line returned by IPC server");
break;
}
if (fclose(sock) != 0) {
warn("Can't close QNetd socket");
}
free(cluster_name);
free(socket_path);
dynar_destroy(&send_str);
return (exit_code);
}
