void
init_logger(const char * entity)
{
int debug_level = 2;
cl_log_set_entity(entity);
cl_log_enable_stderr(debug_level?TRUE:FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
}
gboolean
crm_log_init(
const char *entity, int level, gboolean coredir, gboolean to_stderr,
int argc, char **argv)
{
/* Redirect messages from glib functions to our handler */
/* cl_malloc_forced_for_glib(); */
#ifdef HAVE_G_LOG_SET_DEFAULT_HANDLER
glib_log_default = g_log_set_default_handler(crm_glib_handler, NULL);
#endif
/* and for good measure... - this enum is a bit field (!) */
g_log_set_always_fatal((GLogLevelFlags)0); /*value out of range*/
crm_system_name = entity;
setenv("PCMK_service", crm_system_name, 1);
cl_log_set_entity(entity);
if(argc == 0) {
/* Nuke any syslog activity */
unsetenv("HA_logfacility");
} else if(getenv("HA_logfacility") == NULL) {
/* Set a default */
cl_log_set_facility(HA_LOG_FACILITY);
} /* else: picked up by crm_set_env_options() */
if(coredir) {
int user = getuid();
struct passwd *pwent = NULL;
const char *base = HA_COREDIR;
pwent = getpwuid(user);
if (chdir(base) < 0) {
crm_perror(LOG_ERR, "Cannot change active directory to %s", base);
} else if (pwent == NULL) {
crm_perror(LOG_ERR, "Cannot get name for uid: %d", user);
} else if (chdir(pwent->pw_name) < 0) {
crm_perror(LOG_ERR, "Cannot change active directory to %s/%s", base, pwent->pw_name);
} else {
crm_info("Changed active directory to %s/%s", base, pwent->pw_name);
}
}
set_crm_log_level(level);
crm_set_env_options();
cl_log_args(argc, argv);
cl_log_enable_stderr(to_stderr);
crm_signal(DEBUG_INC, alter_debug);
crm_signal(DEBUG_DEC, alter_debug);
return TRUE;
}
int
main(int argc,char ** argv)
{
int flag;
int hb_num = 10;
int child_proc_num = 1;
int hb_intvl_ms = 1000;
int dofailuretests = FALSE;
int delaysecs = -1;
while (( flag = getopt(argc, argv, OPTARGS)) != EOF) {
switch(flag) {
case 'n': /* Number of heartbeat */
hb_num = atoi(optarg);
break;
case 'p': /* Number of heartbeat processes */
child_proc_num = atoi(optarg);
break;
case 'i': /* Heartbeat interval */
hb_intvl_ms = atoi(optarg);
break;
case 'l': /* Delay before starting multiple clients */
delaysecs = atoi(optarg);
break;
case 'd': /* Debug */
debug += 1;
break;
case 'F': /* Enable failure cases */
dofailuretests = TRUE;
break;
case 'h':
default:
fprintf(stderr
, "%s "USAGE_STR"\n", argv[0]);
return(1);
}
}
cl_log_set_entity(argv[0]);
cl_log_enable_stderr(TRUE);
cl_log_set_facility(LOG_USER);
if (delaysecs < 0)
delaysecs = child_proc_num;
multi_hb_test(child_proc_num, hb_intvl_ms, hb_num, delaysecs
, dofailuretests);
if (dofailuretests) {
/* run these fail cases if you want */
/*
apphb_setwarn_test(2000, 1000);
apphb_setwarn_test(1000, 2000);
dup_reg_test();
*/
}
return(0);
}
int main(int argc, char * argv[])
{
stonith_ops_t * st_op;
cl_log_set_entity("STDAPI_TEST");
cl_log_set_facility(LOG_USER);
cl_log_enable_stderr(TRUE);
if (argc != 5) {
cl_log(LOG_ERR, "parameter error.");
printf("%s optype target_node timeout expect_value.\n", argv[0]);
return -1;
}
if (ST_OK != stonithd_signon("apitest")) {
return -1;
}
st_op = g_new(stonith_ops_t, 1);
st_op->optype = atoi(argv[1]);
st_op->node_name = g_strdup(argv[2]);
st_op->node_uuid = g_strdup(argv[2]);
st_op->timeout = atoi(argv[3]);
st_op->private_data = g_strdup(argv[4]);
if (ST_OK!=stonithd_set_stonith_ops_callback(stonith_ops_cb)) {
stonithd_signoff();
return -1;
}
if (ST_OK == stonithd_node_fence( st_op )) {
while (stonithd_op_result_ready() != TRUE) {
;
}
if (ST_OK!=stonithd_receive_ops_result(TRUE)) {
return -1;
}
} else {
g_rc = -1;
}
/*
stonithRA_ops_t * stra_op;
int call_id;
stra_op = g_new(stonithRA_ops_t, 1);
stra_op->ra_name = g_strdup("/root/test");
stra_op->op_type = g_strdup("start");
stra_op->params = NULL;
stonithd_virtual_stonithRA_ops( stra_op, &call_id );
*/
if (ST_OK!=stonithd_signoff()) {
g_rc = -1;
}
return g_rc;
}
int main(int argc, char *argv[], char *envp[])
{
int rv;
init_set_proc_title(argc, argv, envp);
get_secs(&start_time);
memset(&cl, 0, sizeof(cl));
strncpy(cl.configfile,
BOOTH_DEFAULT_CONF, BOOTH_PATH_LEN - 1);
cl.lockfile[0] = 0;
debug_level = 0;
cl_log_set_entity("booth");
cl_log_enable_stderr(TRUE);
cl_log_set_facility(0);
rv = read_arguments(argc, argv);
if (rv < 0)
goto out;
switch (cl.type) {
case STATUS:
rv = do_status(cl.type);
break;
case ARBITRATOR:
case DAEMON:
case SITE:
rv = do_server(cl.type);
break;
case CLIENT:
rv = do_client();
break;
}
out:
/* Normalize values. 0x100 would be seen as "OK" by waitpid(). */
return (rv >= 0 && rv < 0x70) ? rv : 1;
}
int main(int argc, char *argv[])
{
int rv;
memset(&cl, 0, sizeof(cl));
strncpy(cl.configfile, BOOTH_DEFAULT_CONF, BOOTH_PATH_LEN - 1);
strncpy(cl.lockfile, BOOTH_DEFAULT_LOCKFILE, BOOTH_PATH_LEN - 1);
rv = read_arguments(argc, argv);
if (rv < 0)
goto out;
if (cl.type == ACT_CLIENT) {
cl_log_enable_stderr(TRUE);
cl_log_set_facility(0);
} else {
cl_log_set_entity(logging_entity);
cl_log_enable_stderr(debug_level ? TRUE : FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
}
cl_inherit_logging_environment(0);
switch (cl.type) {
case ACT_ARBITRATOR:
rv = do_server(ARBITRATOR);
break;
case ACT_SITE:
rv = do_server(SITE);
break;
case ACT_CLIENT:
rv = do_client();
break;
}
out:
return rv ? EXIT_FAILURE : EXIT_SUCCESS;
}
gboolean
crm_log_init(
const char *entity, int level, gboolean coredir, gboolean to_stderr,
int argc, char **argv)
{
/* const char *test = "Testing log daemon connection"; */
/* Redirect messages from glib functions to our handler */
/* cl_malloc_forced_for_glib(); */
g_log_set_handler(NULL,
G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL
| G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE
| G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG
| G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL,
cl_glib_msg_handler, NULL);
/* and for good measure... - this enum is a bit field (!) */
g_log_set_always_fatal((GLogLevelFlags)0); /*value out of range*/
cl_log_set_entity(entity);
cl_log_set_facility(HA_LOG_FACILITY);
if(coredir) {
cl_set_corerootdir(HA_COREDIR);
cl_cdtocoredir();
}
set_crm_log_level(level);
crm_set_env_options();
cl_log_args(argc, argv);
cl_log_enable_stderr(to_stderr);
CL_SIGNAL(DEBUG_INC, alter_debug);
CL_SIGNAL(DEBUG_DEC, alter_debug);
return TRUE;
}
int main (int argc, char* argv[])
{
ll_lrm_t* lrm;
lrm_rsc_t* rsc = NULL;
lrm_op_t* op = NULL;
const char* rid = "ip248";
GHashTable* param = NULL;
GList* classes;
int i;
cl_log_set_entity("apitest");
cl_log_set_facility(LOG_USER);
lrm = ll_lrm_new("lrm");
if(NULL == lrm)
{
printf("lrm==NULL\n");
return 1;
}
puts("sigon...");
lrm->lrm_ops->signon(lrm,"apitest");
classes = lrm->lrm_ops->get_rsc_class_supported(lrm);
lrm_free_str_list(classes);
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
puts("add_rsc...");
lrm->lrm_ops->add_rsc(lrm, rid, "heartbeat", "IPaddr", "heartbeat", param);
puts("get_rsc...");
rsc = lrm->lrm_ops->get_rsc(lrm, rid);
printf_rsc(rsc);
puts("perform_op(start)...");
op = lrm_op_new();
op->op_type = g_strdup("start");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a start op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 0;
op->target_rc = EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(status)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("status");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a status op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 1000;
op->target_rc=EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(stop)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("stop");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a stop op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 0;
op->target_rc=EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(status)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("status");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a status op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 2000;
op->target_rc=EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(start)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("start");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a start op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 0;
op->target_rc = EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(status)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("status");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a status op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 3000;
op->target_rc=EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
puts("perform_op(stop)...");
param = g_hash_table_new(g_str_hash,g_str_equal);
g_hash_table_insert(param, strdup("1"), strdup("192.168.192.100"));
op = lrm_op_new();
op->op_type = g_strdup("stop");
op->params = param;
op->timeout = 0;
op->user_data = strdup("It is a stop op!");
if ( op->user_data == NULL ) {
fprintf(stderr, "No enough memory.\n");
return -1;
}
op->user_data_len = strlen(op->user_data)+1;
op->interval = 0;
op->target_rc=EVERYTIME;
rsc->ops->perform_op(rsc,op);
printf_op(op);
lrm_free_op(op);
for(i = 0; i < 5; i++) {
puts("get_cur_state...");
get_cur_state(rsc);
puts("sleep a while...");
sleep(1);
}
puts("delete_rsc...");
lrm->lrm_ops->delete_rsc(lrm, rid);
lrm_free_rsc(rsc);
puts("signoff...");
lrm->lrm_ops->signoff(lrm);
return 0;
}
int main(int argc, char * argv[])
{
char app_instance[INSTANCE_NAME_LEN];
int option_char;
int interval = DEFAULT_APPHB_INTERVAL;
int apphb_warntime = DEFAULT_APPHB_WARNTIME;
char ** client_argv = NULL;
pid_t child_tmp = 0;
cl_log_set_entity(app_name);
cl_log_enable_stderr(TRUE);
cl_log_set_facility(HA_LOG_FACILITY);
if (argc == 1) { /* no arguments */
printf("%s\n", Simple_helpscreen);
exit(LSB_EXIT_EINVAL);
}
/*
* Try to separate the option parameter between myself and the client.
* Maybe rewrite the argc and argv.
*/
separate_argv(&argc, &argv, &client_argv);
/* code for debug */
#if 0
{
int j;
cl_log(LOG_INFO, "client_argv: 0x%08lx", (unsigned long) client_argv);
cl_log(LOG_INFO, "Called arg");
for (j=0; argv[j] != NULL; ++j) {
cl_log(LOG_INFO, "argv[%d]: %s", j, argv[j]);
}
for (j=0; client_argv && client_argv[j] != NULL; ++j) {
if (ANYDEBUG) {
cl_log(LOG_INFO, "client_argv[%d]: %s", j, client_argv[j]);
}
}
}
#endif
do {
option_char = getopt(argc, argv, optstr);
if (option_char == -1) {
break;
}
switch (option_char) {
case 'r':
IS_RECOVERY = TRUE;
break;
case 'm':
if (optarg) {
MAGIC_EXIT_CODE = atoi(optarg);
}
break;
case 'i':
if (optarg) {
interval = atoi(optarg);
} else {
printf("error.\n");
}
break;
case 'p':
if (optarg) {
pidfile = optarg;
}
break;
case 'w':
if (optarg) {
apphb_warntime = atoi(optarg);
}
break;
case 'l':
break;
/* information */
return LSB_EXIT_OK;
case 'h':
printf("%s\n",Simple_helpscreen);
return LSB_EXIT_OK;
default:
cl_log(LOG_ERR, "getopt returned"
"character code %c.", option_char);
printf("%s\n",Simple_helpscreen);
return LSB_EXIT_EINVAL;
}
} while (1);
/*
* Now I suppose recovery program only pass the client name via
* environment variables.
*/
if ( (IS_RECOVERY == FALSE) && (client_argv == NULL) ) {
cl_log(LOG_ERR, "Please give the program name which will be "
"run as a child process of cl_respawn.");
printf("%s\n", Simple_helpscreen);
exit(LSB_EXIT_EINVAL);
}
if ((IS_RECOVERY == TRUE ) && ( client_argv == NULL)) {
/*
* Here the client_argv must be NULL. At least now just
* suppose so.
*/
/*
* From the environment variables to acquire the necessary
* information set by other daemons like recovery manager.
* RSP_PID: the PID of the process which need to be monitored.
* RSP_CMD: the command line to restart the program, which is
* the same as the input in command line as above.
*/
if ( getenv("RSP_PID") == NULL ) {
cl_log(LOG_ERR, "cannot get monitored PID from the "
"environment variable which should be set by "
"the recovery program.");
exit(LSB_EXIT_EINVAL);
} else {
monitored_PID = atoi(getenv("RSP_PID"));
}
/*
* client_argv == NULL" indicates no client program passed as
* a parameter by others such as a recovery manager, so expect
* it will be passed by environment variable RSP_CMD, see as
* below. If cannot get it, quit.
*/
if (client_argv == NULL) {
if (getenv("RSP_CMD") == NULL) {
cl_log(LOG_ERR, "cannot get the argument of the "
"monitored program from the environment "
"variable, which should be set by the "
"recovery program.");
}
if (0!=cmd_str_to_argv(getenv("RSP_CMD"), &client_argv)) {
cl_log(LOG_ERR, "Failed to transfer the CLI "
"string to the argv[] style.");
exit(LSB_EXIT_EINVAL);
}
}
}
/* Not use the API 'daemon' since it's not a POSIX's */
become_daemon();
/* Code for debug
int k = 0;
do {
cl_log(LOG_INFO,"%s", execv_argv[k]);
} while (execv_argv[++k] != NULL);
*/
set_sigchld_proctrack(G_PRIORITY_HIGH,DEFAULT_MAXDISPATCHTIME);
if (( IS_RECOVERY == FALSE )) {
child_tmp = run_client_as_child(client_argv);
if (child_tmp > 0 ) {
cl_log(LOG_NOTICE, "started the monitored program %s, "
"whose PID is %d", client_argv[0], child_tmp);
} else {
exit(LSB_EXIT_GENERIC);
}
}
snprintf(app_instance, INSTANCE_NAME_LEN, "%s_%ldd"
, app_name, (long)getpid());
if (apphb_register(app_name, app_instance) != 0) {
cl_log(LOG_WARNING, "Failed to register with apphbd.");
cl_log(LOG_WARNING, "Maybe apphd isn't running.");
REGTO_APPHBD = FALSE;
} else {
REGTO_APPHBD = TRUE;
cl_log(LOG_INFO, "Registered with apphbd.");
apphb_setinterval(interval);
apphb_setwarn(apphb_warntime);
/* To avoid the warning when app_interval is very small. */
apphb_hb();
}
Gmain_timeout_add(interval - APPHB_INTVL_DETLA
, plumb_client_and_emit_apphb, client_argv);
mainloop = g_main_new(FALSE);
g_main_run(mainloop);
if ( REGTO_APPHBD == TRUE ) {
apphb_hb();
apphb_unregister();
}
return LSB_EXIT_OK;
}
int
main(int argc, char* argv[])
{
char pid_file[256];
char* ipv6addr;
char* cidr_netmask;
int ret;
char* cp;
char* prov_ifname = NULL;
int prefix_len = -1;
struct in6_addr addr6;
/* Check the count of parameters first */
if (argc < 2) {
usage(argv[0]);
return OCF_ERR_ARGS;
}
/* set termination signal */
siginterrupt(SIGTERM, 1);
signal(SIGTERM, byebye);
/* open system log */
cl_log_set_entity(APP_NAME);
cl_log_set_facility(LOG_DAEMON);
/* the meta-data dont need any parameter */
if (0 == strncmp(META_DATA_CMD, argv[1], strlen(META_DATA_CMD))) {
ret = meta_data_addr6();
return OCF_SUCCESS;
}
/* check the OCF_RESKEY_ipv6addr parameter, should be an IPv6 address */
ipv6addr = getenv("OCF_RESKEY_ipv6addr");
if (ipv6addr == NULL) {
cl_log(LOG_ERR, "Please set OCF_RESKEY_ipv6addr to the IPv6 address you want to manage.");
usage(argv[0]);
return OCF_ERR_ARGS;
}
/* legacy option */
if ((cp = strchr(ipv6addr, '/'))) {
prefix_len = atol(cp + 1);
if ((prefix_len < 0) || (prefix_len > 128)) {
cl_log(LOG_ERR, "Invalid prefix_len [%s], should be an integer in [0, 128]", cp+1);
usage(argv[0]);
return OCF_ERR_ARGS;
}
*cp=0;
}
/* get provided netmask (optional) */
cidr_netmask = getenv("OCF_RESKEY_cidr_netmask");
if (cidr_netmask != NULL) {
if ((atol(cidr_netmask) < 0) || (atol(cidr_netmask) > 128)) {
cl_log(LOG_ERR, "Invalid prefix_len [%s], "
"should be an integer in [0, 128]", cidr_netmask);
usage(argv[0]);
return OCF_ERR_ARGS;
}
if (prefix_len != -1 && prefix_len != atol(cidr_netmask)) {
cl_log(LOG_DEBUG, "prefix_len(%d) is overwritted by cidr_netmask(%s)",
prefix_len, cidr_netmask);
}
prefix_len = atol(cidr_netmask);
} else if (prefix_len == -1) {
prefix_len = 0;
}
/* get provided interface name (optional) */
prov_ifname = getenv("OCF_RESKEY_nic");
if (inet_pton(AF_INET6, ipv6addr, &addr6) <= 0) {
cl_log(LOG_ERR, "Invalid IPv6 address [%s]", ipv6addr);
usage(argv[0]);
return OCF_ERR_ARGS;
}
/* Check whether this system supports IPv6 */
if (access(IF_INET6, R_OK)) {
cl_log(LOG_ERR, "No support for INET6 on this system.");
return OCF_ERR_GENERIC;
}
/* create the pid file so we can make sure that only one IPv6addr
* for this address is running
*/
if (snprintf(pid_file, sizeof(pid_file), "%s%s", PIDFILE_BASE, ipv6addr)
>= (int)sizeof(pid_file)) {
cl_log(LOG_ERR, "Pid file truncated");
return OCF_ERR_GENERIC;
}
if (write_pid_file(pid_file) < 0) {
return OCF_ERR_GENERIC;
}
/* switch the command */
if (0 == strncmp(START_CMD,argv[1], strlen(START_CMD))) {
ret = start_addr6(&addr6, prefix_len, prov_ifname);
}else if (0 == strncmp(STOP_CMD,argv[1], strlen(STOP_CMD))) {
ret = stop_addr6(&addr6, prefix_len, prov_ifname);
}else if (0 == strncmp(STATUS_CMD,argv[1], strlen(STATUS_CMD))) {
ret = status_addr6(&addr6, prefix_len, prov_ifname);
}else if (0 ==strncmp(MONITOR_CMD,argv[1], strlen(MONITOR_CMD))) {
ret = monitor_addr6(&addr6, prefix_len);
}else if (0 ==strncmp(RELOAD_CMD,argv[1], strlen(RELOAD_CMD))) {
ret = OCF_ERR_UNIMPLEMENTED;
}else if (0 ==strncmp(RECOVER_CMD,argv[1], strlen(RECOVER_CMD))) {
ret = OCF_ERR_UNIMPLEMENTED;
}else if (0 ==strncmp(VALIDATE_CMD,argv[1], strlen(VALIDATE_CMD))) {
/* ipv6addr has been validated by inet_pton, hence a valid IPv6 address */
ret = OCF_SUCCESS;
}else if (0 ==strncmp(ADVT_CMD,argv[1], strlen(MONITOR_CMD))) {
ret = advt_addr6(&addr6, prefix_len, prov_ifname);
}else{
usage(argv[0]);
ret = OCF_ERR_ARGS;
}
/* release the pid file */
unlink(pid_file);
return ret;
}
int main(int argc, char *argv[])
{
int ret;
progname = get_progname(argv[0]);
nodename = get_nodename();
cl_log_set_entity(progname);
cl_log_set_facility(HA_LOG_FACILITY);
cl_inherit_logging_environment(0);
/* read command line option */
opterr = 0;
while (1) {
int c = getopt(argc, argv, "hi:c:t:m:n:r:");
if (c == -1)
break;
switch (c) {
case 'h': /* help*/
usage(stdout);
exit(EXIT_SUCCESS);
case 'i': /* -i <index> */
{
unsigned long l = strtoul(optarg, NULL, 10);
if (l < SFEX_MIN_NUMLOCKS || l > SFEX_MAX_NUMLOCKS) {
cl_log(LOG_ERR,
"index %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
optarg,
(unsigned long)SFEX_MIN_NUMLOCKS,
(unsigned long)SFEX_MAX_NUMLOCKS);
exit(4);
}
lock_index = l;
}
break;
case 'c': /* -c <collision_timeout> */
{
unsigned long l = strtoul(optarg, NULL, 10);
if (l < 1 || l > INT_MAX) {
cl_log(LOG_ERR,
"collision_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
optarg,
(unsigned long)1,
(unsigned long)INT_MAX);
exit(4);
}
collision_timeout = l;
}
break;
case 'm': /* -m <monitor_interval> */
{
unsigned long l = strtoul(optarg, NULL, 10);
if (l < 1 || l > INT_MAX) {
cl_log(LOG_ERR,
"monitor_interval %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
optarg,
(unsigned long)1,
(unsigned long)INT_MAX);
exit(4);
}
monitor_interval = l;
}
break;
case 't': /* -t <lock_timeout> */
{
unsigned long l = strtoul(optarg, NULL, 10);
if (l < 1 || l > INT_MAX) {
cl_log(LOG_ERR,
"lock_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
optarg,
(unsigned long)1,
(unsigned long)INT_MAX);
exit(4);
}
lock_timeout = l;
}
break;
case 'n':
{
free(nodename);
if (strlen(optarg) > SFEX_MAX_NODENAME) {
cl_log(LOG_ERR, "nodename %s is too long. must be less than %d byte.\n",
optarg,
(unsigned int)SFEX_MAX_NODENAME);
exit(EXIT_FAILURE);
}
nodename = strdup(optarg);
}
break;
case 'r':
{
rsc_id = strdup(optarg);
}
break;
case '?': /* error */
usage(stderr);
exit(4);
}
}
/* check parameter except the option */
if (optind >= argc) {
cl_log(LOG_ERR, "no device specified.\n");
usage(stderr);
exit(EXIT_FAILURE);
} else if (optind + 1 < argc) {
cl_log(LOG_ERR, "too many arguments.\n");
usage(stderr);
exit(EXIT_FAILURE);
}
device = argv[optind];
prepare_lock(device);
#if !SFEX_TESTING
sysrq_fd = open("/proc/sysrq-trigger", O_WRONLY);
if (sysrq_fd == -1) {
cl_log(LOG_ERR, "failed to open /proc/sysrq-trigger due to %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
#endif
ret = lock_index_check(&cdata, lock_index);
if (ret == -1)
exit(EXIT_FAILURE);
{
struct sigaction sig_act;
sigemptyset (&sig_act.sa_mask);
sig_act.sa_flags = SA_SIGINFO;
sig_act.sa_sigaction = quit_handler;
ret = sigaction(SIGTERM, &sig_act, NULL);
if (ret == -1) {
cl_log(LOG_ERR, "sigaction failed\n");
exit(EXIT_FAILURE);
}
}
cl_log(LOG_INFO, "Starting SFeX Daemon...\n");
/* acquire lock first.*/
acquire_lock();
if (daemon(0, 1) != 0) {
cl_perror("%s::%d: daemon() failed.", __FUNCTION__, __LINE__);
release_lock();
exit(EXIT_FAILURE);
}
cl_make_realtime(-1, -1, 128, 128);
cl_log(LOG_INFO, "SFeX Daemon started.\n");
while (1) {
sleep (monitor_interval);
update_lock();
}
}
int
main(int argc, char *argv[])
{
int c = -1;
char errbuf[LIBNET_ERRBUF_SIZE];
char* device;
char* ipaddr;
char* macaddr;
char* broadcast;
char* netmask;
u_int32_t ip;
u_char src_mac[6];
LTYPE* l;
int repeatcount = 1;
int j;
long msinterval = 1000;
int flag;
char pidfilenamebuf[64];
char *pidfilename = NULL;
CL_SIGNAL(SIGTERM, byebye);
CL_SIGINTERRUPT(SIGTERM, 1);
cl_log_set_entity(SENDARPNAME);
cl_log_enable_stderr(TRUE);
cl_log_set_facility(LOG_USER);
cl_inherit_logging_environment(0);
while ((flag = getopt(argc, argv, "i:r:p:")) != EOF) {
switch(flag) {
case 'i': msinterval= atol(optarg);
break;
case 'r': repeatcount= atoi(optarg);
break;
case 'p': pidfilename= optarg;
break;
default: fprintf(stderr, "%s\n\n", print_usage);
return 1;
break;
}
}
if (argc-optind != 5) {
fprintf(stderr, "%s\n\n", print_usage);
return 1;
}
/*
* argv[optind+1] DEVICE dc0,eth0:0,hme0:0,
* argv[optind+2] IP 192.168.195.186
* argv[optind+3] MAC ADDR 00a0cc34a878
* argv[optind+4] BROADCAST 192.168.195.186
* argv[optind+5] NETMASK ffffffffffff
*/
device = argv[optind];
ipaddr = argv[optind+1];
macaddr = argv[optind+2];
broadcast = argv[optind+3];
netmask = argv[optind+4];
if (!pidfilename) {
if (snprintf(pidfilenamebuf, sizeof(pidfilenamebuf), "%s%s",
PIDFILE_BASE, ipaddr) >=
(int)sizeof(pidfilenamebuf)) {
cl_log(LOG_INFO, "Pid file truncated");
return EXIT_FAILURE;
}
pidfilename = pidfilenamebuf;
}
if(write_pid_file(pidfilename) < 0) {
return EXIT_FAILURE;
}
#if defined(HAVE_LIBNET_1_0_API)
#ifdef ON_DARWIN
if ((ip = libnet_name_resolve((unsigned char*)ipaddr, 1)) == -1UL) {
#else
if ((ip = libnet_name_resolve(ipaddr, 1)) == -1UL) {
#endif
cl_log(LOG_ERR, "Cannot resolve IP address [%s]", ipaddr);
unlink(pidfilename);
return EXIT_FAILURE;
}
l = libnet_open_link_interface(device, errbuf);
if (!l) {
cl_log(LOG_ERR, "libnet_open_link_interface on %s: %s"
, device, errbuf);
unlink(pidfilename);
return EXIT_FAILURE;
}
#elif defined(HAVE_LIBNET_1_1_API)
if ((l=libnet_init(LIBNET_LINK, device, errbuf)) == NULL) {
cl_log(LOG_ERR, "libnet_init failure on %s: %s", device, errbuf);
unlink(pidfilename);
return EXIT_FAILURE;
}
if ((signed)(ip = libnet_name2addr4(l, ipaddr, 1)) == -1) {
cl_log(LOG_ERR, "Cannot resolve IP address [%s]", ipaddr);
unlink(pidfilename);
return EXIT_FAILURE;
}
#else
# error "Must have LIBNET API version defined."
#endif
if (!strcasecmp(macaddr, AUTO_MAC_ADDR)) {
if (get_hw_addr(device, src_mac) < 0) {
cl_log(LOG_ERR, "Cannot find mac address for %s",
device);
unlink(pidfilename);
return EXIT_FAILURE;
}
}
else {
convert_macaddr((unsigned char *)macaddr, src_mac);
}
/*
* We need to send both a broadcast ARP request as well as the ARP response we
* were already sending. All the interesting research work for this fix was
* done by Masaki Hasegawa <*****@*****.**> and his colleagues.
*/
for (j=0; j < repeatcount; ++j) {
c = send_arp(l, ip, (unsigned char*)device, src_mac
, (unsigned char*)broadcast, (unsigned char*)netmask
, ARPOP_REQUEST);
if (c < 0) {
break;
}
mssleep(msinterval / 2);
c = send_arp(l, ip, (unsigned char*)device, src_mac
, (unsigned char *)broadcast
, (unsigned char *)netmask, ARPOP_REPLY);
if (c < 0) {
break;
}
if (j != repeatcount-1) {
mssleep(msinterval / 2);
}
}
unlink(pidfilename);
return c < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
void
convert_macaddr (u_char *macaddr, u_char enet_src[6])
{
int i, pos;
u_char bits[3];
pos = 0;
for (i = 0; i < 6; i++) {
/* Inserted to allow old-style MAC addresses */
if (*macaddr == ':') {
pos++;
}
bits[0] = macaddr[pos++];
bits[1] = macaddr[pos++];
bits[2] = '\0';
enet_src[i] = strtol((const char *)bits, (char **)NULL, 16);
}
}
int
main(int argc, char** argv, char** envp)
{
int c;
gboolean daemonize = FALSE;
gboolean stop_logd = FALSE;
gboolean ask_status= FALSE;
const char* cfgfile = NULL;
pid_t pid;
cmdname = argv[0];
while ((c = getopt(argc, argv, "c:dksvh")) != -1){
switch(c){
case 'd': /* daemonize */
daemonize = TRUE;
break;
case 'k': /* stop */
stop_logd = TRUE;
break;
case 's': /* status */
ask_status = TRUE;
break;
case 'c': /* config file*/
cfgfile = optarg;
break;
case 'v':
verbose = TRUE;
break;
case 'h': /*help message */
default:
usage();
exit(1);
}
}
set_ipc_time_debug_flag(FALSE);
cl_log_set_uselogd(FALSE);
if (!cfgfile && access(DEFAULT_CFG_FILE, F_OK) == 0) {
cfgfile = DEFAULT_CFG_FILE;
}
/* default one set to "logd"
* by setting facility, we enable syslog
*/
cl_log_enable_stderr(TRUE);
cl_log_set_entity(logd_config.entity);
cl_log_set_facility(logd_config.log_facility);
if (ask_status){
long pid;
if( (pid = cl_read_pidfile(LOGD_PIDFILE)) > 0 ){
printf("logging daemon is running [pid = %ld].\n", pid);
exit(LSB_EXIT_OK);
}else{
if (pid == - LSB_STATUS_VAR_PID) {
printf("logging daemon is stopped: %s exists.\n"
, LOGD_PIDFILE);
}else{
printf("logging daemon is stopped.\n");
}
}
exit(-pid);
}
if (stop_logd){
logd_stop();
exit(LSB_EXIT_OK);
}
logd_make_daemon(daemonize);
if (ipc_channel_pair(chanspair) != IPC_OK){
cl_perror("cannot create channel pair IPC");
return -1;
}
if (cfgfile && !parse_config(cfgfile)) {
FILE* f;
if ((f = fopen(cfgfile, "r")) != NULL){
fclose(f);
cl_log(LOG_ERR, "Config file [%s] is incorrect."
, cfgfile);
exit(LSB_EXIT_NOTCONFIGED);
}
}
if (strlen(logd_config.debugfile) > 0) {
cl_log_set_debugfile(logd_config.debugfile);
}
if (strlen(logd_config.logfile) > 0) {
cl_log_set_logfile(logd_config.logfile);
}
cl_log_set_syslogprefix(logd_config.syslogprefix);
cl_log_set_entity(logd_config.entity);
cl_log_set_facility(logd_config.log_facility);
cl_log(LOG_INFO, "logd started with %s.",
cfgfile ? cfgfile : "default configuration");
if (cl_enable_coredumps(TRUE) < 0){
cl_log(LOG_ERR, "enabling core dump failed");
}
cl_cdtocoredir();
chanspair[WRITE_PROC_CHAN]->ops->set_recv_qlen(chanspair[WRITE_PROC_CHAN],
LOGD_QUEUE_LEN);
chanspair[READ_PROC_CHAN]->ops->set_send_qlen(chanspair[READ_PROC_CHAN],
LOGD_QUEUE_LEN);
if (init_set_proc_title(argc, argv, envp) < 0) {
cl_log(LOG_ERR, "Allocation of proc title failed.");
return -1;
}
switch(pid = fork()){
case -1:
cl_perror("Can't fork child process!");
return -1;
case 0:
/*child*/
cl_log_use_buffered_io(1);
set_proc_title("ha_logd: write process");
write_msg_process(chanspair[WRITE_PROC_CHAN]);
break;
default:
/*parent*/
set_proc_title("ha_logd: read process");
write_process_pid = pid;
/* we don't expect to log anything in the parent. */
cl_log_close_log_files();
read_msg_process(chanspair[READ_PROC_CHAN]);
break;
}
return 0;
}
int
main(int argc, char ** argv)
{
int req_restart = FALSE;
int req_status = FALSE;
int req_stop = FALSE;
int argerr = 0;
int flag;
char * inherit_debuglevel;
while ((flag = getopt(argc, argv, OPTARGS)) != EOF) {
switch(flag) {
case 'h': /* Help message */
usage(QUORUMD, LSB_EXIT_OK);
break;
case 'v': /* Debug mode, more logs*/
++debug_level;
break;
case 's': /* Status */
req_status = TRUE;
break;
case 'k': /* Stop (kill) */
req_stop = TRUE;
break;
case 'r': /* Restart */
req_restart = TRUE;
break;
default:
++argerr;
break;
}
}
if (optind > argc) {
quorum_log(LOG_ERR,"WHY WE ARE HERE?");
++argerr;
}
if (argerr) {
usage(QUORUMD, LSB_EXIT_GENERIC);
}
inherit_debuglevel = getenv(HADEBUGVAL);
if (inherit_debuglevel != NULL) {
debug_level = atoi(inherit_debuglevel);
if (debug_level > 2) {
debug_level = 2;
}
}
cl_log_set_entity(QUORUMD);
cl_log_enable_stderr(FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
cl_inherit_logging_environment(0);
if (req_status){
return init_status(PID_FILE, QUORUMD);
}
if (req_stop){
return init_stop(PID_FILE);
}
if (req_restart) {
init_stop(PID_FILE);
}
return init_start();
}
int
main(int argc, char *argv[])
{
int rc;
int retval = 0;
const char* conf_file = CONFIG_FILE;
int pid;
cl_cdtocoredir();
if(argc == 2){
conf_file = argv[1];
}else if(argc > 2){
printf("Usage: %s [config_file]\n", cmdname);
exit(LSB_EXIT_NOTCONFIGED);
}
cl_log_enable_stderr(TRUE);
pid = cl_read_pidfile(PIDFILE);
if (pid > 0 && pid != getpid()){
cl_log(LOG_INFO, "recovermgrd is already running[%d]",
pid);
return 0;
}
cl_log_set_entity(argv[0]);
cl_log_set_facility(LOG_USER);
cl_log(LOG_INFO, "Starting %s", argv[0]);
signal(SIGCHLD, sigchld_handler);
if(parseConfigFile(conf_file) == FALSE){
exit(LSB_EXIT_NOTCONFIGED);
};
/* make self a daemon */
#ifndef DEBUG
daemon(0,0);
#else
printf("Debug mode -- non daemon\n");
#endif
if (cl_lock_pidfile(PIDFILE) < 0){
cl_log(LOG_INFO, "recoverymgrd is already running[%d]",
cl_read_pidfile(PIDFILE));
return 0;
}
/* register with apphbd as a client and send pings */
retval = register_hb();
if (0 != retval)
{
cl_perror("Error registering -- is apphbd running??");
exit(retval);
}
create_connection();
/* unregister and shutdown */
rc = apphb_unregister();
if (rc < 0)
{
cl_perror("apphb_unregister failure");
exit(3);
}
cl_unlock_pidfile(PIDFILE);
return 0;
}
int
main(int argc, char **argv)
{
crm_data_t *cib_object = NULL;
crm_data_t *status = NULL;
int argerr = 0;
int flag;
pe_working_set_t data_set;
cib_t * cib_conn = NULL;
int rc = cib_ok;
gboolean xml_stdin = FALSE;
const char *xml_file = NULL;
const char *xml_string = NULL;
crm_system_name = basename(argv[0]);
g_log_set_handler(NULL,
G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL
| G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE
| G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG
| G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL,
cl_glib_msg_handler, NULL);
/* and for good measure... - this enum is a bit field (!) */
g_log_set_always_fatal((GLogLevelFlags)0); /*value out of range*/
cl_log_set_entity(crm_system_name);
cl_log_set_facility(HA_LOG_FACILITY);
cl_log_enable_stderr(TRUE);
set_crm_log_level(LOG_ERR);
CL_SIGNAL(DEBUG_INC, alter_debug);
CL_SIGNAL(DEBUG_DEC, alter_debug);
while (1) {
#ifdef HAVE_GETOPT_H
int option_index = 0;
static struct option long_options[] = {
/* Top-level Options */
{F_CRM_DATA, 1, 0, 'X'},
{"dtd-file", 1, 0, 'D'},
{"xml-file", 1, 0, 'x'},
{"xml-pipe", 0, 0, 'p'},
{"save-xml", 1, 0, 'S'},
{"live-check", 0, 0, 'L'},
{"help", 0, 0, '?'},
{0, 0, 0, 0}
};
#endif
#ifdef HAVE_GETOPT_H
flag = getopt_long(argc, argv, OPTARGS,
long_options, &option_index);
#else
flag = getopt(argc, argv, OPTARGS);
#endif
if (flag == -1)
break;
switch(flag) {
#ifdef HAVE_GETOPT_H
case 0:
printf("option %s", long_options[option_index].name);
if (optarg)
printf(" with arg %s", optarg);
printf("\n");
break;
#endif
case 'D':
crm_debug_2("Option %c => %s", flag, optarg);
dtd_file = optarg;
break;
case 'X':
crm_debug_2("Option %c => %s", flag, optarg);
xml_string = crm_strdup(optarg);
break;
case 'x':
crm_debug_2("Option %c => %s", flag, optarg);
xml_file = crm_strdup(optarg);
break;
case 'p':
xml_stdin = TRUE;
break;
case 'S':
cib_save = crm_strdup(optarg);
break;
case 'V':
alter_debug(DEBUG_INC);
break;
case 'L':
USE_LIVE_CIB = TRUE;
break;
case '?':
usage(crm_system_name, LSB_EXIT_GENERIC);
break;
default:
printf("?? getopt returned character code 0%o ??\n", flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc) {
printf("%s ", argv[optind++]);
}
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
crm_err("%d errors in option parsing", argerr);
usage(crm_system_name, LSB_EXIT_GENERIC);
}
crm_info("=#=#=#=#= Getting XML =#=#=#=#=");
if(USE_LIVE_CIB) {
cib_conn = cib_new();
rc = cib_conn->cmds->signon(
cib_conn, crm_system_name, cib_command_synchronous);
}
if(USE_LIVE_CIB) {
if(rc == cib_ok) {
int options = cib_scope_local|cib_sync_call;
crm_info("Reading XML from: live cluster");
rc = cib_conn->cmds->query(
cib_conn, NULL, &cib_object, options);
}
if(rc != cib_ok) {
fprintf(stderr, "Live CIB query failed: %s\n",
cib_error2string(rc));
return 3;
}
if(cib_object == NULL) {
fprintf(stderr, "Live CIB query failed: empty result\n");
return 3;
}
} else if(xml_file != NULL) {
FILE *xml_strm = fopen(xml_file, "r");
cib_object = file2xml(xml_strm, FALSE);
if(cib_object == NULL) {
fprintf(stderr,
"Couldn't parse input file: %s\n", xml_file);
return 1;
}
fclose(xml_strm);
} else if(xml_string != NULL) {
cib_object = string2xml(xml_string);
if(cib_object == NULL) {
fprintf(stderr,
"Couldn't parse input string: %s\n", xml_string);
return 1;
}
} else if(xml_stdin) {
cib_object = stdin2xml();
if(cib_object == NULL) {
fprintf(stderr, "Couldn't parse input from STDIN.\n");
return 1;
}
} else {
fprintf(stderr, "No configuration source specified."
" Use --help for usage information.\n");
return 3;
}
if(cib_save != NULL) {
write_xml_file(cib_object, cib_save, FALSE);
}
status = get_object_root(XML_CIB_TAG_STATUS, cib_object);
if(status == NULL) {
create_xml_node(cib_object, XML_CIB_TAG_STATUS);
}
#if CRM_DEPRECATED_SINCE_2_0_4
xml_child_iter_filter(status, node_state, XML_CIB_TAG_STATE,
xml_remove_prop(node_state, XML_CIB_TAG_LRM);
);
static int do_server(int type)
{
int rv = -1;
static char log_ent[128] = DAEMON_NAME "-";
rv = setup_config(type);
if (rv < 0)
return rv;
if (!local) {
log_error("Cannot find myself in the configuration.");
exit(EXIT_FAILURE);
}
if (!daemonize) {
if (daemon(0, 0) < 0) {
perror("daemon error");
exit(EXIT_FAILURE);
}
}
/* The lockfile must be written to _after_ the call to daemon(), so
* that the lockfile contains the pid of the daemon, not the parent. */
lock_fd = create_lockfile();
if (lock_fd < 0)
return lock_fd;
atexit(server_exit);
strcat(log_ent, type_to_string(local->type));
cl_log_set_entity(log_ent);
cl_log_enable_stderr(enable_stderr ? TRUE : FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
cl_inherit_logging_environment(0);
log_info("BOOTH %s %s daemon is starting",
type_to_string(local->type), RELEASE_STR);
signal(SIGUSR1, (__sighandler_t)tickets_log_info);
signal(SIGTERM, (__sighandler_t)sig_exit_handler);
signal(SIGINT, (__sighandler_t)sig_exit_handler);
set_scheduler();
set_oom_adj(-16);
set_proc_title("%s %s %s for [%s]:%d",
DAEMON_NAME,
cl.configfile,
type_to_string(local->type),
local->addr_string,
booth_conf->port);
rv = limit_this_process();
if (rv)
return rv;
if (cl_enable_coredumps(TRUE) < 0){
cl_log(LOG_ERR, "enabling core dump failed");
}
cl_cdtocoredir();
prctl(PR_SET_DUMPABLE, (unsigned long)TRUE, 0UL, 0UL, 0UL);
rv = loop(lock_fd);
return rv;
}
int main(int argc, char *argv[], char *envp[])
{
int rv;
const char *cp;
#ifdef LOGGING_LIBQB
enum qb_log_target_slot i;
#endif
init_set_proc_title(argc, argv, envp);
get_time(&start_time);
memset(&cl, 0, sizeof(cl));
strncpy(cl.configfile,
BOOTH_DEFAULT_CONF, BOOTH_PATH_LEN - 1);
cl.lockfile[0] = 0;
debug_level = 0;
cp = ((cp = strstr(argv[0], ATTR_PROG)) && !strcmp(cp, ATTR_PROG)
? ATTR_PROG
: "booth");
#ifndef LOGGING_LIBQB
cl_log_set_entity(cp);
#else
qb_log_init(cp, LOG_USER, LOG_DEBUG); /* prio driven by debug_level */
for (i = QB_LOG_TARGET_START; i < QB_LOG_TARGET_MAX; i++) {
if (i == QB_LOG_SYSLOG || i == QB_LOG_BLACKBOX)
continue;
qb_log_format_set(i, "%t %H %N: [%P]: %p: %b");
}
(void) qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
QB_LOG_FILTER_FILE, "*", LOG_DEBUG);
#endif
cl_log_enable_stderr(TRUE);
cl_log_set_facility(0);
rv = read_arguments(argc, argv);
if (rv < 0)
goto out;
switch (cl.type) {
case STATUS:
rv = do_status(cl.type);
break;
case ARBITRATOR:
case DAEMON:
case SITE:
rv = do_server(cl.type);
break;
case CLIENT:
rv = do_client();
break;
case GEOSTORE:
rv = do_attr();
break;
}
out:
#ifdef LOGGING_LIBQB
qb_log_fini();
#endif
/* Normalize values. 0x100 would be seen as "OK" by waitpid(). */
return (rv >= 0 && rv < 0x70) ? rv : 1;
}
static int do_server(int type)
{
int rv = -1;
static char log_ent[128] = DAEMON_NAME "-";
rv = setup_config(type);
if (rv < 0)
return rv;
if (!local) {
log_error("Cannot find myself in the configuration.");
exit(EXIT_FAILURE);
}
if (daemonize) {
if (daemon(0, 0) < 0) {
perror("daemon error");
exit(EXIT_FAILURE);
}
}
/* The lockfile must be written to _after_ the call to daemon(), so
* that the lockfile contains the pid of the daemon, not the parent. */
lock_fd = create_lockfile();
if (lock_fd < 0)
return lock_fd;
atexit(server_exit);
strcat(log_ent, type_to_string(local->type));
cl_log_set_entity(log_ent);
cl_log_enable_stderr(enable_stderr ? TRUE : FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
cl_inherit_logging_environment(0);
log_info("BOOTH %s %s daemon is starting",
type_to_string(local->type), RELEASE_STR);
signal(SIGUSR1, (__sighandler_t)tickets_log_info);
signal(SIGTERM, (__sighandler_t)sig_exit_handler);
signal(SIGINT, (__sighandler_t)sig_exit_handler);
/* we'll handle errors there and then */
signal(SIGPIPE, SIG_IGN);
set_scheduler();
/* we don't want to be killed by the OOM-killer */
if (set_procfs_val("/proc/self/oom_score_adj", "-999"))
(void)set_procfs_val("/proc/self/oom_adj", "-16");
set_proc_title("%s %s %s for [%s]:%d",
DAEMON_NAME,
cl.configfile,
type_to_string(local->type),
local->addr_string,
booth_conf->port);
rv = limit_this_process();
if (rv)
return rv;
#ifdef COREDUMP_NURSING
if (cl_enable_coredumps(TRUE) < 0){
log_error("enabling core dump failed");
}
cl_cdtocoredir();
prctl(PR_SET_DUMPABLE, (unsigned long)TRUE, 0UL, 0UL, 0UL);
#else
if (chdir(BOOTH_CORE_DIR) < 0) {
log_error("cannot change working directory to %s", BOOTH_CORE_DIR);
}
#endif
signal(SIGCHLD, (__sighandler_t)wait_child);
rv = loop(lock_fd);
return rv;
}