freebsd-src/usr.sbin/apmd/apmd.c
Pedro F. Giffuni 1de7b4b805 various: general adoption of SPDX licensing ID tags.
Mainly focus on files that use BSD 2-Clause license, however the tool I
was using misidentified many licenses so this was mostly a manual - error
prone - task.

The Software Package Data Exchange (SPDX) group provides a specification
to make it easier for automated tools to detect and summarize well known
opensource licenses. We are gradually adopting the specification, noting
that the tags are considered only advisory and do not, in any way,
superceed or replace the license texts.

No functional change intended.
2017-11-27 15:37:16 +00:00

708 lines
15 KiB
C

/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* APM (Advanced Power Management) Event Dispatcher
*
* Copyright (c) 1999 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
* Copyright (c) 1999 KOIE Hidetaka <koie@suri.co.jp>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef lint
static const char rcsid[] =
"$FreeBSD$";
#endif /* not lint */
#include <sys/types.h>
#include <assert.h>
#include <bitstring.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <machine/apm_bios.h>
#include "apmd.h"
int debug_level = 0;
int verbose = 0;
int soft_power_state_change = 0;
const char *apmd_configfile = APMD_CONFIGFILE;
const char *apmd_pidfile = APMD_PIDFILE;
int apmctl_fd = -1, apmnorm_fd = -1;
/*
* table of event handlers
*/
#define EVENT_CONFIG_INITIALIZER(EV,R) { #EV, NULL, R },
struct event_config events[EVENT_MAX] = {
EVENT_CONFIG_INITIALIZER(NOEVENT, 0)
EVENT_CONFIG_INITIALIZER(STANDBYREQ, 1)
EVENT_CONFIG_INITIALIZER(SUSPENDREQ, 1)
EVENT_CONFIG_INITIALIZER(NORMRESUME, 0)
EVENT_CONFIG_INITIALIZER(CRITRESUME, 0)
EVENT_CONFIG_INITIALIZER(BATTERYLOW, 0)
EVENT_CONFIG_INITIALIZER(POWERSTATECHANGE, 0)
EVENT_CONFIG_INITIALIZER(UPDATETIME, 0)
EVENT_CONFIG_INITIALIZER(CRITSUSPEND, 1)
EVENT_CONFIG_INITIALIZER(USERSTANDBYREQ, 1)
EVENT_CONFIG_INITIALIZER(USERSUSPENDREQ, 1)
EVENT_CONFIG_INITIALIZER(STANDBYRESUME, 0)
EVENT_CONFIG_INITIALIZER(CAPABILITIESCHANGE, 0)
};
/*
* List of battery events
*/
struct battery_watch_event *battery_watch_list = NULL;
#define BATT_CHK_INTV 10 /* how many seconds between battery state checks? */
/*
* default procedure
*/
struct event_cmd *
event_cmd_default_clone(void *this)
{
struct event_cmd * oldone = this;
struct event_cmd * newone = malloc(oldone->len);
newone->next = NULL;
newone->len = oldone->len;
newone->name = oldone->name;
newone->op = oldone->op;
return newone;
}
/*
* exec command
*/
int
event_cmd_exec_act(void *this)
{
struct event_cmd_exec * p = this;
int status = -1;
pid_t pid;
switch ((pid = fork())) {
case -1:
warn("cannot fork");
break;
case 0:
/* child process */
signal(SIGHUP, SIG_DFL);
signal(SIGCHLD, SIG_DFL);
signal(SIGTERM, SIG_DFL);
execl(_PATH_BSHELL, "sh", "-c", p->line, (char *)NULL);
_exit(127);
default:
/* parent process */
do {
pid = waitpid(pid, &status, 0);
} while (pid == -1 && errno == EINTR);
break;
}
return status;
}
void
event_cmd_exec_dump(void *this, FILE *fp)
{
fprintf(fp, " \"%s\"", ((struct event_cmd_exec *)this)->line);
}
struct event_cmd *
event_cmd_exec_clone(void *this)
{
struct event_cmd_exec * newone = (struct event_cmd_exec *) event_cmd_default_clone(this);
struct event_cmd_exec * oldone = this;
newone->evcmd.next = NULL;
newone->evcmd.len = oldone->evcmd.len;
newone->evcmd.name = oldone->evcmd.name;
newone->evcmd.op = oldone->evcmd.op;
if ((newone->line = strdup(oldone->line)) == NULL)
err(1, "out of memory");
return (struct event_cmd *) newone;
}
void
event_cmd_exec_free(void *this)
{
free(((struct event_cmd_exec *)this)->line);
}
struct event_cmd_op event_cmd_exec_ops = {
event_cmd_exec_act,
event_cmd_exec_dump,
event_cmd_exec_clone,
event_cmd_exec_free
};
/*
* reject command
*/
int
event_cmd_reject_act(void *this __unused)
{
int rc = 0;
if (ioctl(apmctl_fd, APMIO_REJECTLASTREQ, NULL)) {
syslog(LOG_NOTICE, "fail to reject\n");
rc = -1;
}
return rc;
}
struct event_cmd_op event_cmd_reject_ops = {
event_cmd_reject_act,
NULL,
event_cmd_default_clone,
NULL
};
/*
* manipulate event_config
*/
struct event_cmd *
clone_event_cmd_list(struct event_cmd *p)
{
struct event_cmd dummy;
struct event_cmd *q = &dummy;
for ( ;p; p = p->next) {
assert(p->op->clone);
if ((q->next = p->op->clone(p)) == NULL)
err(1, "out of memory");
q = q->next;
}
q->next = NULL;
return dummy.next;
}
void
free_event_cmd_list(struct event_cmd *p)
{
struct event_cmd * q;
for ( ; p ; p = q) {
q = p->next;
if (p->op->free)
p->op->free(p);
free(p);
}
}
int
register_battery_handlers(
int level, int direction,
struct event_cmd *cmdlist)
{
/*
* level is negative if it's in "minutes", non-negative if
* percentage.
*
* direction =1 means we care about this level when charging,
* direction =-1 means we care about it when discharging.
*/
if (level>100) /* percentage > 100 */
return -1;
if (abs(direction) != 1) /* nonsense direction value */
return -1;
if (cmdlist) {
struct battery_watch_event *we;
if ((we = malloc(sizeof(struct battery_watch_event))) == NULL)
err(1, "out of memory");
we->next = battery_watch_list; /* starts at NULL */
battery_watch_list = we;
we->level = abs(level);
we->type = (level<0)?BATTERY_MINUTES:BATTERY_PERCENT;
we->direction = (direction<0)?BATTERY_DISCHARGING:
BATTERY_CHARGING;
we->done = 0;
we->cmdlist = clone_event_cmd_list(cmdlist);
}
return 0;
}
int
register_apm_event_handlers(
bitstr_t bit_decl(evlist, EVENT_MAX),
struct event_cmd *cmdlist)
{
if (cmdlist) {
bitstr_t bit_decl(tmp, EVENT_MAX);
memcpy(&tmp, evlist, bitstr_size(EVENT_MAX));
for (;;) {
int n;
struct event_cmd *p;
struct event_cmd *q;
bit_ffs(tmp, EVENT_MAX, &n);
if (n < 0)
break;
p = events[n].cmdlist;
if ((q = clone_event_cmd_list(cmdlist)) == NULL)
err(1, "out of memory");
if (p) {
while (p->next != NULL)
p = p->next;
p->next = q;
} else {
events[n].cmdlist = q;
}
bit_clear(tmp, n);
}
}
return 0;
}
/*
* execute command
*/
int
exec_run_cmd(struct event_cmd *p)
{
int status = 0;
for (; p; p = p->next) {
assert(p->op->act);
if (verbose)
syslog(LOG_INFO, "action: %s", p->name);
status = p->op->act(p);
if (status) {
syslog(LOG_NOTICE, "command finished with %d\n", status);
break;
}
}
return status;
}
/*
* execute command -- the event version
*/
int
exec_event_cmd(struct event_config *ev)
{
int status = 0;
status = exec_run_cmd(ev->cmdlist);
if (status && ev->rejectable) {
syslog(LOG_ERR, "canceled");
event_cmd_reject_act(NULL);
}
return status;
}
/*
* read config file
*/
extern FILE * yyin;
extern int yydebug;
void
read_config(void)
{
int i;
if ((yyin = fopen(apmd_configfile, "r")) == NULL) {
err(1, "cannot open config file");
}
#ifdef DEBUG
yydebug = debug_level;
#endif
if (yyparse() != 0)
err(1, "cannot parse config file");
fclose(yyin);
/* enable events */
for (i = 0; i < EVENT_MAX; i++) {
if (events[i].cmdlist) {
u_int event_type = i;
if (write(apmctl_fd, &event_type, sizeof(u_int)) == -1) {
err(1, "cannot enable event 0x%x", event_type);
}
}
}
}
void
dump_config(void)
{
int i;
struct battery_watch_event *q;
for (i = 0; i < EVENT_MAX; i++) {
struct event_cmd * p;
if ((p = events[i].cmdlist)) {
fprintf(stderr, "apm_event %s {\n", events[i].name);
for ( ; p ; p = p->next) {
fprintf(stderr, "\t%s", p->name);
if (p->op->dump)
p->op->dump(p, stderr);
fprintf(stderr, ";\n");
}
fprintf(stderr, "}\n");
}
}
for (q = battery_watch_list ; q != NULL ; q = q -> next) {
struct event_cmd * p;
fprintf(stderr, "apm_battery %d%s %s {\n",
q -> level,
(q -> type == BATTERY_PERCENT)?"%":"m",
(q -> direction == BATTERY_CHARGING)?"charging":
"discharging");
for ( p = q -> cmdlist; p ; p = p->next) {
fprintf(stderr, "\t%s", p->name);
if (p->op->dump)
p->op->dump(p, stderr);
fprintf(stderr, ";\n");
}
fprintf(stderr, "}\n");
}
}
void
destroy_config(void)
{
int i;
struct battery_watch_event *q;
/* disable events */
for (i = 0; i < EVENT_MAX; i++) {
if (events[i].cmdlist) {
u_int event_type = i;
if (write(apmctl_fd, &event_type, sizeof(u_int)) == -1) {
err(1, "cannot disable event 0x%x", event_type);
}
}
}
for (i = 0; i < EVENT_MAX; i++) {
struct event_cmd * p;
if ((p = events[i].cmdlist))
free_event_cmd_list(p);
events[i].cmdlist = NULL;
}
for( ; battery_watch_list; battery_watch_list = battery_watch_list -> next) {
free_event_cmd_list(battery_watch_list->cmdlist);
q = battery_watch_list->next;
free(battery_watch_list);
battery_watch_list = q;
}
}
void
restart(void)
{
destroy_config();
read_config();
if (verbose)
dump_config();
}
/*
* write pid file
*/
static void
write_pid(void)
{
FILE *fp = fopen(apmd_pidfile, "w");
if (fp) {
fprintf(fp, "%ld\n", (long)getpid());
fclose(fp);
}
}
/*
* handle signals
*/
static int signal_fd[2];
void
enque_signal(int sig)
{
if (write(signal_fd[1], &sig, sizeof sig) != sizeof sig)
err(1, "cannot process signal.");
}
void
wait_child(void)
{
int status;
while (waitpid(-1, &status, WNOHANG) > 0)
;
}
int
proc_signal(int fd)
{
int rc = 0;
int sig;
while (read(fd, &sig, sizeof sig) == sizeof sig) {
syslog(LOG_INFO, "caught signal: %d", sig);
switch (sig) {
case SIGHUP:
syslog(LOG_NOTICE, "restart by SIG");
restart();
break;
case SIGTERM:
syslog(LOG_NOTICE, "going down on signal %d", sig);
rc = -1;
return rc;
case SIGCHLD:
wait_child();
break;
default:
warn("unexpected signal(%d) received.", sig);
break;
}
}
return rc;
}
void
proc_apmevent(int fd)
{
struct apm_event_info apmevent;
while (ioctl(fd, APMIO_NEXTEVENT, &apmevent) == 0) {
int status;
syslog(LOG_NOTICE, "apmevent %04x index %d\n",
apmevent.type, apmevent.index);
syslog(LOG_INFO, "apm event: %s", events[apmevent.type].name);
if (fork() == 0) {
status = exec_event_cmd(&events[apmevent.type]);
exit(status);
}
}
}
#define AC_POWER_STATE ((pw_info.ai_acline == 1) ? BATTERY_CHARGING :\
BATTERY_DISCHARGING)
void
check_battery(void)
{
static int first_time=1, last_state;
int status;
struct apm_info pw_info;
struct battery_watch_event *p;
/* If we don't care, don't bother */
if (battery_watch_list == NULL)
return;
if (first_time) {
if ( ioctl(apmnorm_fd, APMIO_GETINFO, &pw_info) < 0)
err(1, "cannot check battery state.");
/*
* This next statement isn't entirely true. The spec does not tie AC
* line state to battery charging or not, but this is a bit lazier to do.
*/
last_state = AC_POWER_STATE;
first_time = 0;
return; /* We can't process events, we have no baseline */
}
/*
* XXX - should we do this a bunch of times and perform some sort
* of smoothing or correction?
*/
if ( ioctl(apmnorm_fd, APMIO_GETINFO, &pw_info) < 0)
err(1, "cannot check battery state.");
/*
* If we're not in the state now that we were in last time,
* then it's a transition, which means we must clean out
* the event-caught state.
*/
if (last_state != AC_POWER_STATE) {
if (soft_power_state_change && fork() == 0) {
status = exec_event_cmd(&events[PMEV_POWERSTATECHANGE]);
exit(status);
}
last_state = AC_POWER_STATE;
for (p = battery_watch_list ; p!=NULL ; p = p -> next)
p->done = 0;
}
for (p = battery_watch_list ; p != NULL ; p = p -> next)
if (p -> direction == AC_POWER_STATE &&
!(p -> done) &&
((p -> type == BATTERY_PERCENT &&
p -> level == (int)pw_info.ai_batt_life) ||
(p -> type == BATTERY_MINUTES &&
p -> level == (pw_info.ai_batt_time / 60)))) {
p -> done++;
if (verbose)
syslog(LOG_NOTICE, "Caught battery event: %s, %d%s",
(p -> direction == BATTERY_CHARGING)?"charging":"discharging",
p -> level,
(p -> type == BATTERY_PERCENT)?"%":" minutes");
if (fork() == 0) {
status = exec_run_cmd(p -> cmdlist);
exit(status);
}
}
}
void
event_loop(void)
{
int fdmax = 0;
struct sigaction nsa;
fd_set master_rfds;
sigset_t sigmask, osigmask;
FD_ZERO(&master_rfds);
FD_SET(apmctl_fd, &master_rfds);
fdmax = apmctl_fd > fdmax ? apmctl_fd : fdmax;
FD_SET(signal_fd[0], &master_rfds);
fdmax = signal_fd[0] > fdmax ? signal_fd[0] : fdmax;
memset(&nsa, 0, sizeof nsa);
nsa.sa_handler = enque_signal;
sigfillset(&nsa.sa_mask);
nsa.sa_flags = SA_RESTART;
sigaction(SIGHUP, &nsa, NULL);
sigaction(SIGCHLD, &nsa, NULL);
sigaction(SIGTERM, &nsa, NULL);
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGHUP);
sigaddset(&sigmask, SIGCHLD);
sigaddset(&sigmask, SIGTERM);
sigprocmask(SIG_SETMASK, &sigmask, &osigmask);
while (1) {
fd_set rfds;
int res;
struct timeval to;
to.tv_sec = BATT_CHK_INTV;
to.tv_usec = 0;
memcpy(&rfds, &master_rfds, sizeof rfds);
sigprocmask(SIG_SETMASK, &osigmask, NULL);
if ((res=select(fdmax + 1, &rfds, 0, 0, &to)) < 0) {
if (errno != EINTR)
err(1, "select");
}
sigprocmask(SIG_SETMASK, &sigmask, NULL);
if (res == 0) { /* time to check the battery */
check_battery();
continue;
}
if (FD_ISSET(signal_fd[0], &rfds)) {
if (proc_signal(signal_fd[0]) < 0)
return;
}
if (FD_ISSET(apmctl_fd, &rfds))
proc_apmevent(apmctl_fd);
}
}
int
main(int ac, char* av[])
{
int ch;
int daemonize = 1;
char *prog;
int logopt = LOG_NDELAY | LOG_PID;
while ((ch = getopt(ac, av, "df:sv")) != -1) {
switch (ch) {
case 'd':
daemonize = 0;
debug_level++;
break;
case 'f':
apmd_configfile = optarg;
break;
case 's':
soft_power_state_change = 1;
break;
case 'v':
verbose = 1;
break;
default:
err(1, "unknown option `%c'", ch);
}
}
if (daemonize)
daemon(0, 0);
#ifdef NICE_INCR
nice(NICE_INCR);
#endif
if (!daemonize)
logopt |= LOG_PERROR;
prog = strrchr(av[0], '/');
openlog(prog ? prog+1 : av[0], logopt, LOG_DAEMON);
syslog(LOG_NOTICE, "start");
if (pipe(signal_fd) < 0)
err(1, "pipe");
if (fcntl(signal_fd[0], F_SETFL, O_NONBLOCK) < 0)
err(1, "fcntl");
if ((apmnorm_fd = open(APM_NORM_DEVICEFILE, O_RDWR)) == -1) {
err(1, "cannot open device file `%s'", APM_NORM_DEVICEFILE);
}
if (fcntl(apmnorm_fd, F_SETFD, 1) == -1) {
err(1, "cannot set close-on-exec flag for device file '%s'", APM_NORM_DEVICEFILE);
}
if ((apmctl_fd = open(APM_CTL_DEVICEFILE, O_RDWR)) == -1) {
err(1, "cannot open device file `%s'", APM_CTL_DEVICEFILE);
}
if (fcntl(apmctl_fd, F_SETFD, 1) == -1) {
err(1, "cannot set close-on-exec flag for device file '%s'", APM_CTL_DEVICEFILE);
}
restart();
write_pid();
event_loop();
exit(EXIT_SUCCESS);
}