* Copyright (c) 2003 Wasabi Systems, Inc.

/* $NetBSD: powerd.c,v 1.21 2023/08/03 08:03:19 mrg Exp $ */

/*
* Copyright (c) 2003 Wasabi Systems, Inc.
* All rights reserved.
*
* Written by Jason R. Thorpe for Wasabi Systems, Inc.
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed for the NetBSD Project by
* Wasabi Systems, Inc.
* 4. The name of Wasabi Systems, Inc. may not be used to endorse
* or promote products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
* 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.
*/

/*
* Power management daemon for sysmon.
*/

#define SYSLOG_NAMES

#include <sys/cdefs.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/event.h>
#include <sys/power.h>
#include <sys/wait.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <syslog.h>
#include <unistd.h>
#include <util.h>
#include <prop/proplib.h>
#include <stdarg.h>
#include <string.h>

#include "prog_ops.h"

int debug, no_scripts;

static int kq;

#define _PATH_POWERD_SCRIPTS "/etc/powerd/scripts"

static void usage(void) __dead;
static void run_script(const char *[]);
static struct kevent *allocchange(void);
static int wait_for_events(struct kevent *, size_t);
static void dispatch_dev_power(struct kevent *);
static void dispatch_power_event_state_change(int, power_event_t *);
static void powerd_log(int, const char *, ...) __printflike(2, 3);

static const char *script_paths[] = {
NULL,
_PATH_POWERD_SCRIPTS
};

