int main(int argc, char **argv)
{
const char *prog = xbasename(argv[0]);
verbose = 1; /* TODO: remove when done testing */
/* normally we don't have stderr, so get this going to syslog early */
open_syslog(prog);
syslogbit_set();
upsname = getenv("UPSNAME");
notify_type = getenv("NOTIFYTYPE");
if ((!upsname) || (!notify_type)) {
printf("Error: UPSNAME and NOTIFYTYPE must be set.\n");
printf("This program should only be run from upsmon.\n");
exit(EXIT_FAILURE);
}
/* see if this matches anything in the config file */
checkconf();
exit(EXIT_SUCCESS);
}
krb5_error_code KRB5_LIB_FUNCTION
krb5_addlog_dest(krb5_context context, krb5_log_facility *f, const char *orig)
{
krb5_error_code ret = 0;
int min = 0, max = -1, n;
char c;
const char *p = orig;
n = sscanf(p, "%d%c%d/", &min, &c, &max);
if(n == 2){
if(c == '/') {
if(min < 0){
max = -min;
min = 0;
}else{
max = min;
}
}
}
if(n){
p = strchr(p, '/');
if(p == NULL) {
krb5_set_error_message(context, HEIM_ERR_LOG_PARSE,
N_("failed to parse \"%s\"", ""), orig);
return HEIM_ERR_LOG_PARSE;
}
p++;
}
if(strcmp(p, "STDERR") == 0){
ret = open_file(context, f, min, max, NULL, NULL, stderr, 1);
}else if(strcmp(p, "CONSOLE") == 0){
ret = open_file(context, f, min, max, "/dev/console", "w", NULL, 0);
}else if(strncmp(p, "FILE", 4) == 0 && (p[4] == ':' || p[4] == '=')){
char *fn;
FILE *file = NULL;
int keep_open = 0;
fn = strdup(p + 5);
if(fn == NULL) {
krb5_set_error_message(context, ENOMEM,
N_("malloc: out of memory", ""));
return ENOMEM;
}
if(p[4] == '='){
int i = open(fn, O_WRONLY | O_CREAT |
O_TRUNC | O_APPEND, 0666);
if(i < 0) {
ret = errno;
krb5_set_error_message(context, ret,
N_("open(%s) logile: %s", ""), fn,
strerror(ret));
free(fn);
return ret;
}
rk_cloexec(i);
file = fdopen(i, "a");
if(file == NULL){
ret = errno;
close(i);
krb5_set_error_message(context, ret,
N_("fdopen(%s) logfile: %s", ""),
fn, strerror(ret));
free(fn);
return ret;
}
keep_open = 1;
}
ret = open_file(context, f, min, max, fn, "a", file, keep_open);
}else if(strncmp(p, "DEVICE", 6) == 0 && (p[6] == ':' || p[6] == '=')){
ret = open_file(context, f, min, max, strdup(p + 7), "w", NULL, 0);
}else if(strncmp(p, "SYSLOG", 6) == 0 && (p[6] == '\0' || p[6] == ':')){
char severity[128] = "";
char facility[128] = "";
p += 6;
if(*p != '\0')
p++;
if(strsep_copy(&p, ":", severity, sizeof(severity)) != -1)
strsep_copy(&p, ":", facility, sizeof(facility));
if(*severity == '\0')
strlcpy(severity, "ERR", sizeof(severity));
if(*facility == '\0')
strlcpy(facility, "AUTH", sizeof(facility));
ret = open_syslog(context, f, min, max, severity, facility);
}else{
ret = HEIM_ERR_LOG_PARSE; /* XXX */
krb5_set_error_message (context, ret,
N_("unknown log type: %s", ""), p);
}
return ret;
}
int main(int argc, char **argv)
{
int interval = 30, i;
const char *prog = xbasename(argv[0]);
time_t now, nextpoll = 0;
const char *user = NULL;
struct passwd *new_uid = NULL;
const char *pidfilebase = prog;
logformat = DEFAULT_LOGFORMAT;
user = RUN_AS_USER;
printf("Network UPS Tools %s %s\n", prog, UPS_VERSION);
while ((i = getopt(argc, argv, "+hs:l:i:f:u:Vp:")) != -1) {
switch(i) {
case 'h':
help(prog);
break;
case 's':
monhost = optarg;
break;
case 'l':
logfn = optarg;
break;
case 'i':
interval = atoi(optarg);
break;
case 'f':
logformat = optarg;
break;
case 'u':
user = optarg;
break;
case 'V':
exit(EXIT_SUCCESS);
case 'p':
pidfilebase = optarg;
break;
}
}
argc -= optind;
argv += optind;
/* not enough args for the old way? */
if ((argc == 1) || (argc == 2))
help(prog);
/* see if it's being called in the old style - 3 or 4 args */
/* <system> <logfn> <interval> [<format>] */
if (argc >= 3) {
monhost = argv[0];
logfn = argv[1];
interval = atoi(argv[2]);
}
if (argc >= 4) {
/* read out the remaining argv entries to the format string */
logformat = xmalloc(LARGEBUF);
memset(logformat, '\0', LARGEBUF);
for (i = 3; i < argc; i++)
snprintfcat(logformat, LARGEBUF, "%s ", argv[i]);
}
if (!monhost)
fatalx(EXIT_FAILURE, "No UPS defined for monitoring - use -s <system>");
if (!logfn)
fatalx(EXIT_FAILURE, "No filename defined for logging - use -l <file>");
/* shouldn't happen */
if (!logformat)
fatalx(EXIT_FAILURE, "No format defined - but this should be impossible");
printf("logging status of %s to %s (%is intervals)\n",
monhost, logfn, interval);
if (upscli_splitname(monhost, &upsname, &hostname, &port) != 0) {
fatalx(EXIT_FAILURE, "Error: invalid UPS definition. Required format: upsname[@hostname[:port]]\n");
}
if (upscli_connect(&ups, hostname, port, UPSCLI_CONN_TRYSSL) < 0)
fprintf(stderr, "Warning: initial connect failed: %s\n",
upscli_strerror(&ups));
if (strcmp(logfn, "-") == 0)
logfile = stdout;
else
logfile = fopen(logfn, "a");
if (logfile == NULL)
fatal_with_errno(EXIT_FAILURE, "could not open logfile %s", logfn);
/* now drop root if we have it */
new_uid = get_user_pwent(user);
open_syslog(prog);
if (logfile != stdout)
background();
setup_signals();
writepid(pidfilebase);
become_user(new_uid);
compile_format();
while (exit_flag == 0) {
time(&now);
if (nextpoll > now) {
/* there is still time left, so sleep it off */
sleep(difftime(nextpoll, now));
nextpoll += interval;
} else {
/* we spent more time in polling than the interval allows */
nextpoll = now + interval;
}
if (reopen_flag) {
upslogx(LOG_INFO, "Signal %d: reopening log file",
reopen_flag);
reopen_log();
reopen_flag = 0;
}
/* reconnect if necessary */
if (upscli_fd(&ups) < 0) {
upscli_connect(&ups, hostname, port, 0);
}
run_flist();
/* don't keep connection open if we don't intend to use it shortly */
if (interval > 30) {
upscli_disconnect(&ups);
}
}
upslogx(LOG_INFO, "Signal %d: exiting", exit_flag);
if (logfile != stdout)
fclose(logfile);
upscli_disconnect(&ups);
exit(EXIT_SUCCESS);
}
void rpl_debug::logv_syslog_flush(int level)
{
open_syslog();
syslog(level ? level : LOG_INFO, "%s", syslogbuf);
}
int main(int argc, char *argv[]) {
const char *homedir;
parse_arguments(argc, argv);
flowlist=malloc(sizeof(flist_t));
flist_init(flowlist);
clientlist = malloc(sizeof(flist_t));
flist_init(clientlist);
gflist = malloc(sizeof(global_function_list_t));
gflist->fflist=malloc(sizeof(flist_t));
flist_init(gflist->fflist);
gflist->lock = 0;
homedir = getenv("HOME");
if (homedir == NULL) {
fputs("Environment variable HOME not set. Giving up.\n", stderr);
exit( 1);
}
mapid_conf = printf_string( CONFDIR"/"CONF_FILE );
printf("using %s\n", mapid_conf);
log_level = get_log_level(mapid_conf); // get log level from mapi.conf
if (log_to_syslog) // logging to syslog is enabled
open_syslog(log_level, "MAPID");
log_to_file = set_logging_to_file(mapid_conf, &log_fd_info, &log_fd_debug); // support for logging to file
if (log_to_syslog == 0 && log_to_file == 0)
log_level = LOGGING_DISABLED;
if (log_to_syslog == 0)
printf("logging to syslog: disabled\n");
else
printf("logging to syslog: enabled - LogLevel: %d\n", log_level);
if (log_to_file) {
daemon_started(log_fd_info, "MAPID", daemonize, 0);
daemon_started(log_fd_debug, "MAPID", daemonize, 0);
}
if (log_to_syslog)
log_message(
"MAPID was started %s%s",
daemonize ? " ( is running as daemon )" : "");
drvlist = load_drivers();
if (drvlist == NULL) {
DEBUG_CMD(Debug_Message("ERROR: No MAPI drivers found"));
exit(EXIT_FAILURE);
}
// Grab some signals so we can mapid_shutdown gracefully
signal(SIGTERM, mapid_shutdown);
signal(SIGQUIT, mapid_shutdown);
signal(SIGINT, mapid_shutdown);
if (daemonize)
continue_as_daemon();
mapidcom();
mapid_shutdown(0);
// wait for shutdown to finish
// espenb TODO: use pthread_cond_wait (or similar) instead
while (running_shutdown != 2)
usleep(10000);
return 0;
}
int main(int argc, char *argv[])
{
const char *prog = xbasename(argv[0]);
int i, cmd = 0, checking_flag = 0;
printf("Network UPS Tools %s %s\n", prog, UPS_VERSION);
/* if no configuration file is specified on the command line, use default */
configfile = xmalloc(SMALLBUF);
snprintf(configfile, SMALLBUF, "%s/upsmon.conf", confpath());
configfile = xrealloc(configfile, strlen(configfile) + 1);
run_as_user = xstrdup(RUN_AS_USER);
while ((i = getopt(argc, argv, "+Dhic:f:pu:VK46")) != -1) {
switch (i) {
case 'c':
if (!strncmp(optarg, "fsd", strlen(optarg)))
cmd = SIGCMD_FSD;
if (!strncmp(optarg, "stop", strlen(optarg)))
cmd = SIGCMD_STOP;
if (!strncmp(optarg, "reload", strlen(optarg)))
cmd = SIGCMD_RELOAD;
/* bad command name given */
if (cmd == 0)
help(argv[0]);
break;
case 'D':
nut_debug_level++;
break;
case 'f':
free(configfile);
configfile = xstrdup(optarg);
break;
case 'h':
help(argv[0]);
break;
case 'K':
checking_flag = 1;
break;
case 'p':
use_pipe = 0;
break;
case 'u':
free(run_as_user);
run_as_user = xstrdup(optarg);
break;
case 'V':
/* just show the banner */
exit(EXIT_SUCCESS);
case '4':
opt_af = AF_INET;
break;
case '6':
opt_af = AF_INET6;
break;
default:
help(argv[0]);
break;
}
}
if (cmd) {
sendsignal(prog, cmd);
exit(EXIT_SUCCESS);
}
/* otherwise, we are being asked to start.
* so check if a previous instance is running by sending signal '0'
* (Ie 'kill <pid> 0') */
if (sendsignal(prog, 0) == 0) {
printf("Fatal error: A previous upsmon instance is already running!\n");
printf("Either stop the previous instance first, or use the 'reload' command.\n");
exit(EXIT_FAILURE);
}
argc -= optind;
argv += optind;
open_syslog(prog);
loadconfig();
if (checking_flag)
exit(check_pdflag());
if (shutdowncmd == NULL)
printf("Warning: no shutdown command defined!\n");
/* we may need to get rid of a flag from a previous shutdown */
if (powerdownflag != NULL)
clear_pdflag();
/* FIXME (else): POWERDOWNFLAG is not defined!!
* => fallback to a default value */
if (totalpv < minsupplies) {
printf("\nFatal error: insufficient power configured!\n\n");
printf("Sum of power values........: %d\n", totalpv);
printf("Minimum value (MINSUPPLIES): %d\n", minsupplies);
printf("\nEdit your upsmon.conf and change the values.\n");
exit(EXIT_FAILURE);
}
if (nut_debug_level < 1) {
background();
} else {
upsdebugx(1, "debug level is '%d'", nut_debug_level);
}
/* only do the pipe stuff if the user hasn't disabled it */
if (use_pipe) {
struct passwd *new_uid = get_user_pwent(run_as_user);
/* === root parent and unprivileged child split here === */
start_pipe();
/* write the pid file now, as we will soon lose root */
writepid(prog);
become_user(new_uid);
} else {
upslogx(LOG_INFO, "Warning: running as one big root process by request (upsmon -p)");
writepid(prog);
}
/* prep our signal handlers */
setup_signals();
/* reopen the log for the child process */
closelog();
open_syslog(prog);
while (exit_flag == 0) {
utype_t *ups;
/* check flags from signal handlers */
if (userfsd)
forceshutdown();
if (reload_flag)
reload_conf();
for (ups = firstups; ups != NULL; ups = ups->next)
pollups(ups);
recalc();
/* make sure the parent hasn't died */
if (use_pipe)
check_parent();
/* reap children that have exited */
waitpid(-1, NULL, WNOHANG);
sleep(sleepval);
}
upslogx(LOG_INFO, "Signal %d: exiting", exit_flag);
upsmon_cleanup();
exit(EXIT_SUCCESS);
}