Bump version to 5.6.1; Update ChangeLog.
[collectd.git] / src / gps.c
1 /**
2  * collectd - src/gps.c
3  * Copyright (C) 2015  Nicolas JOURDEN
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Nicolas JOURDEN <nicolas.jourden at laposte.net>
25  *   Florian octo Forster <octo at collectd.org>
26  *   Marc Fournier <marc.fournier at camptocamp.com>
27  **/
28
29 #include "common.h"
30 #include "plugin.h"
31 #include "utils_time.h"
32 #include "collectd.h"
33
34 #define CGPS_TRUE 1
35 #define CGPS_FALSE 0
36 #define CGPS_DEFAULT_HOST "localhost"
37 #define CGPS_DEFAULT_PORT "2947" /* DEFAULT_GPSD_PORT */
38 #define CGPS_DEFAULT_TIMEOUT MS_TO_CDTIME_T(15)
39 #define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T(5)
40 #define CGPS_MAX_ERROR 100
41 #define CGPS_CONFIG "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
42
43 #include <gps.h>
44 #include <pthread.h>
45
46 typedef struct {
47   char *host;
48   char *port;
49   cdtime_t timeout;
50   cdtime_t pause_connect;
51 } cgps_config_t;
52
53 typedef struct {
54   gauge_t sats_used;
55   gauge_t sats_visible;
56   gauge_t hdop;
57   gauge_t vdop;
58 } cgps_data_t;
59
60 static cgps_config_t cgps_config_data;
61
62 static cgps_data_t cgps_data = {NAN, NAN, NAN, NAN};
63
64 static pthread_t cgps_thread_id;
65 static pthread_mutex_t cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
66 static pthread_mutex_t cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
67 static int cgps_thread_shutdown = CGPS_FALSE;
68 static int cgps_thread_running = CGPS_FALSE;
69
70 /**
71  * Non blocking pause for the thread.
72  */
73 static int cgps_thread_pause(cdtime_t pTime) {
74   cdtime_t now;
75   now = cdtime();
76   struct timespec pause_th;
77   CDTIME_T_TO_TIMESPEC(MS_TO_CDTIME_T(10), &pause_th);
78   while (CGPS_TRUE) {
79     if ((cdtime() - now) > pTime) {
80       break;
81     }
82
83     pthread_mutex_lock(&cgps_thread_lock);
84     if (cgps_thread_shutdown == CGPS_TRUE) {
85       return CGPS_FALSE;
86     }
87     pthread_mutex_unlock(&cgps_thread_lock);
88     nanosleep(&pause_th, NULL);
89   }
90
91   return CGPS_TRUE;
92 }
93
94 /**
95  * Thread reading from gpsd.
96  */
97 static void *cgps_thread(void *pData) {
98   struct gps_data_t gpsd_conn;
99   unsigned int err_count;
100   cgps_thread_running = CGPS_TRUE;
101
102   while (CGPS_TRUE) {
103     pthread_mutex_lock(&cgps_thread_lock);
104     if (cgps_thread_shutdown == CGPS_TRUE) {
105       goto quit;
106     }
107     pthread_mutex_unlock(&cgps_thread_lock);
108
109     err_count = 0;
110
111 #if GPSD_API_MAJOR_VERSION > 4
112     int status =
113         gps_open(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
114 #else
115     int status =
116         gps_open_r(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
117 #endif
118     if (status < 0) {
119       WARNING("gps plugin: connecting to %s:%s failed: %s",
120               cgps_config_data.host, cgps_config_data.port, gps_errstr(status));
121
122       // Here we make a pause until a new tentative to connect, we check also if
123       // the thread does not need to stop.
124       if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE) {
125         goto quit;
126       }
127
128       continue;
129     }
130
131     gps_stream(&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
132     gps_send(&gpsd_conn, CGPS_CONFIG);
133
134     while (CGPS_TRUE) {
135       pthread_mutex_lock(&cgps_thread_lock);
136       if (cgps_thread_shutdown == CGPS_TRUE) {
137         goto stop;
138       }
139       pthread_mutex_unlock(&cgps_thread_lock);
140
141 #if GPSD_API_MAJOR_VERSION > 4
142       long timeout_us = CDTIME_T_TO_US(cgps_config_data.timeout);
143       if (!gps_waiting(&gpsd_conn, (int)timeout_us))
144 #else
145       if (!gps_waiting(&gpsd_conn))
146 #endif
147       {
148         continue;
149       }
150
151       if (gps_read(&gpsd_conn) == -1) {
152         WARNING("gps plugin: incorrect data! (err_count: %d)", err_count);
153         err_count++;
154
155         if (err_count > CGPS_MAX_ERROR) {
156           // Server is not responding ...
157           if (gps_send(&gpsd_conn, CGPS_CONFIG) == -1) {
158             WARNING("gps plugin: gpsd seems to be down, reconnecting");
159             gps_close(&gpsd_conn);
160             break;
161           }
162           // Server is responding ...
163           else {
164             err_count = 0;
165           }
166         }
167
168         continue;
169       }
170
171       pthread_mutex_lock(&cgps_data_lock);
172
173       // Number of sats in view:
174       cgps_data.sats_used = (gauge_t)gpsd_conn.satellites_used;
175       cgps_data.sats_visible = (gauge_t)gpsd_conn.satellites_visible;
176
177       // dilution of precision:
178       cgps_data.vdop = NAN;
179       cgps_data.hdop = NAN;
180       if (cgps_data.sats_used > 0) {
181         cgps_data.hdop = gpsd_conn.dop.hdop;
182         cgps_data.vdop = gpsd_conn.dop.vdop;
183       }
184
185       DEBUG("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = "
186             "%.3f",
187             cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop,
188             cgps_data.vdop);
189
190       pthread_mutex_unlock(&cgps_data_lock);
191     }
192   }
193
194 stop:
195   DEBUG("gps plugin: thread closing gpsd connection ... ");
196   gps_stream(&gpsd_conn, WATCH_DISABLE, NULL);
197   gps_close(&gpsd_conn);
198 quit:
199   DEBUG("gps plugin: thread shutting down ... ");
200   cgps_thread_running = CGPS_FALSE;
201   pthread_mutex_unlock(&cgps_thread_lock);
202   pthread_exit(NULL);
203 }
204
205 /**
206  * Submit a piece of the data.
207  */
208 static void cgps_submit(const char *type, gauge_t value,
209                         const char *type_instance) {
210   value_t values[1];
211   value_list_t vl = VALUE_LIST_INIT;
212
213   values[0].gauge = value;
214
215   vl.values = values;
216   vl.values_len = 1;
217   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
218   sstrncpy(vl.plugin, "gps", sizeof(vl.plugin));
219   sstrncpy(vl.type, type, sizeof(vl.type));
220   sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
221
222   plugin_dispatch_values(&vl);
223 }
224
225 /**
226  * Read the data and submit by piece.
227  */
228 static int cgps_read(void) {
229   cgps_data_t data_copy;
230
231   pthread_mutex_lock(&cgps_data_lock);
232   data_copy = cgps_data;
233   pthread_mutex_unlock(&cgps_data_lock);
234
235   cgps_submit("dilution_of_precision", data_copy.hdop, "horizontal");
236   cgps_submit("dilution_of_precision", data_copy.vdop, "vertical");
237   cgps_submit("satellites", data_copy.sats_used, "used");
238   cgps_submit("satellites", data_copy.sats_visible, "visible");
239
240   return (0);
241 }
242
243 /**
244  * Read configuration.
245  */
246 static int cgps_config(oconfig_item_t *ci) {
247   int i;
248
249   for (i = 0; i < ci->children_num; i++) {
250     oconfig_item_t *child = ci->children + i;
251
252     if (strcasecmp("Host", child->key) == 0)
253       cf_util_get_string(child, &cgps_config_data.host);
254     else if (strcasecmp("Port", child->key) == 0)
255       cf_util_get_service(child, &cgps_config_data.port);
256     else if (strcasecmp("Timeout", child->key) == 0)
257       cf_util_get_cdtime(child, &cgps_config_data.timeout);
258     else if (strcasecmp("PauseConnect", child->key) == 0)
259       cf_util_get_cdtime(child, &cgps_config_data.pause_connect);
260     else
261       WARNING("gps plugin: Ignoring unknown config option \"%s\".", child->key);
262   }
263
264   // Controlling the value for timeout:
265   // If set too high it blocks the reading (> 5 s), too low it gets not reading
266   // (< 500 us).
267   // To avoid any issues we replace "out of range" value by the default value.
268   if (cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5) ||
269       cgps_config_data.timeout < US_TO_CDTIME_T(500)) {
270     WARNING("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
271             CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
272             CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT));
273     cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
274   }
275
276   return (0);
277 }
278
279 /**
280  * Init.
281  */
282 static int cgps_init(void) {
283   int status;
284
285   if (cgps_thread_running == CGPS_TRUE) {
286     DEBUG("gps plugin: error gps thread already running ... ");
287     return 0;
288   }
289
290   DEBUG("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., "
291         "pause connect: %.3f sec.}",
292         cgps_config_data.host, cgps_config_data.port,
293         CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
294         CDTIME_T_TO_DOUBLE(cgps_config_data.pause_connect));
295
296   status = plugin_thread_create(&cgps_thread_id, NULL, cgps_thread, NULL);
297   if (status != 0) {
298     ERROR("gps plugin: pthread_create() failed.");
299     return (-1);
300   }
301
302   return (0);
303 }
304
305 /**
306  * Shutdown.
307  */
308 static int cgps_shutdown(void) {
309   void *res;
310
311   pthread_mutex_lock(&cgps_thread_lock);
312   cgps_thread_shutdown = CGPS_TRUE;
313   pthread_mutex_unlock(&cgps_thread_lock);
314
315   pthread_join(cgps_thread_id, &res);
316   free(res);
317
318   // Clean mutex:
319   pthread_mutex_unlock(&cgps_thread_lock);
320   pthread_mutex_destroy(&cgps_thread_lock);
321   pthread_mutex_unlock(&cgps_data_lock);
322   pthread_mutex_destroy(&cgps_data_lock);
323
324   sfree(cgps_config_data.port);
325   sfree(cgps_config_data.host);
326
327   return (0);
328 }
329
330 /**
331  * Register the module.
332  */
333 void module_register(void) {
334   cgps_config_data.host = sstrdup(CGPS_DEFAULT_HOST);
335   cgps_config_data.port = sstrdup(CGPS_DEFAULT_PORT);
336   cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
337   cgps_config_data.pause_connect = CGPS_DEFAULT_PAUSE_CONNECT;
338
339   plugin_register_complex_config("gps", cgps_config);
340   plugin_register_init("gps", cgps_init);
341   plugin_register_read("gps", cgps_read);
342   plugin_register_shutdown("gps", cgps_shutdown);
343 }