Add battery state monitoring to apmd.

The new syntax available in the config file is:

apm_battery [0-9]+(%|[Mm) (dis|)charging { ... }

The stuff in the braces is the same as the existing case. nn% checks for
a certain percentage of life remaining and nnM checks for a cerain
number of minutes remaining. Specifying "discharge" means that you're
interested in knowing when the battery reaches a certain level while AC
power is off, "charging" the opposite.

The man page needs to be updated.

The code can be fooled. If you SIGHUP the daemon and the battery level
matches a rule it will be performed once per SIGHUP. If the battery
level matches a rule and you repeatedly apply and take away AC power,
the rule will be run once per occurance. This, however, is a feature.
:-) The code also only runs when select() times out, so getting APM
events more often than the timeout interval will result in the rules not
being run. These are things that remain to be overcome.

1 files changed, 165 insertions, 8 deletions

diff --git a/usr.sbin/apmd/apmd.c b/usr.sbin/apmd/apmd.c
index 470bcc6..a285b9b 100644
--- a/usr.sbin/apmd/apmd.c
+++ b/usr.sbin/apmd/apmd.c
@@ -58,7 +58,7 @@ int		debug_level = 0;
 int		verbose = 0;
 const char	*apmd_configfile = APMD_CONFIGFILE;
 const char	*apmd_pidfile = APMD_PIDFILE;
-int             apmctl_fd = -1;
+int             apmctl_fd = -1, apmnorm_fd = -1;
 
 /*
  * table of event handlers
@@ -81,6 +81,13 @@ struct event_config events[EVENT_MAX] = {
 };
 
 /*
+ * 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 *
@@ -207,6 +214,40 @@ free_event_cmd_list(struct event_cmd *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)
+			(void) 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)
@@ -242,11 +283,10 @@ register_apm_event_handlers(
  * execute command
  */
 int
-exec_event_cmd(struct event_config *ev)
+exec_run_cmd(struct event_cmd *p)
 {
 	int status = 0;
 
-	struct event_cmd *p = ev->cmdlist;
 	for (; p; p = p->next) {
 		assert(p->op->act);
 		if (verbose)
@@ -254,10 +294,6 @@ exec_event_cmd(struct event_config *ev)
 		status = p->op->act(p);
 		if (status) {
 			syslog(LOG_NOTICE, "command finished with %d\n", status);
-			if (ev->rejectable) {
-				syslog(LOG_ERR, "canceled");
-				(void) event_cmd_reject_act(NULL);
-			}
 			break;
 		}
 	}
@@ -265,6 +301,22 @@ exec_event_cmd(struct event_config *ev)
 }
 
 /*
+ * 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");
+		(void) event_cmd_reject_act(NULL);
+	}
+	return status;
+}
+
+/*
  * read config file
  */
 extern FILE * yyin;
@@ -303,6 +355,7 @@ void
 dump_config()
 {
 	int i;
+	struct battery_watch_event *q;
 
 	for (i = 0; i < EVENT_MAX; i++) {
 		struct event_cmd * p;
@@ -317,12 +370,28 @@ dump_config()
 			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()
 {
 	int i;
+	struct battery_watch_event *q;
 
 	/* disable events */
 	for (i = 0; i < EVENT_MAX; i++) {
@@ -340,6 +409,13 @@ destroy_config()
 			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
@@ -430,6 +506,72 @@ proc_apmevent(int fd)
 		}
 	}
 }
+
+#define AC_POWER_STATE ((pw_info.ai_acline == 1) ? BATTERY_CHARGING :\
+	BATTERY_DISCHARGING)
+
+void
+check_battery()
+{
+
+	static int first_time=1, last_state;
+
+	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)
+			(void) 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)
+		(void) 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) {
+		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 == 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) {
+				int status;
+				status = exec_run_cmd(p -> cmdlist);
+				exit(status);
+			}
+		}
+}
 void
 event_loop(void)
 {
@@ -461,19 +603,30 @@ event_loop(void)
 
 	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 (select(fdmax + 1, &rfds, 0, 0, 0) < 0) {
+		if ((res=select(fdmax + 1, &rfds, 0, 0, &to)) < 0) {
 			if (errno != EINTR)
 				(void) 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)
 				goto out;
 		}
+
 		if (FD_ISSET(apmctl_fd, &rfds))
 			proc_apmevent(apmctl_fd);
 	}
@@ -526,6 +679,10 @@ main(int ac, char* av[])
 	if (fcntl(signal_fd[0], F_SETFL, O_NONBLOCK) < 0)
 		(void) err(1, "fcntl");
 
+	if ((apmnorm_fd = open(APM_NORM_DEVICEFILE, O_RDWR)) == -1) {
+		(void) err(1, "cannot open device file `%s'", APM_NORM_DEVICEFILE);
+	}
+
 	if ((apmctl_fd = open(APM_CTL_DEVICEFILE, O_RDWR)) == -1) {
 		(void) err(1, "cannot open device file `%s'", APM_CTL_DEVICEFILE);
 	}