int
main(int argc, char *argv[])
{
struct kevent *ev, events[16];
struct power_type power_type;
char *cp;
int ch, fd;

setprogname(*argv);

if (prog_init && prog_init() == -1)
err(1, "init failed");

while ((ch = getopt(argc, argv, "dn")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;

case 'n':
no_scripts = 1;
break;

default:
usage();
}
}
argc -= optind;
argv += optind;

if (argc)
usage();

if (debug == 0) {
(void)daemon(0, 0);

openlog("powerd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
(void)pidfile(NULL);
}

if ((kq = prog_kqueue()) == -1) {
powerd_log(LOG_ERR, "kqueue: %s", strerror(errno));
exit(EX_OSERR);
}

if ((fd = prog_open(_PATH_POWER, O_RDONLY|O_NONBLOCK, 0600)) == -1) {
powerd_log(LOG_ERR, "open %s: %s", _PATH_POWER,
strerror(errno));
exit(EX_OSERR);
}

if (prog_fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
powerd_log(LOG_ERR, "Cannot set close on exec in power fd: %s",
strerror(errno));
exit(EX_OSERR);
}

if (prog_ioctl(fd, POWER_IOC_GET_TYPE, &power_type) == -1) {
powerd_log(LOG_ERR, "POWER_IOC_GET_TYPE: %s", strerror(errno));
exit(EX_OSERR);
}

(void)asprintf(&cp, "%s/%s", _PATH_POWERD_SCRIPTS,
power_type.power_type);
if (cp == NULL) {
powerd_log(LOG_ERR, "allocating script path: %s",
strerror(errno));
exit(EX_OSERR);
}
script_paths[0] = cp;

ev = allocchange();
EV_SET(ev, fd, EVFILT_READ, EV_ADD | EV_ENABLE,
0, 0, (intptr_t) dispatch_dev_power);

for (;;) {
void (*handler)(struct kevent *);
int i, rv;

rv = wait_for_events(events, __arraycount(events));
for (i = 0; i < rv; i++) {
handler = (void *) events[i].udata;
(*handler)(&events[i]);
}
}
}

static void
usage(void)
{

(void)fprintf(stderr, "usage: %s [-dn]\n", getprogname());
exit(EX_USAGE);
}

static void
run_script(const char *argv[])
{
char path[MAXPATHLEN+1];
size_t i, j;

for (i = 0; i < __arraycount(script_paths); i++) {
(void)snprintf(path, sizeof(path), "%s/%s", script_paths[i],
argv[0]);
if (access(path, R_OK|X_OK) == 0) {
int status;
pid_t pid;
const char *orig_argv0 = argv[0];

argv[0] = path;

if (debug) {
(void)fprintf(stderr, "%srunning script: %s",
no_scripts?"not ":"", argv[0]);
for (j = 1; argv[j] != NULL; j++)
(void)fprintf(stderr, " %s", argv[j]);
(void)fprintf(stderr, "\n");
}
if (no_scripts != 0) {
argv[0] = orig_argv0;
return;
}

switch ((pid = vfork())) {
case -1:
powerd_log(LOG_ERR, "fork to run script: %s",
strerror(errno));
argv[0] = orig_argv0;
return;

case 0:
/* Child. */
(void) execv(path, __UNCONST(argv));
_exit(1);
/* NOTREACHED */

default:
/* Parent. */
if (waitpid(pid, &status, 0) == -1) {
powerd_log(LOG_ERR,
"waitpid for %s: %s", path,
strerror(errno));
break;
}
if (WIFEXITED(status) &&
WEXITSTATUS(status) != 0) {
powerd_log(LOG_ERR,
"%s exited with status %d",
path, WEXITSTATUS(status));
} else if (!WIFEXITED(status)) {
powerd_log(LOG_ERR,
"%s terminated abnormally", path);
}
break;
}
argv[0] = orig_argv0;

return;
}
}

powerd_log(LOG_ERR, "no script for %s", argv[0]);
}

static struct kevent changebuf[8];
static size_t nchanges;

static struct kevent *
allocchange(void)
{

if (nchanges == __arraycount(changebuf)) {
(void)wait_for_events(NULL, 0);
nchanges = 0;
}

return &changebuf[nchanges++];
}

static int
wait_for_events(struct kevent *events, size_t nevents)
{
int rv;

while ((rv = prog_kevent(kq, nchanges ? changebuf : NULL, nchanges,
events, nevents, NULL)) < 0) {
nchanges = 0;
if (errno != EINTR) {
powerd_log(LOG_ERR, "kevent: %s", strerror(errno));
exit(EX_OSERR);
}
}

return rv;
}

static void
dispatch_dev_power(struct kevent *ev)
{
power_event_t pev;
int fd = ev->ident;

if (debug)
(void)fprintf(stderr, "%s: %" PRId64
" event%s available\n", __func__,
ev->data, ev->data > 1 ? "s" : "");

again:
if (prog_read(fd, &pev, sizeof(pev)) != sizeof(pev)) {
if (errno == EWOULDBLOCK)
return;
powerd_log(LOG_ERR, "read of %s: %s", _PATH_POWER,
strerror(errno));
exit(EX_OSERR);
}

if (debug)
(void)fprintf(stderr, "%s: event type %d\n",
__func__, pev.pev_type);

switch (pev.pev_type) {
case POWER_EVENT_ENVSYS_STATE_CHANGE:
case POWER_EVENT_SWITCH_STATE_CHANGE:
dispatch_power_event_state_change(fd, &pev);
break;
default:
powerd_log(LOG_INFO, "unknown %s event type: %d",
_PATH_POWER, pev.pev_type);
}

goto again;
}

static void
dispatch_power_event_state_change(int fd, power_event_t *pev)
{
prop_dictionary_t dict;
const char *argv[6];
char *buf = NULL;
int error;

error = prop_dictionary_recv_ioctl(fd, POWER_EVENT_RECVDICT, &dict);
if (error) {
if (debug)
printf("%s: prop_dictionary_recv_ioctl error=%d\n",
__func__, error);
return;
}

if (debug) {
buf = prop_dictionary_externalize(dict);
printf("%s", buf);
free(buf);
}

/* First three arguments are not optional. */
if (!prop_dictionary_get_string(dict, "powerd-script-name", &argv[0])) {
powerd_log(LOG_ERR, "dict does not have powerd-script-name");
return;
}
if (!prop_dictionary_get_string(dict, "driver-name", &argv[1])) {
powerd_log(LOG_ERR, "dict does not have driver-name");
return;
}
if (!prop_dictionary_get_string(dict, "powerd-event-name", &argv[2])) {
powerd_log(LOG_ERR, "dict does not have powerd-event-name");
return;
}

/* These arguments are optional. */
if (!prop_dictionary_get_string(dict, "sensor-name", &argv[3]))
argv[3] = NULL;
if (!prop_dictionary_get_string(dict, "state-description", &argv[4]))
argv[4] = NULL;

argv[5] = NULL;

run_script(argv);
}

static void
powerd_log(int pri, const char *msg, ...)
{
va_list arglist;
unsigned int i;

va_start(arglist, msg);
if (debug == 0)
vsyslog(pri, msg, arglist);
else {
for (i = 0; i < __arraycount(prioritynames); i++)
if (prioritynames[i].c_val == pri)
break;
fprintf(stderr, "%s: ",
(prioritynames[i].c_val == -1) ?
"UNKNOWN" : prioritynames[i].c_name);
vfprintf(stderr, msg, arglist);
}
va_end(arglist);
}