pid_t play_sound(char *sound_cmd, char *soundfile) {
pid_t sound_pid;
char command[600];
sound_pid=0;
if (strlen(sound_cmd)>3 && strlen(soundfile)>1) {
if (last_sound_pid==0) {
// Create a new process to run in
sound_pid = fork();
if (sound_pid!=-1) {
if(sound_pid==0) {
// This is the child process
// Go back to default signal handler instead of
// calling restart() on SIGHUP
(void) signal(SIGHUP,SIG_DFL);
// Change the name of the new child process. So
// far this only works for "ps" listings, not
// for "top". This code only works on Linux.
// For BSD use setproctitle(3), NetBSD can use
// setprogname(2).
#ifdef __linux__
init_set_proc_title(my_argc, my_argv, my_envp);
set_proc_title("%s", "festival process (xastir)");
//fprintf(stderr,"DEBUG: %s\n", Argv[0]);
#endif // __linux__
xastir_snprintf(command,
sizeof(command),
"%s %s/%s",
sound_cmd,
SOUND_DIR,
soundfile);
if (system(command) != 0) {} // We don't care whether it succeeded
exit(0); // Exits only this process, not Xastir itself
}
else {
// This is the parent process
last_sound_pid=sound_pid;
}
} else
fprintf(stderr,"Error! trying to play sound\n");
} else {
sound_pid=last_sound_pid;
/*fprintf(stderr,"Sound already running\n");*/
}
}
return(sound_pid);
}
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, 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[], 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;
}
int main(int argc, char *argv[], char **envp)
{
QueryHandle *res;
time_t tt;
GLOBAL *g;
INSTANCE *instances;
int fval = 0, i = 0, reload = 0;
char *inst, *instance;
FILE *pidf;
openlog(PROGNAME, 0, LOG_INFO | LOG_CRIT | LOG_ERR);
syslog(LOG_INFO, "LMS Daemon started.");
// initialize global structure
g = (GLOBAL *) realloc(NULL, sizeof(GLOBAL));
g->api_version = APIVERSION;
g->db = (DB *) realloc(NULL, sizeof(DB));
g->db->conn = NULL;
// initialize proces name change
init_set_proc_title(argc, argv, envp);
// configuration load sequence - check if LMSini is set
configfile = ( getenv("LMSINI") ? getenv("LMSINI") : "/etc/lms/lms.ini" );
// read environment and command line
driver = ( getenv("LMSDBTYPE") ? getenv("DBTYPE") : strdup("mysql") );
passwd = ( getenv("LMSDBPASS") ? getenv("LMSDBPASS") : "" );
dbname = ( getenv("LMSDBNAME") ? getenv("LMSDBNAME") : "lms" );
user = ( getenv("LMSDBUSER") ? getenv("LMSDBUSER") : "lms" );
port = ( getenv("LMSDBPORT") ? atoi(getenv("LMSDBPORT")) : 0 );
if( getenv("LMSDBHOST") ) strcpy(host, getenv("LMSDBHOST")); else strcpy(host, "localhost");
gethostname(dhost, 255);
// date/time localization according to environement settings
setlocale(LC_TIME, "");
// command line arguments
parse_command_line(argc, argv);
// load configuration file if exist (if not it will use default parameters - only database section)
ini = config_load(configfile, g->db, dhost, "database");
// assign variables
driver = config_getstring(ini, "database", "type", driver);
passwd = config_getstring(ini, "database", "password", passwd);
dbname = config_getstring(ini, "database", "database", dbname);
user = config_getstring(ini, "database", "user", user);
port = config_getint(ini, "database", "port", port);
strcpy(host, config_getstring(ini, "database", "host", host));
// change process name (hide command line args)
set_proc_title(PROGNAME);
str_replace(&driver, "postgres", "pgsql"); // postgres in ini file is pgsql
str_replace(&driver, "mysqli", "mysql"); // mysqli in ini file is mysql
char dbdrv_path[strlen(LMS_LIB_DIR) + strlen(driver) + 4];
sprintf(dbdrv_path, LMS_LIB_DIR "/%s.so", driver);
if( !file_exists(dbdrv_path))
{
syslog(LOG_CRIT, "Database driver '%s' does not exist. Could not find '%s'.", driver, dbdrv_path);
fprintf(stderr, "Database driver '%s' does not exist. Could not find '%s'.\n", driver, dbdrv_path);
exit(1);
}
void *dbdrv;
dbdrv = dlopen(dbdrv_path, RTLD_NOW);
if( !dbdrv )
{
char * errMsg = dlerror();
syslog(LOG_CRIT, "Unable to load database driver '%s': %s", dbdrv_path, errMsg);
fprintf(stderr, "Unable to load database driver '%s': %s.\n", dbdrv_path, errMsg);
exit(1);
}
else
{
syslog(LOG_INFO, "Database driver '%s' loaded.", driver);
}
g->db->connect = dlsym(dbdrv, "db_connect");
g->db->disconnect = dlsym(dbdrv, "db_disconnect");
g->db->query = dlsym(dbdrv, "db_query");
g->db->pquery = dlsym(dbdrv, "db_pquery");
g->db->exec = dlsym(dbdrv, "db_exec");
g->db->pexec = dlsym(dbdrv, "db_pexec");
g->db->last_insert_id = dlsym(dbdrv, "db_last_insert_id");
g->db->free = dlsym(dbdrv, "db_free");
g->db->begin = dlsym(dbdrv, "db_begin");
g->db->commit = dlsym(dbdrv, "db_commit");
g->db->abort = dlsym(dbdrv, "db_abort");
g->db->get_data = dlsym(dbdrv, "db_get_data");
g->db->nrows = dlsym(dbdrv, "db_nrows");
g->db->ncols = dlsym(dbdrv, "db_ncols");
g->db->concat = dlsym(dbdrv, "db_concat");
g->db->escape = dlsym(dbdrv, "db_escape");
g->db->colname = dlsym(dbdrv, "db_colname");
// test database connection
if( !(g->db->conn = g->db->connect(dbname,user,passwd,host,port,ssl)) )
{
fprintf(stderr, "CRITICAL: Could not connect to database. See logs for details.\n");
termination_handler(1);
}
res = g->db->pquery(g->db->conn, "SELECT count(*) FROM dbinfo");
if( ! g->db->nrows(res) )
{
fprintf(stderr, "CRITICAL: Could not query database. See logs for details.\n");
termination_handler(1);
}
g->db->free(&res);
g->db->disconnect(g->db->conn);
g->str_replace = &str_replace;
g->str_save = &str_save;
g->str_concat = &str_concat;
g->str_lwc = &str_lwc;
g->str_upc = &str_upc;
g->va_list_join = &va_list_join;
g->config_getstring = &config_getstring;
g->config_getint = &config_getint;
g->config_getbool = &config_getbool;
g->config_getdouble = &config_getdouble;
// catch SIGCHLD to catch zombies
sa.sa_handler = sig_child;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGCHLD, &sa, &orig);
// daemonize
if ( !quit && !dontfork )
{
fval = fork();
switch(fval)
{
case -1:
fprintf(stderr, "Fork error. Exiting.");
termination_handler(1);
case 0:
setsid();
break;
default:
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [lmsd] Daemonize. Forked child %d.", fval);
#endif
if (pidfile != NULL && (pidf = fopen(pidfile, "w")) != NULL)
{
fprintf(pidf, "%d", fval);
fclose(pidf);
}
exit(0); // parent exits
}
}
// termination signals handling
signal(SIGINT, termination_handler);
signal(SIGTERM, termination_handler);
// main loop ****************************************************
for(;;)
{
int i_no = 0;
if( quit )
{
reload = 1;
tt = time(0);
}
else // daemon mode
{
reload = 0;
tt = cron_sync_sleep();
}
// run shell command, i.e. secure connections tuneling
if( command!=NULL )
{
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [lmsd] Executing command: %s.", command);
#endif
system(command);
}
// try to connect to database
if( !(g->db->conn = g->db->connect(dbname,user,passwd,host,port,ssl)) )
{
if( quit ) termination_handler(1);
continue;
}
if( !reload )
{
// check reload order
res = g->db->pquery(g->db->conn, "SELECT reload FROM hosts WHERE name = '?' AND reload != 0", dhost);
if( g->db->nrows(res) )
{
reload = 1;
}
g->db->free(&res);
}
instances = (INSTANCE *) malloc(sizeof(INSTANCE));
// get instances list even if reload == 0
// maybe we should do that once before main loop, but in
// this way we can change configuration without daemon restart
if( iopt ) // from command line...
{
inst = strdup(iopt);
for( instance=strtok(inst," "); instance!=NULL; instance=strtok(NULL, " ") )
{
char *name = strdup(instance);
str_replace(&name, "\\s", " "); // instance name with spaces
res = g->db->pquery(g->db->conn, "SELECT module, crontab FROM daemoninstances, hosts WHERE hosts.id = hostid AND disabled = 0 AND hosts.name = '?' AND daemoninstances.name = '?'", dhost, name);
if( g->db->nrows(res) )
{
char *crontab = g->db->get_data(res, 0, "crontab");
if( runall || (reload && !strlen(crontab)) || (!quit && crontab_match(tt, crontab)) )
{
instances = (INSTANCE *) realloc(instances, sizeof(INSTANCE)*(i_no+1));
instances[i_no].name = strdup(name);
instances[i_no].module = strdup(g->db->get_data(res, 0, "module"));
instances[i_no].crontab = strdup(crontab);
i_no++;
}
} else {
syslog(LOG_CRIT, "Host '%s' and/or instance '%s' not found in database!", dhost, name);
fprintf(stderr, "Host '%s' and/or instance '%s' not found in database!\n", dhost, name);
}
g->db->free(&res);
free(name);
}
free(inst);
}
else // ... or from database
{
res = g->db->pquery(g->db->conn, "SELECT module, crontab, daemoninstances.name AS name FROM daemoninstances, hosts WHERE hosts.id = hostid AND disabled = 0 AND hosts.name = '?' ORDER BY priority", dhost);
for(i=0; i<g->db->nrows(res); i++)
{
char *crontab = g->db->get_data(res, i, "crontab");
if( runall || (reload && !strlen(crontab)) || (!quit && crontab_match(tt, crontab)) )
{
instances = (INSTANCE *) realloc(instances, sizeof(INSTANCE)*(i_no+1));
instances[i_no].name = strdup(g->db->get_data(res, i, "name"));
instances[i_no].module = strdup(g->db->get_data(res, i, "module"));
instances[i_no].crontab = strdup(crontab);
i_no++;
}
}
g->db->free(&res);
}
g->db->disconnect(g->db->conn);
if( i_no )
{
// forking reload - we can do a job for longer than one minute
if( quit )
fval = 0; // don't fork in "quit mode"
else
fval = fork();
if( fval < 0 )
{
syslog(LOG_CRIT, "Fork error. Can't reload.");
if ( quit ) termination_handler(1);
}
else if( fval == 0 ) // child or "quit mode"
{
set_proc_title(PROGNAME": reload");
// restore old handler so we can wait for childs executed by modules
if( !quit )
sigaction(SIGCHLD, &orig, NULL);
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [lmsd] Reloading...");
#endif
// try to connect to database again
if( !(g->db->conn = g->db->connect(dbname,user,passwd,host,port,ssl)) )
{
if( quit )
termination_handler(1);
else
exit(1);
}
// write reload timestamp and disable reload order
if( reload )
g->db->pexec(g->db->conn, "UPDATE hosts SET lastreload = %NOW%, reload = 0 WHERE name = '?'", dhost);
for(i=0; i<i_no; i++)
{
MODULE *m;
MODULE *mod = (MODULE*) malloc(sizeof(MODULE));
MODULE * (*init)(GLOBAL *, MODULE *);
char path[strlen(LMS_LIB_DIR) + strlen(instances[i].module) + 4];
// get instance configuration and members
mod->ini = config_load(configfile, g->db, dhost, instances[i].name);
mod->instance = strdup(instances[i].name);
// set path to module if not specified
// be sure that it has .so extension
str_replace(&instances[i].module, ".so", "");
if( instances[i].module[0] == '/' )
sprintf(path, "%s.so", instances[i].module);
else
sprintf(path, LMS_LIB_DIR "/%s.so", instances[i].module);
mod->file = strdup(path);
// try to load module
mod->dlh = dlopen(mod->file, RTLD_NOW);
if( !mod->dlh )
{
syslog(LOG_ERR, "Unable to load module '%s': %s", mod->file, dlerror());
free_module(mod);
continue;
}
// initialize module
init = dlsym(mod->dlh, "init");
if( !init )
{
syslog(LOG_CRIT, "Unable to find initialization function in module '%s'. Is that file really a lmsd module?", mod->file);
free_module(mod);
continue;
}
if( !(m = init(g, mod)))
{
syslog(LOG_CRIT, "Unable to initialize module '%s'. Perhaps there is a version mismatch?", mod->file);
free_module(mod);
continue;
}
syslog(LOG_INFO, "Running module: %s", instances[i].module);
// now run module
m->reload(g, m);
// cleanup
free_module(m);
}
g->db->disconnect(g->db->conn);
// exit child (reload) thread
if( !quit )
{
#ifdef DEBUG1
syslog(LOG_INFO, "DEBUG: [lmsd] Reload finished. Exiting child.");
#endif
exit(0);
}
}
else
sleep(10); // it's important to sleep parent for some time
for(i=0; i<i_no; i++)
{
free(instances[i].name);
free(instances[i].module);
free(instances[i].crontab);
}
}
if( quit ) termination_handler(0);
free(instances);
} // end of loop **********************************************
return 0;
}
