chrony: fix conversion of clock_last_meas value
[collectd.git] / src / apcups.c
1 /*
2  * collectd - src/apcups.c
3  * Copyright (C) 2006-2015  Florian octo Forster
4  * Copyright (C) 2006       Anthony Gialluca <tonyabg at charter.net>
5  * Copyright (C) 2000-2004  Kern Sibbald
6  * Copyright (C) 1996-1999  Andre M. Hedrick <andre at suse.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of version 2 of the GNU General
10  * Public License as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public
18  * License along with this program; if not, write to the Free
19  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20  * MA 02111-1307, USA.
21  *
22  * Authors:
23  *   Anthony Gialluca <tonyabg at charter.net>
24  *   Florian octo Forster <octo at collectd.org>
25  **/
26
27 #include "collectd.h"
28
29 #include "common.h" /* rrd_update_file */
30 #include "plugin.h" /* plugin_register, plugin_submit */
31
32 #if HAVE_SYS_TYPES_H
33 #include <sys/types.h>
34 #endif
35 #if HAVE_NETDB_H
36 #include <netdb.h>
37 #endif
38
39 #if HAVE_NETINET_IN_H
40 #include <netinet/in.h>
41 #endif
42
43 #ifndef APCUPS_SERVER_TIMEOUT
44 #define APCUPS_SERVER_TIMEOUT 15.0
45 #endif
46
47 #ifndef APCUPS_DEFAULT_NODE
48 #define APCUPS_DEFAULT_NODE "localhost"
49 #endif
50
51 #ifndef APCUPS_DEFAULT_SERVICE
52 #define APCUPS_DEFAULT_SERVICE "3551"
53 #endif
54
55 /*
56  * Private data types
57  */
58 typedef struct {
59   gauge_t linev;
60   gauge_t loadpct;
61   gauge_t bcharge;
62   gauge_t timeleft;
63   gauge_t outputv;
64   gauge_t itemp;
65   gauge_t battv;
66   gauge_t linefreq;
67 } apc_detail_t;
68
69 /*
70  * Private variables
71  */
72 /* Default values for contacting daemon */
73 static char *conf_node = NULL;
74 static char *conf_service = NULL;
75 /* Defaults to false for backwards compatibility. */
76 static _Bool conf_report_seconds = 0;
77 static _Bool conf_persistent_conn = 1;
78
79 static int global_sockfd = -1;
80
81 static int count_retries = 0;
82 static int count_iterations = 0;
83
84 static int net_shutdown(int *fd) {
85   uint16_t packet_size = 0;
86
87   if ((fd == NULL) || (*fd < 0))
88     return (EINVAL);
89
90   (void)swrite(*fd, (void *)&packet_size, sizeof(packet_size));
91   close(*fd);
92   *fd = -1;
93
94   return (0);
95 } /* int net_shutdown */
96
97 /* Close the network connection */
98 static int apcups_shutdown(void) {
99   if (global_sockfd < 0)
100     return (0);
101
102   net_shutdown(&global_sockfd);
103   return (0);
104 } /* int apcups_shutdown */
105
106 /*
107  * Open a TCP connection to the UPS network server
108  * Returns -1 on error
109  * Returns socket file descriptor otherwise
110  */
111 static int net_open(char const *node, char const *service) {
112   int sd;
113   int status;
114   struct addrinfo *ai_return;
115   struct addrinfo *ai_list;
116
117   /* TODO: Change this to `AF_UNSPEC' if apcupsd can handle IPv6 */
118   struct addrinfo ai_hints = {.ai_family = AF_INET, .ai_socktype = SOCK_STREAM};
119
120   status = getaddrinfo(node, service, &ai_hints, &ai_return);
121   if (status != 0) {
122     char errbuf[1024];
123     INFO("apcups plugin: getaddrinfo failed: %s",
124          (status == EAI_SYSTEM) ? sstrerror(errno, errbuf, sizeof(errbuf))
125                                 : gai_strerror(status));
126     return (-1);
127   }
128
129   /* Create socket */
130   sd = -1;
131   for (ai_list = ai_return; ai_list != NULL; ai_list = ai_list->ai_next) {
132     sd = socket(ai_list->ai_family, ai_list->ai_socktype, ai_list->ai_protocol);
133     if (sd >= 0)
134       break;
135   }
136   /* `ai_list' still holds the current description of the socket.. */
137
138   if (sd < 0) {
139     DEBUG("apcups plugin: Unable to open a socket");
140     freeaddrinfo(ai_return);
141     return (-1);
142   }
143
144   status = connect(sd, ai_list->ai_addr, ai_list->ai_addrlen);
145
146   freeaddrinfo(ai_return);
147
148   if (status != 0) /* `connect(2)' failed */
149   {
150     char errbuf[1024];
151     INFO("apcups plugin: connect failed: %s",
152          sstrerror(errno, errbuf, sizeof(errbuf)));
153     close(sd);
154     return (-1);
155   }
156
157   DEBUG("apcups plugin: Done opening a socket %i", sd);
158
159   return (sd);
160 } /* int net_open */
161
162 /*
163  * Receive a message from the other end. Each message consists of
164  * two packets. The first is a header that contains the size
165  * of the data that follows in the second packet.
166  * Returns number of bytes read
167  * Returns 0 on end of file
168  * Returns -1 on hard end of file (i.e. network connection close)
169  * Returns -2 on error
170  */
171 static int net_recv(int *sockfd, char *buf, int buflen) {
172   uint16_t packet_size;
173
174   /* get data size -- in short */
175   if (sread(*sockfd, (void *)&packet_size, sizeof(packet_size)) != 0) {
176     close(*sockfd);
177     *sockfd = -1;
178     return (-1);
179   }
180
181   packet_size = ntohs(packet_size);
182   if (packet_size > buflen) {
183     ERROR("apcups plugin: Received %" PRIu16 " bytes of payload "
184           "but have only %i bytes of buffer available.",
185           packet_size, buflen);
186     close(*sockfd);
187     *sockfd = -1;
188     return (-2);
189   }
190
191   if (packet_size == 0)
192     return (0);
193
194   /* now read the actual data */
195   if (sread(*sockfd, (void *)buf, packet_size) != 0) {
196     close(*sockfd);
197     *sockfd = -1;
198     return (-1);
199   }
200
201   return ((int)packet_size);
202 } /* static int net_recv (int *sockfd, char *buf, int buflen) */
203
204 /*
205  * Send a message over the network. The send consists of
206  * two network packets. The first is sends a short containing
207  * the length of the data packet which follows.
208  * Returns zero on success
209  * Returns non-zero on error
210  */
211 static int net_send(int *sockfd, const char *buff, int len) {
212   uint16_t packet_size;
213
214   assert(len > 0);
215   assert(*sockfd >= 0);
216
217   /* send short containing size of data packet */
218   packet_size = htons((uint16_t)len);
219
220   if (swrite(*sockfd, (void *)&packet_size, sizeof(packet_size)) != 0) {
221     close(*sockfd);
222     *sockfd = -1;
223     return (-1);
224   }
225
226   /* send data packet */
227   if (swrite(*sockfd, (void *)buff, len) != 0) {
228     close(*sockfd);
229     *sockfd = -1;
230     return (-2);
231   }
232
233   return (0);
234 }
235
236 /* Get and print status from apcupsd NIS server */
237 static int apc_query_server(char const *node, char const *service,
238                             apc_detail_t *apcups_detail) {
239   int n;
240   char recvline[1024];
241   char *tokptr;
242   char *toksaveptr;
243   _Bool retry = 1;
244   int status;
245
246 #if APCMAIN
247 #define PRINT_VALUE(name, val)                                                 \
248   printf("  Found property: name = %s; value = %f;\n", name, val)
249 #else
250 #define PRINT_VALUE(name, val) /**/
251 #endif
252
253   while (retry) {
254     if (global_sockfd < 0) {
255       global_sockfd = net_open(node, service);
256       if (global_sockfd < 0) {
257         ERROR("apcups plugin: Connecting to the "
258               "apcupsd failed.");
259         return (-1);
260       }
261     }
262
263     status = net_send(&global_sockfd, "status", strlen("status"));
264     if (status != 0) {
265       /* net_send is closing the socket on error. */
266       assert(global_sockfd < 0);
267       if (retry) {
268         retry = 0;
269         count_retries++;
270         continue;
271       }
272
273       ERROR("apcups plugin: Writing to the socket failed.");
274       return (-1);
275     }
276
277     break;
278   } /* while (retry) */
279
280   /* When collectd's collection interval is larger than apcupsd's
281    * timeout, we would have to retry / re-connect each iteration. Try to
282    * detect this situation and shut down the socket gracefully in that
283    * case. Otherwise, keep the socket open to avoid overhead. */
284   count_iterations++;
285   if ((count_iterations == 10) && (count_retries > 2)) {
286     NOTICE("apcups plugin: There have been %i retries in the "
287            "first %i iterations. Will close the socket "
288            "in future iterations.",
289            count_retries, count_iterations);
290     conf_persistent_conn = 0;
291   }
292
293   while ((n = net_recv(&global_sockfd, recvline, sizeof(recvline) - 1)) > 0) {
294     assert((size_t)n < sizeof(recvline));
295     recvline[n] = 0;
296 #if APCMAIN
297     printf("net_recv = `%s';\n", recvline);
298 #endif /* if APCMAIN */
299
300     toksaveptr = NULL;
301     tokptr = strtok_r(recvline, " :\t", &toksaveptr);
302     while (tokptr != NULL) {
303       char *key = tokptr;
304       if ((tokptr = strtok_r(NULL, " :\t", &toksaveptr)) == NULL)
305         continue;
306
307       gauge_t value;
308       if (strtogauge(tokptr, &value) != 0)
309         continue;
310
311       PRINT_VALUE(key, value);
312
313       if (strcmp("LINEV", key) == 0)
314         apcups_detail->linev = value;
315       else if (strcmp("BATTV", key) == 0)
316         apcups_detail->battv = value;
317       else if (strcmp("ITEMP", key) == 0)
318         apcups_detail->itemp = value;
319       else if (strcmp("LOADPCT", key) == 0)
320         apcups_detail->loadpct = value;
321       else if (strcmp("BCHARGE", key) == 0)
322         apcups_detail->bcharge = value;
323       else if (strcmp("OUTPUTV", key) == 0)
324         apcups_detail->outputv = value;
325       else if (strcmp("LINEFREQ", key) == 0)
326         apcups_detail->linefreq = value;
327       else if (strcmp("TIMELEFT", key) == 0) {
328         /* Convert minutes to seconds if requested by
329          * the user. */
330         if (conf_report_seconds)
331           value *= 60.0;
332         apcups_detail->timeleft = value;
333       }
334
335       tokptr = strtok_r(NULL, ":", &toksaveptr);
336     } /* while (tokptr != NULL) */
337   }
338   status = errno; /* save errno, net_shutdown() may re-set it. */
339
340   if (!conf_persistent_conn)
341     net_shutdown(&global_sockfd);
342
343   if (n < 0) {
344     char errbuf[1024];
345     ERROR("apcups plugin: Reading from socket failed: %s",
346           sstrerror(status, errbuf, sizeof(errbuf)));
347     return (-1);
348   }
349
350   return (0);
351 }
352
353 static int apcups_config(oconfig_item_t *ci) {
354   _Bool persistent_conn_set = 0;
355
356   for (int i = 0; i < ci->children_num; i++) {
357     oconfig_item_t *child = ci->children + i;
358
359     if (strcasecmp(child->key, "Host") == 0)
360       cf_util_get_string(child, &conf_node);
361     else if (strcasecmp(child->key, "Port") == 0)
362       cf_util_get_service(child, &conf_service);
363     else if (strcasecmp(child->key, "ReportSeconds") == 0)
364       cf_util_get_boolean(child, &conf_report_seconds);
365     else if (strcasecmp(child->key, "PersistentConnection") == 0) {
366       cf_util_get_boolean(child, &conf_persistent_conn);
367       persistent_conn_set = 1;
368     } else
369       ERROR("apcups plugin: Unknown config option \"%s\".", child->key);
370   }
371
372   if (!persistent_conn_set) {
373     double interval = CDTIME_T_TO_DOUBLE(plugin_get_interval());
374     if (interval > APCUPS_SERVER_TIMEOUT) {
375       NOTICE("apcups plugin: Plugin poll interval set to %.3f seconds. "
376              "Apcupsd NIS socket timeout is %.3f seconds, "
377              "PersistentConnection disabled by default.",
378              interval, APCUPS_SERVER_TIMEOUT);
379       conf_persistent_conn = 0;
380     }
381   }
382
383   return (0);
384 } /* int apcups_config */
385
386 static void apc_submit_generic(const char *type, const char *type_inst,
387                                gauge_t value) {
388   if (isnan(value))
389     return;
390
391   value_list_t vl = VALUE_LIST_INIT;
392   vl.values = &(value_t){.gauge = value};
393   vl.values_len = 1;
394   sstrncpy(vl.plugin, "apcups", sizeof(vl.plugin));
395   sstrncpy(vl.type, type, sizeof(vl.type));
396   sstrncpy(vl.type_instance, type_inst, sizeof(vl.type_instance));
397
398   plugin_dispatch_values(&vl);
399 }
400
401 static void apc_submit(apc_detail_t const *apcups_detail) {
402   apc_submit_generic("voltage", "input", apcups_detail->linev);
403   apc_submit_generic("voltage", "output", apcups_detail->outputv);
404   apc_submit_generic("voltage", "battery", apcups_detail->battv);
405   apc_submit_generic("charge", "", apcups_detail->bcharge);
406   apc_submit_generic("percent", "load", apcups_detail->loadpct);
407   apc_submit_generic("timeleft", "", apcups_detail->timeleft);
408   apc_submit_generic("temperature", "", apcups_detail->itemp);
409   apc_submit_generic("frequency", "input", apcups_detail->linefreq);
410 }
411
412 static int apcups_read(void) {
413   apc_detail_t apcups_detail = {
414       .linev = NAN,
415       .outputv = NAN,
416       .battv = NAN,
417       .loadpct = NAN,
418       .bcharge = NAN,
419       .timeleft = NAN,
420       .itemp = NAN,
421       .linefreq = NAN,
422   };
423
424   int status =
425       apc_query_server(conf_node == NULL ? APCUPS_DEFAULT_NODE : conf_node,
426                        conf_service, &apcups_detail);
427   if (status != 0) {
428     DEBUG("apcups plugin: apc_query_server (\"%s\", \"%s\") = %d",
429           conf_node == NULL ? APCUPS_DEFAULT_NODE : conf_node, conf_service,
430           status);
431     return (status);
432   }
433
434   apc_submit(&apcups_detail);
435
436   return (0);
437 } /* apcups_read */
438
439 void module_register(void) {
440   plugin_register_complex_config("apcups", apcups_config);
441   plugin_register_read("apcups", apcups_read);
442   plugin_register_shutdown("apcups", apcups_shutdown);
443 } /* void module_register */