Home | History | Annotate | Line # | Download | only in apmd
apmd.c revision 1.26 
      1 /*	$NetBSD: apmd.c,v 1.26 2003/06/24 09:41:34 martin Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1996, 2000 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by John Kohl.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 #include <stdio.h>
     40 #include <errno.h>
     41 #include <syslog.h>
     42 #include <fcntl.h>
     43 #include <unistd.h>
     44 #include <util.h>
     45 #include <stdlib.h>
     46 #include <string.h>
     47 #include <signal.h>
     48 #include <sys/types.h>
     49 #include <pwd.h>
     50 #include <grp.h>
     51 #include <sys/stat.h>
     52 #include <sys/ioctl.h>
     53 #include <sys/time.h>
     54 #include <sys/socket.h>
     55 #include <sys/un.h>
     56 #include <sys/wait.h>
     57 #include <poll.h>
     58 #include <machine/apmvar.h>
     59 #include <err.h>
     60 #include "pathnames.h"
     61 #include "apm-proto.h"
     62 
     63 #define MAX(a,b) (a > b ? a : b)
     64 #define TRUE 1
     65 #define FALSE 0
     66 
     67 #define POWER_STATUS_ACON	0x1
     68 #define POWER_STATUS_LOWBATTNOW	0x2
     69 
     70 const char apmdev[] = _PATH_APM_CTLDEV;
     71 const char sockfile[] = _PATH_APM_SOCKET;
     72 
     73 static int debug = 0;
     74 static int verbose = 0;
     75 
     76 void usage (void);
     77 int power_status (int fd, int force, struct apm_power_info *pinfo);
     78 int bind_socket (const char *sn, mode_t mode, uid_t uid, gid_t gid);
     79 enum apm_state handle_client(int sock_fd, int ctl_fd);
     80 void suspend(int ctl_fd);
     81 void stand_by(int ctl_fd);
     82 void resume(int ctl_fd);
     83 void sigexit(int signo);
     84 void make_noise(int howmany);
     85 void do_etc_file(const char *file);
     86 void do_ac_state(int state);
     87 
     88 void
     89 sigexit(int signo)
     90 {
     91     exit(1);
     92 }
     93 
     94 void
     95 usage(void)
     96 {
     97     fprintf(stderr,"usage: %s [-adlqsv] [-t seconds] [-S sockname]\n\t[-m sockmode] [-o sockowner:sockgroup] [-f devname]\n", getprogname());
     98     exit(1);
     99 }
    100 
    101 
    102 int
    103 power_status(int fd, int force, struct apm_power_info *pinfo)
    104 {
    105     struct apm_power_info bstate;
    106     static struct apm_power_info last;
    107     int acon = 0;
    108     int lowbattnow = 0;
    109 
    110     memset(&bstate, 0, sizeof(bstate));
    111     if (ioctl(fd, APM_IOC_GETPOWER, &bstate) == 0) {
    112 	/* various conditions under which we report status:  something changed
    113 	   enough since last report, or asked to force a print */
    114 	if (bstate.ac_state == APM_AC_ON)
    115 	    acon = 1;
    116 	if (bstate.battery_state != last.battery_state  &&
    117 	    bstate.battery_state == APM_BATT_LOW)
    118 		lowbattnow = 1;
    119 	if (force ||
    120 	    bstate.ac_state != last.ac_state ||
    121 	    bstate.battery_state != last.battery_state ||
    122 	    (bstate.minutes_left && bstate.minutes_left < 15) ||
    123 	    abs(bstate.battery_life - last.battery_life) > 20) {
    124 	    if (verbose) {
    125 		if (bstate.minutes_left)
    126 		    syslog(LOG_NOTICE,
    127 		           "battery status: %s. external power status: %s. "
    128 		           "estimated battery life %d%% (%d minutes)",
    129 		           battstate(bstate.battery_state),
    130 		           ac_state(bstate.ac_state), bstate.battery_life,
    131 		           bstate.minutes_left);
    132 		else
    133 		    syslog(LOG_NOTICE,
    134 		           "battery status: %s. external power status: %s. "
    135 		           "estimated battery life %d%%",
    136 		           battstate(bstate.battery_state),
    137 		           ac_state(bstate.ac_state), bstate.battery_life);
    138 	    }
    139 	    last = bstate;
    140 	}
    141 	if (pinfo)
    142 	    *pinfo = bstate;
    143     } else
    144 	syslog(LOG_ERR, "cannot fetch power status: %m");
    145     return ((acon?POWER_STATUS_ACON:0) |
    146 	(lowbattnow?POWER_STATUS_LOWBATTNOW:0));
    147 }
    148 
    149 static char *socketname;
    150 
    151 static void sockunlink(void);
    152 
    153 static void
    154 sockunlink(void)
    155 {
    156     if (socketname)
    157 	(void) remove(socketname);
    158 }
    159 
    160 int
    161 bind_socket(const char *sockname, mode_t mode, uid_t uid, gid_t gid)
    162 {
    163     int sock;
    164     struct sockaddr_un s_un;
    165 
    166     sock = socket(AF_LOCAL, SOCK_STREAM, 0);
    167     if (sock == -1)
    168 	err(1, "cannot create local socket");
    169 
    170     s_un.sun_family = AF_LOCAL;
    171     strncpy(s_un.sun_path, sockname, sizeof(s_un.sun_path));
    172     s_un.sun_len = SUN_LEN(&s_un);
    173     /* remove it if present, we're moving in */
    174     (void) remove(sockname);
    175     if (bind(sock, (struct sockaddr *)&s_un, s_un.sun_len) == -1)
    176 	err(1, "cannot create APM socket");
    177     if (chmod(sockname, mode) == -1 || chown(sockname, uid, gid) == -1)
    178 	err(1, "cannot set socket mode/owner/group to %o/%d/%d",
    179 	    mode, uid, gid);
    180     listen(sock, 1);
    181     socketname = strdup(sockname);
    182     atexit(sockunlink);
    183     return sock;
    184 }
    185 
    186 enum apm_state
    187 handle_client(int sock_fd, int ctl_fd)
    188 {
    189     /* accept a handle from the client, process it, then clean up */
    190     int cli_fd;
    191     struct sockaddr_un from;
    192     int fromlen = sizeof(from);
    193     struct apm_command cmd;
    194     struct apm_reply reply;
    195 
    196     cli_fd = accept(sock_fd, (struct sockaddr *)&from, &fromlen);
    197     if (cli_fd == -1) {
    198 	syslog(LOG_INFO, "client accept failure: %m");
    199 	return NORMAL;
    200     }
    201     if (recv(cli_fd, &cmd, sizeof(cmd), 0) != sizeof(cmd)) {
    202 	(void) close(cli_fd);
    203 	syslog(LOG_INFO, "client size botch");
    204 	return NORMAL;
    205     }
    206     if (cmd.vno != APMD_VNO) {
    207 	close(cli_fd);			/* terminate client */
    208 	/* no error message, just drop it. */
    209 	return NORMAL;
    210     }
    211     power_status(ctl_fd, 0, &reply.batterystate);
    212     switch (cmd.action) {
    213     default:
    214 	reply.newstate = NORMAL;
    215 	break;
    216     case SUSPEND:
    217 	reply.newstate = SUSPENDING;
    218 	break;
    219     case STANDBY:
    220 	reply.newstate = STANDING_BY;
    221 	break;
    222     }
    223     reply.vno = APMD_VNO;
    224     if (send(cli_fd, &reply, sizeof(reply), 0) != sizeof(reply)) {
    225 	syslog(LOG_INFO, "client reply botch");
    226     }
    227     close(cli_fd);
    228     return reply.newstate;
    229 }
    230 
    231 static int speaker_ok = TRUE;
    232 
    233 void
    234 make_noise(howmany)
    235 int howmany;
    236 {
    237     int spkrfd;
    238     int trycnt;
    239 
    240     if (!speaker_ok)		/* don't bother after sticky errors */
    241 	return;
    242 
    243     for (trycnt = 0; trycnt < 3; trycnt++) {
    244 	spkrfd = open(_PATH_DEV_SPEAKER, O_WRONLY);
    245 	if (spkrfd == -1) {
    246 	    switch (errno) {
    247 	    case EBUSY:
    248 		usleep(500000);
    249 		errno = EBUSY;
    250 		continue;
    251 	    case ENOENT:
    252 	    case ENODEV:
    253 	    case ENXIO:
    254 	    case EPERM:
    255 	    case EACCES:
    256 		syslog(LOG_INFO,
    257 		       "speaker device " _PATH_DEV_SPEAKER " unavailable: %m");
    258 		speaker_ok = FALSE;
    259 		return;
    260 	    }
    261 	} else
    262 	    break;
    263     }
    264     if (spkrfd == -1) {
    265 	syslog(LOG_WARNING, "cannot open " _PATH_DEV_SPEAKER ": %m");
    266 	return;
    267     }
    268     syslog(LOG_DEBUG, "sending %d tones to speaker\n", howmany);
    269     write (spkrfd, "o4cc", 2 + howmany);
    270     close(spkrfd);
    271     return;
    272 }
    273 
    274 
    275 void
    276 suspend(int ctl_fd)
    277 {
    278     do_etc_file(_PATH_APM_ETC_SUSPEND);
    279     sync();
    280     make_noise(2);
    281     sync();
    282     sync();
    283     sleep(1);
    284     ioctl(ctl_fd, APM_IOC_SUSPEND, 0);
    285 }
    286 
    287 void
    288 stand_by(int ctl_fd)
    289 {
    290     do_etc_file(_PATH_APM_ETC_STANDBY);
    291     sync();
    292     make_noise(1);
    293     sync();
    294     sync();
    295     sleep(1);
    296     ioctl(ctl_fd, APM_IOC_STANDBY, 0);
    297 }
    298 
    299 #define TIMO (10*60)			/* 10 minutes */
    300 
    301 void
    302 resume(int ctl_fd)
    303 {
    304     do_etc_file(_PATH_APM_ETC_RESUME);
    305 }
    306 
    307 int
    308 main(int argc, char *argv[])
    309 {
    310     const char *fname = apmdev;
    311     int ctl_fd, sock_fd, ch, ready;
    312     int statonly = 0;
    313     struct pollfd set[2];
    314     struct apm_event_info apmevent;
    315     int suspends, standbys, resumes;
    316     int ac_is_off;
    317     int noacsleep = 0;
    318     int lowbattsleep = 0;
    319     mode_t mode = 0660;
    320     unsigned long timeout = TIMO;
    321     const char *sockname = sockfile;
    322     char *user, *group;
    323     char *scratch;
    324     uid_t uid = 0;
    325     gid_t gid = 0;
    326     struct passwd *pw;
    327     struct group *gr;
    328 
    329     while ((ch = getopt(argc, argv, "adlqsvf:t:S:m:o:")) != -1)
    330 	switch(ch) {
    331 	case 'q':
    332 	    speaker_ok = FALSE;
    333 	    break;
    334 	case 'a':
    335 	    noacsleep = 1;
    336 	    break;
    337 	case 'l':
    338 	    lowbattsleep = 1;
    339 	    break;
    340 	case 'd':
    341 	    debug = 1;
    342 	    break;
    343 	case 'v':
    344 	    verbose = 1;
    345 	    break;
    346 	case 'f':
    347 	    fname = optarg;
    348 	    break;
    349 	case 'S':
    350 	    sockname = optarg;
    351 	    break;
    352 	case 't':
    353 	    timeout = strtoul(optarg, 0, 0);
    354 	    if (timeout == 0)
    355 		usage();
    356 	    break;
    357 	case 'm':
    358 	    mode = strtoul(optarg, 0, 8);
    359 	    if (mode == 0)
    360 		usage();
    361 	    break;
    362 	case 'o':
    363 	    /* (user):(group) */
    364 	    user = optarg;
    365 	    group = strchr(user, ':');
    366 	    if (group)
    367 		*group++ = '\0';
    368 	    if (*user) {
    369 		uid = strtoul(user, &scratch, 0);
    370 		if (*scratch != '\0') {
    371 		    pw = getpwnam(user);
    372 		    if (pw)
    373 			uid = pw->pw_uid;
    374 		    else
    375 			errx(1, "user name `%s' unknown", user);
    376 		}
    377 	    }
    378 	    if (group && *group) {
    379 		gid = strtoul(group, &scratch, 0);
    380 		if (*scratch != '\0') {
    381 		    gr = getgrnam(group);
    382 		    if (gr)
    383 			gid = gr->gr_gid;
    384 		    else
    385 			errx(1, "group name `%s' unknown", group);
    386 		}
    387 	    }
    388 	    break;
    389 	case 's':			/* status only */
    390 	    statonly = 1;
    391 	    break;
    392 	case '?':
    393 
    394 	default:
    395 	    usage();
    396 	}
    397     argc -= optind;
    398     argv += optind;
    399     if (debug) {
    400 	openlog("apmd", 0, LOG_LOCAL1);
    401     } else {
    402 	daemon(0, 0);
    403 	openlog("apmd", 0, LOG_DAEMON);
    404 	setlogmask(LOG_UPTO(LOG_NOTICE));
    405 	pidfile(NULL);
    406     }
    407     if ((ctl_fd = open(fname, O_RDWR)) == -1) {
    408 	syslog(LOG_ERR, "cannot open device file `%s'", fname);
    409 	exit(1);
    410     }
    411 
    412     if (statonly) {
    413         power_status(ctl_fd, 1, 0);
    414 	exit(0);
    415     } else {
    416 	struct apm_power_info pinfo;
    417 	power_status(ctl_fd, 1, &pinfo);
    418 	do_ac_state(pinfo.ac_state);
    419 	ac_is_off = (pinfo.ac_state == APM_AC_OFF);
    420     }
    421 
    422     (void) signal(SIGTERM, sigexit);
    423     (void) signal(SIGHUP, sigexit);
    424     (void) signal(SIGINT, sigexit);
    425     (void) signal(SIGPIPE, SIG_IGN);
    426 
    427 
    428     sock_fd = bind_socket(sockname, mode, uid, gid);
    429 
    430     set[0].fd = ctl_fd;
    431     set[0].events = POLLIN;
    432     set[1].fd = sock_fd;
    433     set[1].events = POLLIN;
    434 
    435 
    436     for (errno = 0;
    437 	 (ready = poll(set, 2, timeout * 1000)) >= 0 || errno == EINTR;
    438 	 errno = 0) {
    439 	if (errno == EINTR)
    440 	    continue;
    441 	if (ready == 0) {
    442 		int status;
    443 		/* wakeup for timeout: take status */
    444 		status = power_status(ctl_fd, 0, 0);
    445 		if (lowbattsleep && status&POWER_STATUS_LOWBATTNOW) {
    446 			if (noacsleep && status&POWER_STATUS_ACON) {
    447 				if (debug)
    448 					syslog(LOG_DEBUG,
    449 					    "not sleeping because "
    450 					    "AC is connected");
    451 			} else
    452 				suspend(ctl_fd);
    453 		}
    454 	}
    455 	if (set[0].revents & POLLIN) {
    456 	    suspends = standbys = resumes = 0;
    457 	    while (ioctl(ctl_fd, APM_IOC_NEXTEVENT, &apmevent) == 0) {
    458 		if (debug)
    459 		    syslog(LOG_DEBUG, "apmevent %04x index %d", apmevent.type,
    460 		           apmevent.index);
    461 		switch (apmevent.type) {
    462 		case APM_SUSPEND_REQ:
    463 		case APM_USER_SUSPEND_REQ:
    464 		case APM_CRIT_SUSPEND_REQ:
    465 		    suspends++;
    466 		    break;
    467 		case APM_BATTERY_LOW:
    468 		    if (lowbattsleep)
    469 			suspends++;
    470 		    break;
    471 		case APM_USER_STANDBY_REQ:
    472 		case APM_STANDBY_REQ:
    473 		    standbys++;
    474 		    break;
    475 #if 0
    476 		case APM_CANCEL:
    477 		    suspends = standbys = 0;
    478 		    break;
    479 #endif
    480 		case APM_NORMAL_RESUME:
    481 		case APM_CRIT_RESUME:
    482 		case APM_SYS_STANDBY_RESUME:
    483 		    resumes++;
    484 		    break;
    485 		case APM_POWER_CHANGE:
    486 		{
    487 		    struct apm_power_info pinfo;
    488 		    power_status(ctl_fd, 0, &pinfo);
    489 		    /* power status can change without ac status changing */
    490 		    if (ac_is_off != (pinfo.ac_state == APM_AC_OFF)) {
    491 		    	do_ac_state(pinfo.ac_state);
    492 			ac_is_off = (pinfo.ac_state == APM_AC_OFF);
    493 		    }
    494 		    break;
    495 		}
    496 		default:
    497 		    break;
    498 		}
    499 	    }
    500 	    if ((standbys || suspends) && noacsleep &&
    501 		(power_status(ctl_fd, 0, 0) & POWER_STATUS_ACON)) {
    502 		if (debug)
    503 		    syslog(LOG_DEBUG, "not sleeping because AC is connected");
    504 	    } else if (suspends) {
    505 		suspend(ctl_fd);
    506 	    } else if (standbys) {
    507 		stand_by(ctl_fd);
    508 	    } else if (resumes) {
    509 		resume(ctl_fd);
    510 		if (verbose)
    511 		    syslog(LOG_NOTICE, "system resumed from APM sleep");
    512 	    }
    513 	    ready--;
    514 	}
    515 	if (ready == 0)
    516 	    continue;
    517 	if (set[1].revents & POLLIN) {
    518 	    switch (handle_client(sock_fd, ctl_fd)) {
    519 	    case NORMAL:
    520 		break;
    521 	    case SUSPENDING:
    522 		suspend(ctl_fd);
    523 		break;
    524 	    case STANDING_BY:
    525 		stand_by(ctl_fd);
    526 		break;
    527 	    }
    528 	}
    529     }
    530     syslog(LOG_ERR, "select failed: %m");
    531     exit(1);
    532 }
    533 
    534 void
    535 do_etc_file(const char *file)
    536 {
    537     pid_t pid;
    538     int status;
    539     const char *prog;
    540 
    541     /* If file doesn't exist, do nothing. */
    542     if (access(file, X_OK|R_OK)) {
    543 	if (debug)
    544 	    syslog(LOG_DEBUG, "do_etc_file(): cannot access file %s", file);
    545 	return;
    546     }
    547 
    548     prog = strrchr(file, '/');
    549     if (prog)
    550 	prog++;
    551     else
    552 	prog = file;
    553 
    554     pid = fork();
    555     switch (pid) {
    556     case -1:
    557 	syslog(LOG_ERR, "failed to fork(): %m");
    558 	return;
    559     case 0:
    560 	/* We are the child. */
    561 	if (execl(file, prog, NULL) == -1)
    562 		syslog(LOG_ERR, "could not execute \"%s\": %m", file);
    563 	_exit(1);
    564 	/* NOTREACHED */
    565     default:
    566 	/* We are the parent. */
    567 	wait4(pid, &status, 0, 0);
    568 	if (WIFEXITED(status)) {
    569 	    if (debug)
    570 		syslog(LOG_DEBUG, "%s exited with status %d", file,
    571 		       WEXITSTATUS(status));
    572 	} else
    573 	    syslog(LOG_ERR, "%s exited abnormally.", file);
    574 	break;
    575     }
    576 }
    577 
    578 void
    579 do_ac_state(int state)
    580 {
    581 	switch (state) {
    582 	case APM_AC_OFF:
    583 		do_etc_file(_PATH_APM_ETC_BATTERY);
    584 		break;
    585 	case APM_AC_ON:
    586 	case APM_AC_BACKUP:
    587 		do_etc_file(_PATH_APM_ETC_LINE);
    588 		break;
    589 	default:
    590 		/* Silently ignore */ ;
    591 	}
    592 }
    593