int
main(int argc, char ** argv)
{
int flag;
int argerr = 0;
crm_log_init(crm_system_name, LOG_INFO, TRUE, FALSE, 0, NULL);
crm_info("CRM Hg Version: %s\n", HA_HG_VERSION);
while ((flag = getopt(argc, argv, OPTARGS)) != EOF) {
switch(flag) {
case 'V':
cl_log_enable_stderr(1);
alter_debug(DEBUG_INC);
break;
case 'h': /* Help message */
usage(crm_system_name, LSB_EXIT_OK);
break;
default:
++argerr;
break;
}
}
if(argc - optind == 1 && safe_str_eq("metadata", argv[optind])) {
crmd_metadata();
return 0;
} else if(argc - optind == 1 && safe_str_eq("version", argv[optind])) {
fprintf(stderr, "CRM Version: ");
fprintf(stdout, "%s (%s)\n", VERSION, HA_HG_VERSION);
return 0;
}
if (optind > argc) {
++argerr;
}
if (argerr) {
usage(crm_system_name,LSB_EXIT_GENERIC);
}
/* read local config file */
crm_debug_3("Enabling coredumps");
if(cl_enable_coredumps(1) != 0) {
crm_warn("Cannot enable coredumps");
}
if(crm_is_writable(HA_VARLIBDIR"/heartbeat/pengine", NULL,
HA_CCMUSER, HA_APIGROUP, FALSE) == FALSE) {
fprintf(stderr,"ERROR: Bad permissions on "
HA_VARLIBDIR"/heartbeat/pengine... See logs for details\n");
fflush(stderr);
return 100;
}
return crmd_init();
}
/* main loop of the daemon*/
int
init_start ()
{
int ssock;
struct sockaddr_in saddr;
GIOChannel* sch;
/* register pid */
if (cl_lock_pidfile(PID_FILE) < 0) {
quorum_log(LOG_ERR, "already running: [pid %d]."
, cl_read_pidfile(PID_FILE));
quorum_log(LOG_ERR, "Startup aborted (already running)."
"Shutting down.");
exit(100);
}
register_pid(FALSE, sigterm_action);
/* enable coredumps */
quorum_log(LOG_DEBUG, "Enabling coredumps");
cl_cdtocoredir();
cl_enable_coredumps(TRUE);
cl_set_all_coredump_signal_handlers();
/* initialize gnutls */
initialize_tls_global();
/* enable dynamic up/down debug level */
G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGUSR1,
sig_handler, NULL, NULL);
G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGUSR2,
sig_handler, NULL, NULL);
G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGHUP,
sig_handler, NULL, NULL);
/* create the mainloop */
mainloop = g_main_new(FALSE);
/* create the protocal table */
protocols = g_hash_table_new(g_str_hash, g_str_equal);
/* create server socket */
ssock = socket(AF_INET, SOCK_STREAM, 0);
if (ssock == -1) {
quorum_log(LOG_ERR, "Can not create server socket."
"Shutting down.");
exit(100);
}
/* bind server socket*/
memset(&saddr, '\0', sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
saddr.sin_port = htons(PORT);
if (bind(ssock, (struct sockaddr*)&saddr, sizeof(saddr)) == -1) {
quorum_log(LOG_ERR, "Can not bind server socket."
"Shutting down.");
exit(100);
}
if (listen(ssock, 10) == -1) {
quorum_log(LOG_ERR, "Can not start listen."
"Shutting down.");
exit(100);
}
/* create source for server socket and add to the mainloop */
sch = g_io_channel_unix_new(ssock);
g_io_add_watch(sch, G_IO_IN|G_IO_ERR|G_IO_HUP, on_listen, NULL);
/* run the mainloop */
quorum_log(LOG_DEBUG, "main: run the loop...");
quorum_log(LOG_INFO, "Started.");
g_main_run(mainloop);
/* exit, clean the pid file */
if (cl_unlock_pidfile(PID_FILE) == 0) {
quorum_log(LOG_DEBUG, "[%s] stopped", QUORUMD);
}
return 0;
}
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;
}
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;
}
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;
}
