- Good english
[dragonfly.git] / usr.sbin / battd / battd.c
1 /*
2  * Copyright (c) 2003, 2005 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Liam J. Foy <liamfoy@dragonflybsd.org> 
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  * $DragonFly: src/usr.sbin/battd/battd.c,v 1.8 2005/03/09 18:58:22 liamfoy Exp $
35  */
36
37 #include <sys/file.h>
38 #include <sys/ioctl.h>
39 #include <sys/types.h>
40 #include <sys/wait.h>
41
42 #include <machine/apm_bios.h>
43 #include <limits.h>
44
45 #include <err.h>
46 #include <errno.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <syslog.h>
51 #include <unistd.h>
52
53 #define APMUNKNOWN      255 /* Unknown value. */
54 #define AC_LINE_IN      1 /* AC Line Status values. */
55 #define AC_OFFLINE      0
56 #define SECONDS         60
57 #define APM_DEVICE      "/dev/apm" /* Default APM Device. */
58 #define ERR_OUT         1  /* Values for error writing. */
59 #define SYSLOG_OUT      0
60 #define DEFAULT_ALERT   10 /* Default alert is 10%. */
61
62 struct battd_conf {
63         int     alert_per;      /* Percentage to alert user on */
64         int     alert_time;     /* User can also alert when there is only X amount of minutes left */
65         int     alert_status;   /* Alert when battery is either high, low, critical */ 
66         const char      *apm_dev;       /* APM Device */
67         const char      *exec_cmd;      /* Command to execute if desired */     
68 };
69
70 #ifdef DEBUG
71 static int f_debug;
72 #endif
73
74 static int      check_percent(int);
75 static int      check_stat(int);
76 static int      check_time(int);
77 static int      get_apm_info(struct apm_info *, int, const char *, int);
78 static void     execute_cmd(const char *, int *);
79 static void     write_emerg(const char *, int *);
80 static void     usage(void); __dead2
81
82 static void
83 usage(void)
84 {
85 #ifdef DEBUG
86         fprintf(stderr, "usage: battd [-dEhT] [-p percent] [-t minutes] [-s status]\n"
87                         "             [-f device] [-e command] [-c seconds]\n");
88 #else
89         fprintf(stderr, "usage: battd [-EhT] [-p percent] [-t minutes] [-s status]\n"
90                         "             [-f device] [-e command] [-c seconds]\n");
91 #endif
92         exit(EXIT_FAILURE);
93 }
94
95 static int
96 check_percent(int apm_per)
97 {
98         if (apm_per < 0 || apm_per >= APMUNKNOWN || apm_per > 100)
99                 return(1);
100
101         return(0);
102 }
103
104 static int
105 check_time(int apm_time)
106 {
107         if (apm_time == -1)
108                 return(1);
109
110         return(0);
111 }
112
113 static int
114 check_stat(int apm_stat)
115 {
116         if (apm_stat > 3 || apm_stat < 0)
117                 return(1);
118
119         return(0);
120 }
121
122 /* Fetch battery information */
123 static int
124 get_apm_info(struct apm_info *ai, int fp_dev, const char *apm_dev, int err_to)
125 {
126         if (ioctl(fp_dev, APMIO_GETINFO, ai) == -1) {
127                 if (err_to)
128                         err(1, "ioctl(APMIO_GETINFO) device: %s", apm_dev);
129                 else
130                         syslog(LOG_ERR, "ioctl(APMIO_GETINFO) device: %s: %m ",
131                                 apm_dev);
132
133                 return(1);
134         }
135
136         return(0);
137 }
138
139 /* Execute command. */
140 static void
141 execute_cmd(const char *exec_cmd, int *exec_cont)
142 {
143         pid_t pid;
144         int status;
145                 
146         if (exec_cmd != NULL) {
147                 if ((pid = fork()) == -1) {
148                         /* Here fork failed */
149 #ifdef DEBUG
150                         if (f_debug)
151                                 warn("fork failed");
152                         else
153 #endif
154                                 syslog(LOG_ERR, "fork failed: %m");
155                 } else if (pid == 0) {
156                         execl("/bin/sh", "/bin/sh", "-c", exec_cmd, NULL);
157                         _exit(EXIT_FAILURE);
158                 } else {
159                         while (waitpid(pid, &status, 0) != pid)
160                                 ;
161                         if (WEXITSTATUS(status)) {
162 #ifdef DEBUG
163                                 if (f_debug)
164                                         warnx("child exited with code %d", status);
165                                 else
166 #endif
167                                         syslog(LOG_ERR, "child exited with code %d", status);
168                         }
169                         if (*exec_cont)
170                                 exec_cmd = NULL;
171                 }
172         }
173 }
174
175 /* Write warning. */
176 static void
177 write_emerg(const char *eme_msg, int *warn_cont)
178 {
179         if (*warn_cont == 0) {
180                 openlog("battd", LOG_EMERG, LOG_CONSOLE);
181                 syslog(LOG_ERR, "%s\n", eme_msg);
182                 *warn_cont = 1;
183         }
184 }
185
186 /* Check given numerical arguments. */
187 static int
188 getnum(const char *str)
189 {
190         long val;
191         char *ep;
192
193         errno = 0;
194         val = strtol(str, &ep, 10);
195         if (errno)
196                 err(1, "strtol failed: %s", str);
197
198         if (str == ep || *ep != '\0')
199                 errx(1, "invalid value: %s", str);
200
201         if (val > INT_MAX || val < INT_MIN) {
202                 errno = ERANGE;
203                 errc(1, errno, "getnum failed:");
204         }
205
206         return((int)val);
207 }
208
209 int
210 main(int argc, char **argv)
211 {
212         struct battd_conf battd_options, *opts;
213         struct apm_info ai;
214         int fp_device, exec_cont;
215         int per_warn_cont, time_warn_cont, stat_warn_cont;
216         int check_sec, time_def_alert, def_warn_cont;
217         int c, tmp;
218         char msg[80];
219
220         opts = &battd_options;
221
222         /*
223          * As default, we sleep for 30 seconds before
224          * we next call get_apm_info and do the rounds.
225          * The lower the value, the more accurate. Very
226          * low values could cause a decrease in system
227          * performance. We recommend about 30 seconds.
228          */
229
230         check_sec = 30;
231
232         exec_cont = per_warn_cont = stat_warn_cont = 0;
233         time_warn_cont = time_def_alert = def_warn_cont = 0;
234
235         opts->alert_per = 0;
236         opts->alert_time = 0;
237         opts->alert_status = -1;
238         opts->exec_cmd = NULL;
239         opts->apm_dev = APM_DEVICE;
240
241         while ((c = getopt(argc, argv, "de:Ep:s:c:f:ht:T")) != -1) {
242                 switch (c) {
243                 case 'c':
244                         /* Parse the check battery interval. */
245                         check_sec = getnum(optarg);
246                         if (check_sec <= 0)
247                                 errx(1, "the interval for checking battery"
248                                         "status must be greater than 0.");
249                         break;
250 #ifdef DEBUG
251                 case 'd':
252                         /* Debug mode. */
253                         f_debug = 1;
254                         break;
255 #endif
256                 case 'e':
257                         /* Command to execute. */
258                         opts->exec_cmd = optarg;
259                         break;
260                 case 'E':
261                         /* Only execute once when any condition has been met. */
262                         exec_cont = 1;
263                         break;
264                 case 'f':
265                         /* Don't use /dev/apm use optarg. */
266                         opts->apm_dev = optarg;
267                         break;
268                 case 'h':
269                         /* Print usage and be done! */
270                         usage();
271                         break;
272                 case 'p':
273                         /*
274                          * Parse percentage to alert on and enable
275                          * battd to monitor the battery percentage.
276                          */
277                         opts->alert_per = getnum(optarg);
278                         if (opts->alert_per <= 0 || opts->alert_per > 100)
279                                 errx(1, "Battery percentage to alert on must be "
280                                         "greater than 0 and less than 100.");
281                         break;
282                 case 's':
283                         /*
284                          * Parse status to alert on and enable
285                          * battd to monitor the battery status.
286                          * We also accept 'high', 'HIGH' or 'HiGh'.
287                          */
288                         if (strcasecmp(optarg, "high") == 0)
289                                 opts->alert_status = 0; /* High */
290                         else if (strcasecmp(optarg, "low") == 0)
291                                 opts->alert_status = 1; /* Low */
292                         else if (strcasecmp(optarg, "critical") == 0)
293                                 opts->alert_status = 2; /* Critical (mental) */
294                         else {
295                                 /* No idea, see what we have. */
296                                 opts->alert_status = getnum(optarg);
297                                 if (opts->alert_status < 0 || opts->alert_status > 2)
298                                         errx(1, "Alert status must be between 0 and 2.");
299                         }
300                         break;
301                 case 't':
302                         /*
303                          * Parse time to alert on and enable
304                          * battd to monitor the time percentage.
305                          */
306                         opts->alert_time = getnum(optarg);
307                         if (opts->alert_time <= 0)
308                                 errx(1, "Alert time must be greater than 0 minutes.");
309                         break;
310                 case 'T':
311                         time_def_alert = 1;
312                         break;
313                 default:
314                         usage();
315                 }
316         }
317
318         if ((fp_device = open(opts->apm_dev, O_RDONLY)) < 0)
319                 err(1, "open failed: %s", opts->apm_dev);
320
321         /* 
322          * Before we become a daemon, first check whether
323          * the actual function requested is supported. If
324          * not, exit and let the user know.
325          */
326
327         /* Start test */
328         get_apm_info(&ai, fp_device, opts->apm_dev, ERR_OUT);
329
330         if (opts->alert_per >= 0)
331                 if (check_percent(ai.ai_batt_life))
332                         errx(1, "invalid/unknown percentage(%d) returned from %s",
333                                 ai.ai_batt_life, opts->apm_dev);
334
335         if (opts->alert_time || time_def_alert)
336                 if (check_time(ai.ai_batt_time))
337                         errx(1, "invalid/unknown time(%d) returned from %s",
338                                 ai.ai_batt_time, opts->apm_dev);
339
340         if (opts->alert_status)
341                 if (check_stat(ai.ai_batt_stat))
342                         errx(1, "invalid/unknown status(%d) returned from %s",
343                                 ai.ai_batt_stat, opts->apm_dev);
344         /* End test */
345
346 #ifdef DEBUG
347         if (f_debug == 0) {
348 #endif
349                 if (daemon(0, 0) == -1)
350                         err(1, "daemon failed");
351 #ifdef DEBUG
352         }
353 #endif
354
355         for (;;) {
356                 if (get_apm_info(&ai, fp_device, opts->apm_dev,
357 #ifdef DEBUG
358                         f_debug ? ERR_OUT : SYSLOG_OUT))
359 #else
360                         SYSLOG_OUT))
361 #endif
362                         /* Recoverable - sleep for check_sec seconds */
363                         goto sleepy_time;
364
365                 /* If we have power, reset the warning values. */
366                 if (ai.ai_acline == AC_LINE_IN) {
367                         per_warn_cont = 0;
368                         time_warn_cont = 0;
369                         stat_warn_cont = 0;
370                         def_warn_cont = 0;
371                 }
372
373                 /*
374                  * If the battery has main power (AC lead is plugged in)
375                  * we skip and sleep for check_sec seconds.
376                  */
377                 if (ai.ai_acline != AC_LINE_IN) {
378                         /*
379                          * Battery has no mains power. Time to do
380                          * our job!
381                          */
382
383                         /*
384                          * Main Processing loop
385                          * --------------------
386                          * 1. Check battery percentage if enabled.
387                          * 2. Check battery time remaining if enabled.
388                          * 3. Check battery status if enabled.
389                          * 4. Deal with default alerts.
390                          */ 
391
392                         /* 1. Check battery percentage if enabled */
393                         if (opts->alert_per) {
394                                 if (check_percent(ai.ai_batt_life)) {
395 #ifdef DEBUG
396                                         if (f_debug) {
397                                                 printf("Invalid percentage (%d) received from %s.\n",
398                                                         ai.ai_batt_life, opts->apm_dev);
399                                         } else {
400 #endif
401                                                 syslog(LOG_ERR, "Invalid percentage received from %s.",
402                                                         opts->apm_dev);
403 #ifdef DEBUG
404                                         }
405 #endif
406                                         continue;
407                                 }
408
409                                 if (ai.ai_batt_life <= (u_int)opts->alert_per) {
410                                         tmp = (ai.ai_batt_life == (u_int)opts->alert_per);
411                                         snprintf(msg, sizeof(msg), "battery has %s %d%%\n",
412                                                 tmp ? "reached" : "fallen below",
413                                                 opts->alert_per);
414                                         execute_cmd(opts->exec_cmd, &exec_cont);
415                                         write_emerg(msg, &per_warn_cont);
416                                 }
417                         }
418
419                         /* 2. Check battery time remaining if enabled */
420                         if (opts->alert_time) {
421                                 if (check_time(ai.ai_batt_time)) {
422 #ifdef DEBUG
423                                         if (f_debug) {
424                                                 printf("Invalid time value (%d) received from %s.\n",
425                                                         ai.ai_batt_time, opts->apm_dev);
426                                         } else {
427 #endif
428                                                 syslog(LOG_ERR, "Invalid time value received from %s.",
429                                                         opts->apm_dev);
430 #ifdef DEBUG
431                                         }
432 #endif
433                                         continue;
434                                 }
435         
436                                 if (ai.ai_batt_time <= (opts->alert_time * SECONDS)) {
437                                         int h, m, s;
438                                         char tmp_time[sizeof "tt:tt:tt" + 1];
439                                         h = ai.ai_batt_time;
440                                         s = h % 60;
441                                         h /= 60;
442                                         m = h % 60;
443                                         h /= 60;
444                                         snprintf(tmp_time, sizeof(tmp_time), "%d:%d:%d\n", h, m, s);
445                                         tmp = (ai.ai_batt_time == opts->alert_time);
446                                         snprintf(msg, sizeof(msg), "battery has %s %d(%s) minutes"
447                                                 "remaining\n", tmp ? "reached" : "fallen below",
448                                                 ai.ai_batt_time / SECONDS, tmp_time);
449                                         execute_cmd(opts->exec_cmd, &exec_cont);
450                                         write_emerg(msg, &time_warn_cont);
451                                 }
452                         }
453
454                         /* 3. Check battery status if enabled */
455                         if (opts->alert_status != -1) {
456                                 if (check_stat(ai.ai_batt_stat)) {
457 #ifdef DEBUG
458                                         if (f_debug) {
459                                                 printf("Invalid status value (%d) received from %s.\n",
460                                                         ai.ai_batt_life, opts->apm_dev);
461                                         } else {
462 #endif
463                                                 syslog(LOG_ERR, "Invalid status value received from %s.",
464                                                         opts->apm_dev);
465 #ifdef DEBUG
466                                         }
467 #endif
468                                         continue;
469                                 }
470
471                                 if (ai.ai_batt_stat >= (u_int)opts->alert_status) {
472                                         const char *batt_status[] = {"high", "low", "critical"};
473
474                                         tmp = (ai.ai_batt_stat == (u_int)opts->alert_status);
475                                         snprintf(msg, sizeof(msg), "battery has %s '%s' status\n",
476                                                 tmp ? "reached" : "fallen below",
477                                                 batt_status[ai.ai_batt_stat]);
478                                         execute_cmd(opts->exec_cmd, &exec_cont);
479                                         write_emerg(msg, &stat_warn_cont);
480                                 }
481                         }
482
483                         /* 4. Deal with default alerts. */ 
484                         if (time_def_alert) {
485                                 if (check_time(ai.ai_batt_time)) {
486                                                 if (ai.ai_batt_time <= DEFAULT_ALERT * SECONDS) {
487                                                         snprintf(msg, sizeof(msg), "WARNING! battery only"
488                                                                  "has roughly %d minutes remaining!\n",
489                                                                 ai.ai_batt_time / SECONDS);
490                                                         write_emerg(msg, NULL);
491                                                 }
492                                 }
493                         }
494
495                         if (ai.ai_batt_life <= DEFAULT_ALERT) {
496                                 tmp = (ai.ai_batt_life == DEFAULT_ALERT);
497                                 snprintf(msg, sizeof(msg), "WARNING! battery has %s %d%%\n",
498                                         tmp ? "reached" : "fallen below",
499                                         DEFAULT_ALERT);
500                                 if (!def_warn_cont)
501                                         execute_cmd(opts->exec_cmd, &exec_cont);
502                                 write_emerg(msg, &def_warn_cont);
503                         }
504
505                 }
506 sleepy_time:
507                 /* Sleep time! Default is 30 seconds */
508                 sleep(check_sec);
509         }
510         return(0);
511 }