int main(int argc, char *argv[])
{
struct match *list, *match;
struct pci_domain *pci_domain;
openconsole(&dev_null_r, &dev_stdcon_w);
pci_domain = pci_scan();
if (pci_domain) {
list = parse_config(argc < 2 ? NULL : argv[1]);
match = find_pci_device(pci_domain, list);
if (match)
syslinux_run_command(match->filename);
}
/* On error, return to the command line */
fputs("Error: no recognized network card found!\n", stderr);
return 1;
}
static int load_module(void)
{
int res = 0;
if (parse_config(0))
return AST_MODULE_LOAD_DECLINE;
res |= ast_register_translator(&speextolin);
res |= ast_register_translator(&lintospeex);
res |= ast_register_translator(&speexwbtolin16);
res |= ast_register_translator(&lin16tospeexwb);
res |= ast_register_translator(&speexuwbtolin32);
res |= ast_register_translator(&lin32tospeexuwb);
if (res) {
unload_module();
return res;
}
return res;
}
int init_config ()
{
FILE *f;
int returnedValue;
gconfig.port = UDP_LISTEN_PORT;
gconfig.sarefnum = IP_IPSEC_REFINFO; /* default use the latest we know */
gconfig.listenaddr = htonl(INADDR_ANY); /* Default is to bind (listen) to all interfaces */
gconfig.debug_avp = 0;
gconfig.debug_network = 0;
gconfig.packet_dump = 0;
gconfig.debug_tunnel = 0;
gconfig.debug_state = 0;
lnslist = NULL;
laclist = NULL;
deflac = (struct lac *) calloc (1, sizeof (struct lac));
f = fopen (gconfig.configfile, "r");
if (!f)
{
f = fopen (gconfig.altconfigfile, "r");
if (f)
{
l2tp_log (LOG_WARNING, "%s: Using old style config files %s and %s\n",
__FUNCTION__, gconfig.altconfigfile, gconfig.altauthfile);
strncpy (gconfig.authfile, gconfig.altauthfile,
sizeof (gconfig.authfile));
}
else
{
l2tp_log (LOG_CRIT, "%s: Unable to open config file %s or %s\n",
__FUNCTION__, gconfig.configfile, gconfig.altconfigfile);
return -1;
}
}
returnedValue = parse_config (f);
fclose (f);
return (returnedValue);
}
int lxc_read_seccomp_config(struct lxc_conf *conf)
{
FILE *f;
int ret;
if (!conf->seccomp)
return 0;
#if HAVE_SCMP_FILTER_CTX
/* XXX for debug, pass in SCMP_ACT_TRAP */
conf->seccomp_ctx = seccomp_init(SCMP_ACT_ERRNO(31));
ret = !conf->seccomp_ctx;
#else
ret = seccomp_init(SCMP_ACT_ERRNO(31)) < 0;
#endif
if (ret) {
ERROR("failed initializing seccomp");
return -1;
}
/* turn of no-new-privs. We don't want it in lxc, and it breaks
* with apparmor */
if (seccomp_attr_set(
#if HAVE_SCMP_FILTER_CTX
conf->seccomp_ctx,
#endif
SCMP_FLTATR_CTL_NNP, 0)) {
ERROR("failed to turn off n-new-privs\n");
return -1;
}
f = fopen(conf->seccomp, "r");
if (!f) {
SYSERROR("failed to open seccomp policy file %s\n", conf->seccomp);
return -1;
}
ret = parse_config(f, conf);
fclose(f);
return ret;
}
int main(int argc, char **argv)
{
int err = 0;
lua_State *L;
setup_signal_handler();
/* ini file sets defaults for arguments*/
parse_config(inifile);
if (!global.inifile) {
log_error("could not open ini configuration %s\n", inifile);
}
/* parse arguments again, to override ini file */
parse_args(argc, argv, &err);
log_open(logfile);
locale_init();
#ifdef CRTDBG
init_crtdbg();
#endif
L = lua_init();
game_init();
bind_monsters(L);
err = eressea_run(L, luafile);
if (err) {
log_error("script %s failed with code %d\n", luafile, err);
return err;
}
#ifdef MSPACES
malloc_stats();
#endif
game_done();
lua_done(L);
log_close();
if (global.inifile) {
iniparser_freedict(global.inifile);
}
return 0;
}
terrain_builder::terrain_builder(const config& level,
const gamemap* m, const std::string& offmap_image) :
map_(m),
tile_map_(map().w(), map().h()),
terrain_by_type_()
{
image::precache_file_existence("terrain/");
if(building_rules_.empty() && rules_cfg_){
// parse global terrain rules
parse_global_config(*rules_cfg_);
} else {
// use cached global rules but clear local rules
flush_local_rules();
}
// parse local rules
parse_config(level);
add_off_map_rule(offmap_image);
build_terrains();
}
void
read_config(FILE *conf)
{
struct stat stat_buf;
long size;
int sts;
size_t nread;
/* get length of file */
sts = fstat(fileno(conf), &stat_buf);
if (sts < 0) {
(void)fprintf(stderr, "%s: Failure to stat configuration file \"%s\": %s\n",
pmProgname, configfile, osstrerror());
exit(1);
}
size = (long)stat_buf.st_size;
/* create buffer */
conf_buffer = (char*)malloc(size+1*sizeof(char));
if (conf_buffer == NULL) {
(void)fprintf(stderr, "%s: Failure to create buffer for configuration file \"%s\"\n",
pmProgname, configfile);
exit(1);
}
conf_buffer_ptr = conf_buffer;
/* read whole file into buffer */
nread = fread(conf_buffer, sizeof(char), size, conf);
if (nread != size) {
(void)fprintf(stderr, "%s: Failure to read configuration file \"%s\" into buffer\n",
pmProgname, configfile);
exit(1);
}
conf_buffer[size] = '\0'; /* terminate the buffer */
if (parse_config(&the_tree) != 0)
exit(1);
}
int main(int ac, char *av[]) {
int rv = 0;
int sfd = setup_signalfd();
struct config *config = parse_config("amtredird.ini");
if (config && validate_config(config)) {
if (init_amt(config)) {
if (sfd != -1) {
rv = (run_server(config, sfd) == 0);
} else {
rv = 1;
}
teardown_amt(config);
}
} else {
rv = 1;
}
close(sfd);
free_config(config);
return rv;
}
int main (int argc, char **argv) {
signal (SIGSEGV, sig_segv_handler);
signal (SIGABRT, sig_abrt_handler);
log_level = 10;
args_parse (argc, argv);
printf (
"Telegram-client version " TG_VERSION ", Copyright (C) 2013 Vitaly Valtman\n"
"Telegram-client comes with ABSOLUTELY NO WARRANTY; for details type `show_license'.\n"
"This is free software, and you are welcome to redistribute it\n"
"under certain conditions; type `show_license' for details.\n"
);
running_for_first_time ();
parse_config ();
get_terminal_attributes ();
#ifdef USE_LUA
if (lua_file) {
lua_init (lua_file);
}
#endif
#ifdef USE_PYTHON
if (python_file) {
python_init(python_file);
}
#endif
inner_main ();
#ifdef USE_PYTHON
if (python_file) {
python_finalize();
}
#endif
return 0;
}
char *
conf_aliases(char *cfgpath)
{
struct table *table;
char *path;
char *p;
if (parse_config(env, cfgpath, 0))
exit(1);
table = table_find("aliases", NULL);
if (table == NULL)
return (PATH_ALIASES);
path = xstrdup(table->t_config, "conf_aliases");
p = strstr(path, ".db");
if (p == NULL || strcmp(p, ".db") != 0) {
return (path);
}
*p = '\0';
return (path);
}
int main(int argc, char **argv)
{
if (argc < 2)
{
printf("argc < 2\n");
return 0;
}
if (0 != parse_config(argv[1]))
return 0;
//fio_register_handler(FIO_CBF_SINGLE_THREAD, single_mode_handle);
//fio_register_handler(IPPROTO_UDP, handle_audp);
switch (sysconfig.single_thread)
{
case FIO_MODE_1_SND_OR_RCV /*2*/:
fio_register_handler(T_FIO_PKT_INTD, handle_dns_resp);
break;
case FIO_MODE_2CARDS /*3*/:
fio_register_handler(T_FIO_PKT_INTD, handle_udps_2cards);
break;
case FIO_MODE_N_BRG_OUT /*4*/:
fio_register_handler(T_FIO_PKT_INTD, handle_udps);
break;
default:
fio_register_handler(T_FIO_PKT_INTD, handle_udps_in);
break;
}
if (0 != fio_init() || 0 != fio_start())
return 0;
signal(SIGINT, fio_sigint_h);
fio_start_statistics();
fio_wait();
fio_shutdown();
return 0;
}
/*
* Initialize slog library. Function parses config file and reads log
* level and save to file flag from config. First argument is file name
* where log will be saved and second argument conf is config file path
* to be parsedand third argument lvl is log level for this message.
*/
void slog_init(const char* fname, const char* conf, int lvl, int flvl, int t_safe)
{
int status = 0;
/* Set up default values */
slg.level = lvl;
slg.file_level = flvl;
slg.to_file = 0;
slg.pretty = 0;
slg.filestamp = 1;
slg.td_safe = t_safe;
/* Init mutex sync */
if (t_safe)
{
/* Init mutex attribute */
pthread_mutexattr_t m_attr;
if (pthread_mutexattr_init(&m_attr) ||
pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE) ||
pthread_mutex_init(&slog_mutex, &m_attr) ||
pthread_mutexattr_destroy(&m_attr))
{
printf("<%s:%d> %s: [ERROR] Can not initialize mutex: %d\n",
__FILE__, __LINE__, __FUNCTION__, errno);
slg.td_safe = 0;
}
}
/* Parse config file */
if (conf != NULL)
{
slg.fname = fname;
status = parse_config(conf);
}
/* Handle config parser status */
if (!status) slog(0, SLOG_INFO, "Initializing logger values without config");
else slog(0, SLOG_INFO, "Loading logger config from: %s", conf);
}
void read_config(char* file)
{
GKeyFile *config;
char *cur = hciattach_options;
const char *end = hciattach_options + sizeof(hciattach_options);
/* set first default values and then load configured ones */
init_config();
config = load_config(file);
parse_config(config);
load_bd_add();
/* set always configured options: use same configured baud-rate also for download, and ignore first 2 bytes (needed by bcm43341 and more recent brcm bt chip) */
cur += snprintf(cur, end-cur, "%s", "--use_baudrate_for_download --no2bytes");
/* concatenate configured options */
if ((cur < end) && (main_opts.enable_fork)) {
cur += snprintf(cur, end-cur," %s", "--enable_fork");
}
if ((cur < end) && (main_opts.enable_lpm)) {
cur += snprintf(cur, end-cur," %s", "--enable_lpm");
}
if ((cur < end) && (main_opts.enable_hci)) {
cur += snprintf(cur, end-cur," %s", "--enable_hci");
}
if ((cur < end) && (main_opts.set_baud_rate)) {
cur += snprintf(cur, end-cur," --baudrate %d", main_opts.baud_rate);
}
if ((cur < end) && (main_opts.dl_patch)) {
cur += snprintf(cur, end-cur," --patchram %s", main_opts.fw_patch);
}
if ((cur < end) && (main_opts.set_bd)) {
cur += snprintf(cur, end-cur," --bd_addr %s", main_opts.bd_add);
}
if ((cur < end) && (main_opts.set_scopcm)) {
cur += snprintf(cur, end-cur," --scopcm %s", main_opts.scopcm);
}
}
bool Config::read_from_sd()
{
Serial.print("Reading config from '");
Serial.print(CONFIG_FILE);
Serial.println("'...");
File configFile = SD.open(CONFIG_FILE);
if(!configFile) {
Serial.print("Unable to open config file '");
Serial.print(CONFIG_FILE);
Serial.println("'!");
return false;
}
String config;
while(configFile.available()) {
config += configFile.readString();
}
configFile.close();
return parse_config(config);
}
static struct acl_data* load_acl(const char* config, struct plugin_handle* handle)
{
struct acl_data* data = parse_config(config);
if (!data)
return 0;
if (!data->file || !*data->file)
{
free_acl(data); data = 0;
set_error_message(handle, "No configuration file given, missing \"file=<filename>\" configuration option.");
return 0;
}
if (file_read_lines(data->file, data->users, &parse_line) == -1)
{
fprintf(stderr, "Unable to load %s\n", data->file);
set_error_message(handle, "Unable to load file");
}
return data;
}
void main_initialize(char *arg1, char *arg2) {
struct stat st; /* buffer for stat */
ssl_init(); /* initialize SSL library */
sthreads_init(); /* initialize critical sections & SSL callbacks */
parse_config(arg1, arg2);
log_open();
s_log(LOG_NOTICE, "%s", stunnel_info());
/* check if certificate exists */
if(!options.key) /* key file not specified */
options.key=options.cert;
if(options.option.cert) {
if(stat(options.key, &st)) {
ioerror(options.key);
exit(1);
}
#ifndef USE_WIN32
if(st.st_mode & 7)
s_log(LOG_WARNING, "Wrong permissions on %s", options.key);
#endif /* defined USE_WIN32 */
}
}
static void traverse_layout(GenerateWebsiteWorkspace *workspace, xmlNodePtr node) {
CongNodePtr child;
g_assert(node);
g_message("traverse_layout <%s>", node->name);
for (child=node->children; child; child=child->next) {
if (cong_node_is_element(child, NULL, "config")) {
parse_config(workspace, child);
} else if (cong_node_is_element(child, NULL, "copyright")) {
parse_copyright(workspace, child);
} else if (cong_node_is_element(child, NULL, "headlink")) {
parse_headlink(workspace, child);
} else if (cong_node_is_element(child, NULL, "style")) {
parse_style(workspace, child);
} else if (cong_node_is_element(child, NULL, "toc")) {
parse_toc(workspace, child);
} else if (cong_node_is_element(child, NULL, "notoc")) {
parse_notoc(workspace, child);
}
}
}
int tmain (int argc, char **argv) {
// signal (SIGSEGV, sig_segv_handler);
// signal (SIGABRT, sig_abrt_handler);
log_level = 10;
args_parse (argc, argv);
running_for_first_time ();
parse_config ();
get_terminal_attributes ();
#ifdef USE_LUA
if (lua_file) {
lua_init (lua_file);
}
#endif
inner_main ();
return 0;
}
void terrain_builder::add_off_map_rule(const std::string& image)
{
// Build a config object
config cfg;
config &item = cfg.add_child("terrain_graphics");
config &tile = item.add_child("tile");
tile["x"] = "0";
tile["y"] = "0";
tile["type"] = t_translation::write_terrain_code(t_translation::OFF_MAP_USER);
config &tile_image = tile.add_child("image");
tile_image["layer"] = "-1000";
tile_image["name"] = image;
item["probability"] = "100";
item["no_flag"] = "base";
item["set_flag"] = "base";
// Parse the object
parse_config(cfg);
}
int main(int argc, char **argv)
{
int err = 0;
lua_State *L;
dictionary *d = 0;
setup_signal_handler();
message_handle_missing(MESSAGE_MISSING_REPLACE);
/* parse arguments again, to override ini file */
err = parse_args(argc, argv);
if (err != 0) {
return (err > 0) ? 0 : err;
}
d = parse_config(inifile);
if (!d) {
log_error("could not open ini configuration %s\n", inifile);
}
locale_init();
L = lua_init(d);
game_init();
bind_monsters(L);
err = eressea_run(L, luafile);
if (err) {
log_error("script %s failed with code %d\n", luafile, err);
return err;
}
game_done();
lua_done(L);
log_close();
stats_write(stdout, "");
stats_close();
if (d) {
iniparser_freedict(d);
}
return 0;
}
/*
*
* schedinit - initialize conf struct and parse conf files
*
* argc - passed in from main
* argv - passed in from main
*
* Returns Success/Failure
*
*
*/
int schedinit(int argc, char *argv[])
{
init_config();
parse_config(CONFIG_FILE);
parse_holidays(HOLIDAYS_FILE);
time(&(cstat.current_time));
if (is_prime_time())
init_prime_time();
else
init_non_prime_time();
parse_ded_file(DEDTIME_FILE);
/* preload the static members to the fairshare tree */
preload_tree();
parse_group(RESGROUP_FILE);
calc_fair_share_perc(conf.group_root -> child, UNSPECIFIED);
if (conf.prime_fs || conf.non_prime_fs)
{
read_usage();
/*
* initialize the last_decay to the current time, since we do not know when
* the last decay happened
*/
last_sync = last_decay = cstat.current_time;
}
token_acct_open((char *)0);
return 0;
}
static int load_module(void)
{
int res = 0;
if (parse_config(0))
return AST_MODULE_LOAD_DECLINE;
ast_format_set(&speextolin.src_format, AST_FORMAT_SPEEX, 0);
ast_format_set(&speextolin.dst_format, AST_FORMAT_SLINEAR, 0);
ast_format_set(&lintospeex.src_format, AST_FORMAT_SLINEAR, 0);
ast_format_set(&lintospeex.dst_format, AST_FORMAT_SPEEX, 0);
ast_format_set(&speexwbtolin16.src_format, AST_FORMAT_SPEEX16, 0);
ast_format_set(&speexwbtolin16.dst_format, AST_FORMAT_SLINEAR16, 0);
ast_format_set(&lin16tospeexwb.src_format, AST_FORMAT_SLINEAR16, 0);
ast_format_set(&lin16tospeexwb.dst_format, AST_FORMAT_SPEEX16, 0);
ast_format_set(&speexuwbtolin32.src_format, AST_FORMAT_SPEEX32, 0);
ast_format_set(&speexuwbtolin32.dst_format, AST_FORMAT_SLINEAR32, 0);
ast_format_set(&lin32tospeexuwb.src_format, AST_FORMAT_SLINEAR32, 0);
ast_format_set(&lin32tospeexuwb.dst_format, AST_FORMAT_SPEEX32, 0);
res |= ast_register_translator(&speextolin);
res |= ast_register_translator(&lintospeex);
res |= ast_register_translator(&speexwbtolin16);
res |= ast_register_translator(&lin16tospeexwb);
res |= ast_register_translator(&speexuwbtolin32);
res |= ast_register_translator(&lin32tospeexuwb);
return res;
}
static int load_module(void)
{
if(!parse_config())
return AST_MODULE_LOAD_DECLINE;
ast_mutex_lock(&pgsql_lock);
if (!pgsql_reconnect(NULL)) {
ast_log(LOG_WARNING,
"Postgresql RealTime: Couldn't establish connection. Check debug.\n");
ast_log(LOG_DEBUG, "Postgresql RealTime: Cannot Connect: %s\n",
PQerrorMessage(pgsqlConn));
}
ast_config_engine_register(&pgsql_engine);
if (option_verbose) {
ast_verbose("Postgresql RealTime driver loaded.\n");
}
ast_cli_register_multiple(cli_realtime, sizeof(cli_realtime) / sizeof(struct ast_cli_entry));
ast_mutex_unlock(&pgsql_lock);
return 0;
}
bool
reload_config(t_configuration_options *orig_options)
{
PGconn *conn;
t_configuration_options new_options;
bool config_changed = false;
/*
* Re-read the configuration file: repmgr.conf
*/
log_info(_("reloading configuration file and updating repmgr tables\n"));
parse_config(&new_options);
if (new_options.node == -1)
{
log_warning(_("unable to parse new configuration, retaining current configuration\n"));
return false;
}
if (strcmp(new_options.cluster_name, orig_options->cluster_name) != 0)
{
log_warning(_("unable to change cluster name, retaining current configuration\n"));
return false;
}
if (new_options.node != orig_options->node)
{
log_warning(_("unable to change node ID, retaining current configuration\n"));
return false;
}
if (strcmp(new_options.node_name, orig_options->node_name) != 0)
{
log_warning(_("unable to change standby name, keeping current configuration\n"));
return false;
}
if (new_options.failover != MANUAL_FAILOVER && new_options.failover != AUTOMATIC_FAILOVER)
{
log_warning(_("new value for 'failover' must be 'automatic' or 'manual'\n"));
return false;
}
if (new_options.master_response_timeout <= 0)
{
log_warning(_("new value for 'master_response_timeout' must be greater than zero\n"));
return false;
}
if (new_options.reconnect_attempts < 0)
{
log_warning(_("new value for 'reconnect_attempts' must be zero or greater\n"));
return false;
}
if (new_options.reconnect_interval < 0)
{
log_warning(_("new value for 'reconnect_interval' must be zero or greater\n"));
return false;
}
if (strcmp(orig_options->conninfo, new_options.conninfo) != 0)
{
/* Test conninfo string */
conn = establish_db_connection(new_options.conninfo, false);
if (!conn || (PQstatus(conn) != CONNECTION_OK))
{
log_warning(_("'conninfo' string is not valid, retaining current configuration\n"));
return false;
}
PQfinish(conn);
}
/*
* No configuration problems detected - copy any changed values
*
* NB: keep these in the same order as in config.h to make it easier
* to manage them
*/
/* cluster_name */
if (strcmp(orig_options->cluster_name, new_options.cluster_name) != 0)
{
strcpy(orig_options->cluster_name, new_options.cluster_name);
config_changed = true;
}
/* conninfo */
if (strcmp(orig_options->conninfo, new_options.conninfo) != 0)
{
strcpy(orig_options->conninfo, new_options.conninfo);
config_changed = true;
}
/* node */
if (orig_options->node != new_options.node)
{
orig_options->node = new_options.node;
config_changed = true;
}
/* failover */
if (orig_options->failover != new_options.failover)
{
orig_options->failover = new_options.failover;
config_changed = true;
}
/* priority */
if (orig_options->priority != new_options.priority)
{
orig_options->priority = new_options.priority;
config_changed = true;
}
/* node_name */
if (strcmp(orig_options->node_name, new_options.node_name) != 0)
{
strcpy(orig_options->node_name, new_options.node_name);
config_changed = true;
}
/* promote_command */
if (strcmp(orig_options->promote_command, new_options.promote_command) != 0)
{
strcpy(orig_options->promote_command, new_options.promote_command);
config_changed = true;
}
/* follow_command */
if (strcmp(orig_options->follow_command, new_options.follow_command) != 0)
{
strcpy(orig_options->follow_command, new_options.follow_command);
config_changed = true;
}
/*
* XXX These ones can change with a simple SIGHUP?
*
* strcpy (orig_options->loglevel, new_options.loglevel); strcpy
* (orig_options->logfacility, new_options.logfacility);
*
* logger_shutdown(); XXX do we have progname here ? logger_init(progname,
* orig_options.loglevel, orig_options.logfacility);
*/
/* rsync_options */
if (strcmp(orig_options->rsync_options, new_options.rsync_options) != 0)
{
strcpy(orig_options->rsync_options, new_options.rsync_options);
config_changed = true;
}
/* ssh_options */
if (strcmp(orig_options->ssh_options, new_options.ssh_options) != 0)
{
strcpy(orig_options->ssh_options, new_options.ssh_options);
config_changed = true;
}
/* master_response_timeout */
if (orig_options->master_response_timeout != new_options.master_response_timeout)
{
orig_options->master_response_timeout = new_options.master_response_timeout;
config_changed = true;
}
/* reconnect_attempts */
if (orig_options->reconnect_attempts != new_options.reconnect_attempts)
{
orig_options->reconnect_attempts = new_options.reconnect_attempts;
config_changed = true;
}
/* reconnect_interval */
if (orig_options->reconnect_interval != new_options.reconnect_interval)
{
orig_options->reconnect_interval = new_options.reconnect_interval;
config_changed = true;
}
/* pg_ctl_options */
if (strcmp(orig_options->pg_ctl_options, new_options.pg_ctl_options) != 0)
{
strcpy(orig_options->pg_ctl_options, new_options.pg_ctl_options);
config_changed = true;
}
/* pg_basebackup_options */
if (strcmp(orig_options->pg_basebackup_options, new_options.pg_basebackup_options) != 0)
{
strcpy(orig_options->pg_basebackup_options, new_options.pg_basebackup_options);
config_changed = true;
}
/* monitor_interval_secs */
if (orig_options->monitor_interval_secs != new_options.monitor_interval_secs)
{
orig_options->monitor_interval_secs = new_options.monitor_interval_secs;
config_changed = true;
}
/* retry_promote_interval_secs */
if (orig_options->retry_promote_interval_secs != new_options.retry_promote_interval_secs)
{
orig_options->retry_promote_interval_secs = new_options.retry_promote_interval_secs;
config_changed = true;
}
/* use_replication_slots */
if (orig_options->use_replication_slots != new_options.use_replication_slots)
{
orig_options->use_replication_slots = new_options.use_replication_slots;
config_changed = true;
}
if (config_changed == true)
{
log_debug(_("reload_config(): configuration has changed\n"));
}
else
{
log_debug(_("reload_config(): configuration has not changed\n"));
}
return config_changed;
}
int
main(int argc, char **argv)
{
int ups_fd, stat_fd, ch;
int flags;
int pstatus, poldstat = 1;
int bstatus, boldstat = 1;
int count = 0;
int bcount = 0;
int tries = 0;
int ikill = 0;
int ioctlbit;
char *self = argv[0];
char killchar = ' ';
struct upsdef *pups;
while ((ch = getopt(argc, argv, "kc:d:r:s:t:")) != -1)
switch (ch) {
case 'k':
ikill = 1;
break;
case 'c':
config_file = optarg;
break;
case 'd':
upsport = optarg;
break;
case 'r':
rcpowerfail = optarg;
break;
case 's':
upsstat = optarg;
break;
case 't':
upstype = optarg;
break;
case '?':
default:
usage(self);
}
argc -= optind;
argv += optind;
if (argc > 0)
usage(self);
parse_config(config_file);
if (upsport == NULL || upstype == NULL || upsstat == NULL) {
usage(self);
}
for (pups = ups; pups; pups = pups->next) {
if (strcmp(pups->tag, upstype) == 0)
break;
}
if (!pups) {
fprintf(stderr, "Error: %s: UPS <%s> unknown\n", self, argv[2]);
exit(1);
}
/* Start syslog. */
openlog(self, LOG_CONS | LOG_PERROR, LOG_DAEMON);
if ((ups_fd = open(upsport, O_RDWR | O_NDELAY)) < 0) {
syslog(LOG_ERR, "%s: %s", upsport, strerror(errno));
closelog();
exit(1);
}
/* Kill the inverter and close out if inverter kill was selected */
if (ikill) {
if (pups->killtime) {
/* Explicitly clear both DTR and RTS as soon as possible */
ioctlbit = TIOCM_RTS;
ioctl(ups_fd, TIOCMBIC, &ioctlbit);
ioctlbit = TIOCM_DTR;
ioctl(ups_fd, TIOCMBIC, &ioctlbit);
/* clear killpower, apply cablepower to enable monitoring */
setlevel(ups_fd, pups->kill.line, !pups->kill.inverted);
setlevel(ups_fd, pups->cablepower.line, !pups->cablepower.inverted);
if (pups->kill.line == TIOCM_ST) {
/* Send BREAK (TX high) to kill the UPS inverter. */
tcsendbreak(ups_fd, 1000 * pups->killtime);
} else {
/* Force high to send the UPS the inverter kill signal. */
setlevel(ups_fd, pups->kill.line, pups->kill.inverted);
sleep(pups->killtime);
}
ioctl(ups_fd, TIOCMGET, &flags);
/*
* Feb/05/2001 Added support for Tripplite Omnismart 450PNP, this
* UPS shutdowns inverter when data is sent over the Tx line
* (jhcaiced)
*/
if (pups->flags & UPS_TXD_KILL_INVERTER) {
sleep(2);
write(ups_fd, &killchar, 1);
}
close(ups_fd);
/************************************************************/
/* We never should have gotten here. */
/* The inverter kill has failed for one reason or another. */
/* If still in powerfail mode, exit with an error. */
/* If power is ok (power has returned) let rc.0 finish the */
/* reboot. */
/************************************************************/
if (getlevel(&pups->powerok, flags) == 0) {
fprintf(stderr, "%s: UPS inverter kill failed.\n", self);
exit(1);
} /* if (getlevel(&pups->powerok,flags) == 0) */
/* Otherwise, exit normaly, power has returned. */
exit(0);
} else {
fprintf(stderr, "Error: %s: UPS <%s> has no support for killing the inverter.\n",
self, pups->tag);
exit(1);
} /* if (pups->kill) */
} /* if (ikill) */
/****************************************/
/* If no kill signal, monitor the line. */
/****************************************/
/* Explicitly clear both DTR and RTS as soon as possible */
ioctl(ups_fd, TIOCMBIC, TIOCM_RTS);
ioctl(ups_fd, TIOCMBIC, TIOCM_DTR);
/* clear killpower, apply cablepower to enable monitoring */
setlevel(ups_fd, pups->kill.line, !pups->kill.inverted);
setlevel(ups_fd, pups->cablepower.line, !pups->cablepower.inverted);
/* Daemonize. */
#ifdef DEBUG
closelog();
setsid();
#else
switch (fork()) {
case 0: /* Child */
closelog();
setsid();
break;
case -1: /* Error */
syslog(LOG_ERR, "can't fork.");
closelog();
exit(1);
default: /* Parent */
closelog();
exit(0);
}
#endif /* switch(fork()) */
/* Restart syslog. */
openlog(self, LOG_CONS, LOG_DAEMON);
/* Create an info file for powerfail scripts. */
unlink(upsstat);
if ((stat_fd = open(upsstat, O_CREAT | O_WRONLY, 0644)) >= 0) {
write(stat_fd, "OK\n", 3);
close(stat_fd);
}
/* Give the UPS a chance to reach a stable state. */
sleep(2);
/* Now sample the line. */
while (1) {
/* Get the status. */
ioctl(ups_fd, TIOCMGET, &flags);
/* Calculate present status. */
pstatus = getlevel(&pups->powerok, flags);
bstatus = getlevel(&pups->battok, flags);
if (pups->cableok.line) {
/* Check the connection. */
tries = 0;
while (getlevel(&pups->cableok, flags) == 0) {
/* Keep on trying, and warn every two minutes. */
if ((tries % 60) == 0)
syslog(LOG_ALERT, "UPS connection error");
sleep(2);
tries++;
ioctl(ups_fd, TIOCMGET, &flags);
} /* while(getlevel(&pups->cableok,flags) */
if (tries > 0)
syslog(LOG_ALERT, "UPS connection OK");
} else {
/*
* Do pseudo-cable check, bad power on startup == possible bad
* cable
*/
if (tries < 1) {
tries++;
/* Do startup failure check */
if (!pstatus) {
/*
* Power is out: assume bad cable, but semi-scram to be
* safe
*/
syslog(LOG_ALERT, "No power on startup; UPS connection error?");
/*
* Set status registers to prevent further processing
* until
*/
/* the status of the cable is changed. */
poldstat = pstatus;
boldstat = bstatus;
powerfail(PFM_CABLE);
} /* if (!pstatus) */
} /* if (tries < 1) */
} /* if (pups->cableok.line) */
/* If anything has changed, process the change */
if (pstatus != poldstat || bstatus != boldstat) {
count++;
if (count < 4) {
/* Wait a little to ride out short brown-outs */
sleep(1);
continue;
} /* if (count < 4) */
if (pstatus != poldstat) {
if (pstatus) {
/* Power is OK */
syslog(LOG_ALERT, "Line power restored");
powerfail(PFM_OK);
} else {
/* Power has FAILED */
if (bstatus) {
/* Battery OK, normal shutdown */
syslog(LOG_ALERT, "Line power has failed");
powerfail(PFM_FAIL);
} else {
/* Low Battery, SCRAM! */
syslog(LOG_ALERT, "UPS battery power is low!");
powerfail(PFM_SCRAM);
} /* if (bstatus) */
} /* if (pstatus) */
} /* if (pstatus != poldstat) */
if (bstatus != boldstat) {
if (!bstatus && !pstatus) {
/* Power is out and Battery is now low, SCRAM! */
syslog(LOG_ALERT, "UPS battery power is low!");
powerfail(PFM_SCRAM);
} else {
/* Battery status has changed */
if (bstatus) {
/* Battery power is back */
syslog(LOG_ALERT, "UPS battery power is now OK");
} /* if (!bstatus) */
} /* if (!bstatus && !pstatus) */
} /* if (bstatus != boldstat) */
} /* if (pstatus != poldstat || bstatus !=
* boldstat) */
if (!bstatus && pstatus) {
/* Line power is OK and UPS signals battery is low */
/* Log a message to the syslog every 10 minutes */
if ((bcount % 300) == 0)
syslog(LOG_ALERT, "UPS battery power is low!");
bcount++;
} else {
/* Reset count */
bcount = 0;
} /* if (!bstatus && pstatus) */
/* Reset count, remember status and sleep 2 seconds. */
count = 0;
poldstat = pstatus;
boldstat = bstatus;
sleep(2);
} /* while(1) */
/* Never happens */
return (0);
}
/*! \brief Start of execution. Parse options, and call other other
* functions one after another. At the moment adding threading support
* would be difficult, but there does not seem to be valid reason to
* consider that. Overall the analysis already quick enough even without
* making it parallel.
*
* \return Return value indicates success or fail or analysis, unless
* either --warning or --critical options are in use, which makes the
* return value in some cases to match with Nagios expectations about
* alarming. */
int main(int argc, char **argv)
{
int i, sorts = 0;
int option_index = 0;
char const *tmp;
struct range_t *tmp_ranges;
enum {
OPT_WARN = CHAR_MAX + 1,
OPT_CRIT
};
int ret_val;
/* Options for getopt_long */
static struct option const long_options[] = {
{"config", required_argument, NULL, 'c'},
{"leases", required_argument, NULL, 'l'},
{"format", required_argument, NULL, 'f'},
{"sort", required_argument, NULL, 's'},
{"reverse", no_argument, NULL, 'r'},
{"output", required_argument, NULL, 'o'},
{"limit", required_argument, NULL, 'L'},
{"version", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{"warning", required_argument, NULL, OPT_WARN},
{"critical", required_argument, NULL, OPT_CRIT},
{NULL, 0, NULL, 0}
};
atexit(close_stdout);
/* FIXME: These allocations should be fully dynamic, e.g., grow
* if needed. */
config.dhcpdconf_file = xmalloc(sizeof(char) * MAXLEN);
config.dhcpdlease_file = xmalloc(sizeof(char) * MAXLEN);
config.output_file = xmalloc(sizeof(char) * MAXLEN);
/* Make sure string has zero length if there is no
* command line option */
config.output_file[0] = '\0';
/* Alarming defaults. */
config.warning = ALARM_WARN;
config.critical = ALARM_CRIT;
/* File location defaults */
strncpy(config.dhcpdconf_file, DHCPDCONF_FILE, MAXLEN - 1);
strncpy(config.dhcpdlease_file, DHCPDLEASE_FILE, MAXLEN - 1);
tmp = OUTPUT_LIMIT;
config.output_limit[0] = (*tmp - '0');
tmp++;
config.output_limit[1] = (*tmp - '0');
config.fullhtml = false;
/* Make sure some output format is selected by default */
strncpy(config.output_format, OUTPUT_FORMAT, (size_t)1);
/* Default sort order is by IPs small to big */
config.reverse_order = false;
config.backups_found = false;
/* Parse command line options */
while (1) {
int c;
c = getopt_long(argc, argv, "c:l:f:o:s:rL:vh",
long_options, &option_index);
if (c == EOF)
break;
switch (c) {
case 'c':
/* config file */
strncpy(config.dhcpdconf_file, optarg, MAXLEN - 1);
break;
case 'l':
/* lease file */
strncpy(config.dhcpdlease_file, optarg, MAXLEN - 1);
break;
case 'f':
/* Output format */
strncpy(config.output_format, optarg, (size_t)1);
break;
case 's':
/* Output sorting option */
sorts = strlen(optarg);
if (5 < sorts) {
warnx
("main: only first 5 sort orders will be used");
strncpy(config.sort, optarg, (size_t)5);
sorts = 5;
} else {
strncpy(config.sort, optarg, (size_t)sorts);
}
for (i = 0; i < sorts; i++) {
field_selector(config.sort[i]);
}
break;
case 'r':
/* What ever sort in reverse order */
config.reverse_order = true;
break;
case 'o':
/* Output file */
strncpy(config.output_file, optarg, MAXLEN - 1);
break;
case 'L':
/* Specification what will be printed */
for (i = 0; i < 2; i++) {
if (optarg[i] >= '0' && optarg[i] < '8') {
config.output_limit[i] =
optarg[i] - '0';
} else {
errx(EXIT_FAILURE,
"main: output mask `%s' is illegal",
optarg);
}
}
break;
case OPT_WARN:
strcpy(config.output_format, "a");
config.warning =
strtod_or_err(optarg, "illegal argument");
break;
case OPT_CRIT:
strcpy(config.output_format, "a");
config.critical =
strtod_or_err(optarg, "illegal argument");
break;
case 'v':
/* Print version */
print_version();
case 'h':
/* Print help */
usage(EXIT_SUCCESS);
default:
errx(EXIT_FAILURE,
"Try `%s --help' for more information.",
program_invocation_short_name);
}
}
/* Output function selection */
switch (config.output_format[0]) {
case 't':
output_analysis = output_txt;
break;
case 'a':
output_analysis = output_alarming;
break;
case 'h':
output_analysis = output_html;
break;
case 'H':
output_analysis = output_html;
config.fullhtml = true;
break;
case 'x':
output_analysis = output_xml;
break;
case 'X':
output_analysis = output_xml;
break;
case 'j':
output_analysis = output_json;
break;
case 'J':
output_analysis = output_json;
break;
case 'c':
output_analysis = output_csv;
break;
default:
errx(EXIT_FAILURE, "main: unknown output format `%c'",
config.output_format[0]);
}
/* Do the job */
prepare_memory();
parse_config(true, config.dhcpdconf_file, shared_networks);
parse_leases();
prepare_data();
do_counting();
tmp_ranges = xmalloc(sizeof(struct range_t) * num_ranges);
if (sorts != 0) {
mergesort_ranges(ranges, num_ranges, tmp_ranges);
}
if (config.reverse_order == true) {
flip_ranges(ranges, tmp_ranges);
}
free(tmp_ranges);
ret_val = output_analysis();
clean_up();
return (ret_val);
}
int main(int argc, char *argv[])
{
mmatic *mm = mmatic_create();
mmatic *mmtmp = mmatic_create();
struct mg *mg;
int i;
/*
* initialize and parse config
*/
mg = mmatic_zalloc(mm, sizeof(struct mg));
mg->mm = mm;
mg->mmtmp = mmtmp;
apply_defaults(mg);
/* get my id number from hostname */
fetch_myid(mg);
/* parse command line options */
if (parse_argv(mg, argc, argv))
return 1;
/* parse configuration file options */
if (mg->options.conf_file) {
if (parse_config(mg))
return 4;
}
/*
* config syntax looks OK, see if it is feasible
*/
/* initialize random number generator */
srand48(mg->options.myid);
/* init libevent */
mg->evb = event_init();
event_set_log_callback(libevent_log);
/* init stats structures so mgstats_aggregator_add() used somewhere below works */
mgstats_init(mg);
/* attach to raw interfaces */
if (mgi_init(mg, handle_packet) <= 0) {
dbg(0, "no available interfaces found\n");
return 2;
}
/* parse traffic file */
if (parse_traffic(mg))
return 3;
/*
* all OK, prepare to start
*/
/* synchronize time reference point on all nodes */
mgc_sync(mg);
/* schedule stats writing */
mgstats_start(mg);
/* attach global stats */
_stats_init(mg);
/* schedule heartbeat and disk sync signals */
heartbeat_init(mg);
sync_init(mg);
/* schedule the real work of this node: line generators */
for (i = 1; i < TRAFFIC_LINE_MAX; i++) {
if (!(mg->lines[i] && mg->lines[i]->my))
continue;
/* this will schedule first execution */
mgs_sleep(mg->lines[i], NULL);
mg->running++;
}
/* suppose last frame was received now */
gettimeofday(&mg->last, NULL);
/*
* start!
*/
dbg(0, "Starting\n");
event_base_dispatch(mg->evb);
/*******************************/
/*
* cleanup after end of libevent loop
*/
event_base_free(mg->evb);
mmatic_free(mg->mm);
mmatic_free(mg->mmtmp);
fflush(NULL);
sync();
return 0;
}
static int reload(void)
{
if (parse_config(1))
return AST_MODULE_LOAD_DECLINE;
return AST_MODULE_LOAD_SUCCESS;
}
/**
* Command line analysis function.
*
* mpirun [-debug] [-xterm] -np N [-hostfile hfile | h1 h2 h3 ... hN] a.out [args]
*/
void commandLine(int argc, char *argv[], char *totalview_cmd, char **env)
{
int i;
int c, option_index;
size_t hostname_len = 0;
do {
c = getopt_long_only(argc, argv, "+", option_table, &option_index);
switch (c) {
case '?':
case ':':
usage();
exit(EXIT_FAILURE);
break;
case EOF:
break;
case 0:
switch (option_index) {
case 0: /* -np */
nprocs = atoi(optarg);
if (nprocs < 1) {
usage();
exit(EXIT_FAILURE);
}
break;
case 1: /* -debug */
debug_on = 1;
xterm_on = 1;
break;
case 2: /* -xterm */
xterm_on = 1;
break;
case 3: /* -hostfile */
hostfile_on = 1;
strncpy(hostfile, optarg, HOSTFILE_LEN);
if (strlen(optarg) >= HOSTFILE_LEN - 1)
hostfile[HOSTFILE_LEN] = '\0';
break;
case 4:
show_on = 1;
break;
case 5:
use_rsh = 1;
break;
case 6:
use_rsh = 0;
break;
case 7:
usage();
exit(EXIT_SUCCESS);
break;
case 8:
PRINT_MVAPICH2_VERSION();
exit(EXIT_SUCCESS);
break;
case 9:
{
/* -tv */
char *tv_env;
int count, idx;
char **new_argv;
tv_env = getenv("TOTALVIEW");
if (tv_env != NULL) {
strncpy(totalview_cmd, tv_env, TOTALVIEW_CMD_LEN);
} else {
fprintf(stderr, "TOTALVIEW env is NULL, use default: %s\n", TOTALVIEW_CMD);
sprintf(totalview_cmd, "%s", TOTALVIEW_CMD);
}
new_argv = (char **) malloc(sizeof(char **) * argc + 3);
new_argv[0] = totalview_cmd;
new_argv[1] = argv[0];
new_argv[2] = "-a";
new_argv[3] = "-startedByTv";
idx = 4;
for (count = 1; count < argc; count++) {
if (strcmp(argv[count], "-tv"))
new_argv[idx++] = argv[count];
}
new_argv[idx] = NULL;
if (execv(new_argv[0], new_argv)) {
perror("execv");
exit(EXIT_FAILURE);
}
}
break;
case 10:
legacy_startup = 1;
break;
case 11:
/* -startedByTv */
use_totalview = 1;
debug_on = 1;
break;
case 12: /* spawnspec given */
spawnfile = strdup(optarg);
DBG(fprintf(stderr, "spawn spec file = %s\n", spawnfile));
break;
case 13:
dpm = 1;
break;
case 14: /* -fastssh */
#ifndef CKPT
USE_LINEAR_SSH = 0;
#endif /* CKPT */
break;
//With this option the user want to activate the mpmd
case 15:
configfile_on = 1;
strncpy(configfile, optarg, CONFILE_LEN);
if (strlen(optarg) >= CONFILE_LEN - 1)
configfile[CONFILE_LEN] = '\0';
break;
case 16:
spinf.totspawns = atoi(optarg);
break;
case 17:
/* sg: change the active group */
change_group = optarg;
DBG(printf("Group change requested: '%s'\n", change_group));
break;
case 18:
#if defined(CKPT) && defined(CR_FTB)
sparehosts_on = 1;
strncpy(sparehostfile, optarg, HOSTFILE_LEN);
if (strlen(optarg) >= HOSTFILE_LEN - 1)
sparehostfile[HOSTFILE_LEN] = 0;
#else
usage();
exit(EXIT_SUCCESS);
#endif
break;
default:
fprintf(stderr, "Unknown option\n");
usage();
exit(EXIT_FAILURE);
break;
}
break;
default:
fprintf(stderr, "Unreachable statement!\n");
usage();
exit(EXIT_FAILURE);
break;
}
}
while (c != EOF);
if (!nprocs && !configfile_on) {
usage();
exit(EXIT_FAILURE);
}
binary_dirname = dirname(strdup(argv[0]));
if (strlen(binary_dirname) == 1 && argv[0][0] != '.') {
use_dirname = 0;
}
//If the mpmd is active we need to parse the configuration file
if (configfile_on) {
/*TODO In the future the user can add the nprocs on the command line. Now the
* number of processes is defined in the configfile */
nprocs = 0;
plist = parse_config(configfile, &nprocs);
DBG(fprintf(stderr, "PARSED CONFIG FILE\n"));
}
if (!hostfile_on) {
/* get hostnames from argument list */
if (strchr(argv[optind], '=') || argc - optind < nprocs + 1) {
sprintf(hostfile, "%s/.mpirun_hosts", env2str("HOME"));
if (file_exists(hostfile)) {
hostfile_on = 1;
aout_index = optind;
goto cont;
} else {
fprintf(stderr, "Without hostfile option, hostnames must be " "specified on command line.\n");
usage();
exit(EXIT_FAILURE);
}
}
aout_index = nprocs + optind;
} else { /* if (!hostfile_on) */
aout_index = optind;
}
cont:
if (!configfile_on) {
plist = malloc(nprocs * sizeof(process));
if (plist == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
for (i = 0; i < nprocs; i++) {
plist[i].state = P_NOTSTARTED;
plist[i].device = NULL;
plist[i].port = -1;
plist[i].remote_pid = 0;
//TODO ADD EXECNAME AND ARGS
}
}
/* grab hosts from command line or file */
/* TODO: remove hostname_len variable */
hostname_len = 0;
if (hostfile_on) {
hostname_len = read_hostfile(hostfile);
} else {
for (i = 0; i < nprocs; i++) {
plist[i].hostname = (char *) strndup(argv[optind + i], 100);
if (hostname_len < strlen(plist[i].hostname)) {
hostname_len = strlen(plist[i].hostname);
}
}
}
}
/*
* create_object parse the object fields from the command line and call the
* appropriate object creator with a table of fields filled in.
*/
int main(
int argc,
char **argv)
{
int ret = 0;
int parse_err = 0;
int index = 1;
int c;
char *obj_type;
char *configFile = NULL;
extern char *optarg;
struct object_field *table;
OPEN_LOG("create_object", LOG_USER);
if (!my_config_load())
{
LOG(LOG_ERR, "can't load configuration");
return EXIT_FAILURE;
}
// parse options
while ((c = getopt(argc, argv, "hf:t:")) != -1)
{
switch (c)
{
case 'h':
printUsage(argv);
break;
case 'f':
configFile = optarg;
break;
case 't':
templateFile = optarg;
break;
case '?':
printUsage(argv);
break;
default:
fprintf(stderr, "Illegal Option\n");
printUsage(argv);
break;
}
}
index = optind; // remaining arguments
if (configFile == NULL)
fprintf(stdout, "No Config file\n");
if (index >= argc)
fatal(INPUT_ARG_ERR, "No Object Type");
else
obj_type = argv[index++];
if (strncasecmp(obj_type, "CERT", strlen("CERT")) == 0)
{
table = get_cert_field_table();
if (configFile != NULL)
if (parse_config(configFile, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
// parse and validate arguments, exit if either or both fail
if (parse_args(argc, argv, index, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
if (validate_table(table, validate_errstr, sizeof(validate_errstr)) !=
0)
fatal(MISSING_FIELDS, validate_errstr);
// if no validation error but we did have a parse err - exit
if (parse_err)
{
config_unload();
exit(INPUT_ARG_ERR);
}
ret = create_cert(table);
// fprintf(stdout,"return from creating certificate %d\n", ret);
}
else if (strncasecmp(obj_type, "CRL", strlen("CRL")) == 0)
{
table = get_crl_field_table();
if (configFile != NULL)
if (parse_config(configFile, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
if (parse_args(argc, argv, index, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
if (validate_table(table, validate_errstr, sizeof(validate_errstr)) !=
0)
fatal(MISSING_FIELDS, validate_errstr);
// if no validation error but we did have a parse err - exit
if (parse_err)
{
config_unload();
exit(INPUT_ARG_ERR);
}
ret = create_crl(table);
}
else if (strncasecmp(obj_type, "ROA", strlen("ROA")) == 0)
{
table = get_roa_field_table();
if (configFile != NULL)
if (parse_config(configFile, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
if (parse_args(argc, argv, index, table) != 0)
fatal(INPUT_ARG_ERR, parse_errstr);
if (validate_table(table, validate_errstr, sizeof(validate_errstr)) !=
0)
fatal(MISSING_FIELDS, validate_errstr);
ret = create_roa(table);
}
else if (strncasecmp(obj_type, "MANIFEST", strlen("MANIFEST")) == 0)
{
table = get_man_field_table();
if (configFile != NULL)
if (parse_config(configFile, table) != 0)
{
warn(INPUT_ARG_ERR, parse_errstr);
parse_err = 1;
}
// parse arguments and validate table
if (parse_args(argc, argv, index, table) != 0)
warn(INPUT_ARG_ERR, parse_errstr);
if (validate_table(table, validate_errstr, sizeof(validate_errstr)) !=
0)
fatal(MISSING_FIELDS, validate_errstr);
ret = create_manifest(table);
}
else
fatal(INPUT_ARG_ERR, argv[1]);
config_unload();
exit(ret);
}