src/onewire.c

   1 /**
   2  * collectd - src/owfs.c
   3  * Copyright (C) 2008  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <octo at noris.net>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "common.h"
  24 #include "plugin.h"
  25 #include "utils_ignorelist.h"
  26
  27 #include <owcapi.h>
  28
  29 #define OW_FAMILY_LENGTH 8
  30 #define OW_FAMILY_MAX_FEATURES 2
  31 struct ow_family_features_s
  32 {
  33   char family[OW_FAMILY_LENGTH];
  34   struct
  35   {
  36     char filename[DATA_MAX_NAME_LEN];
  37     char type[DATA_MAX_NAME_LEN];
  38     char type_instance[DATA_MAX_NAME_LEN];
  39   } features[OW_FAMILY_MAX_FEATURES];
  40   size_t features_num;
  41 };
  42 typedef struct ow_family_features_s ow_family_features_t;
  43
  44 /* see http://owfs.sourceforge.net/ow_table.html for a list of families */
  45 static ow_family_features_t ow_family_features[] =
  46 {
  47   {
  48     /* family = */ "10.",
  49     {
  50       {
  51         /* filename = */ "temperature",
  52         /* type = */ "temperature",
  53         /* type_instance = */ ""
  54       }
  55     },
  56     /* features_num = */ 1
  57   }
  58 };
  59 static int ow_family_features_num = STATIC_ARRAY_SIZE (ow_family_features);
  60
  61 static char *device_g = NULL;
  62 static cdtime_t ow_interval = 0;
  63
  64 static const char *config_keys[] =
  65 {
  66   "Device",
  67   "IgnoreSelected",
  68   "Sensor",
  69   "Interval"
  70 };
  71 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  72
  73 static ignorelist_t *sensor_list;
  74
  75 static int cow_load_config (const char *key, const char *value)
  76 {
  77   if (sensor_list == NULL)
  78     sensor_list = ignorelist_create (1);
  79
  80   if (strcasecmp (key, "Sensor") == 0)
  81   {
  82     if (ignorelist_add (sensor_list, value))
  83     {
  84       ERROR ("sensors plugin: "
  85           "Cannot add value to ignorelist.");
  86       return (1);
  87     }
  88   }
  89   else if (strcasecmp (key, "IgnoreSelected") == 0)
  90   {
  91     ignorelist_set_invert (sensor_list, 1);
  92     if (IS_TRUE (value))
  93       ignorelist_set_invert (sensor_list, 0);
  94   }
  95   else if (strcasecmp (key, "Device") == 0)
  96   {
  97     char *temp;
  98     temp = strdup (value);
  99     if (temp == NULL)
 100     {
 101       ERROR ("onewire plugin: strdup failed.");
 102       return (1);
 103     }
 104     sfree (device_g);
 105     device_g = temp;
 106   }
 107   else if (strcasecmp ("Interval", key) == 0)
 108   {
 109     double tmp;
 110     tmp = atof (value);
 111     if (tmp > 0.0)
 112       ow_interval = DOUBLE_TO_CDTIME_T (tmp);
 113     else
 114       ERROR ("onewire plugin: Invalid `Interval' setting: %s", value);
 115   }
 116   else
 117   {
 118     return (-1);
 119   }
 120
 121   return (0);
 122 }
 123
 124 static int cow_read_values (const char *path, const char *name,
 125     const ow_family_features_t *family_info)
 126 {
 127   value_t values[1];
 128   value_list_t vl = VALUE_LIST_INIT;
 129   int success = 0;
 130   size_t i;
 131
 132   if (sensor_list != NULL)
 133   {
 134     DEBUG ("onewire plugin: Checking ignorelist for `%s'", name);
 135     if (ignorelist_match (sensor_list, name) != 0)
 136       return 0;
 137   }
 138
 139   vl.values = values;
 140   vl.values_len = 1;
 141
 142   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 143   sstrncpy (vl.plugin, "onewire", sizeof (vl.plugin));
 144   sstrncpy (vl.plugin_instance, name, sizeof (vl.plugin_instance));
 145
 146   for (i = 0; i < family_info->features_num; i++)
 147   {
 148     char *buffer;
 149     size_t buffer_size;
 150     int status;
 151
 152     char file[4096];
 153     char *endptr;
 154
 155     snprintf (file, sizeof (file), "%s/%s",
 156         path, family_info->features[i].filename);
 157     file[sizeof (file) - 1] = 0;
 158
 159     buffer = NULL;
 160     buffer_size = 0;
 161     status = OW_get (file, &buffer, &buffer_size);
 162     if (status < 0)
 163     {
 164       ERROR ("onewire plugin: OW_get (%s/%s) failed. status = %#x;",
 165           path, family_info->features[i].filename, status);
 166       return (-1);
 167     }
 168
 169     endptr = NULL;
 170     values[0].gauge = strtod (buffer, &endptr);
 171     if (endptr == NULL)
 172     {
 173       ERROR ("onewire plugin: Buffer is not a number: %s", buffer);
 174       status = -1;
 175       continue;
 176     }
 177
 178     sstrncpy (vl.type, family_info->features[i].type, sizeof (vl.type));
 179     sstrncpy (vl.type_instance, family_info->features[i].type_instance,
 180         sizeof (vl.type_instance));
 181
 182     plugin_dispatch_values (&vl);
 183     success++;
 184
 185     free (buffer);
 186   } /* for (i = 0; i < features_num; i++) */
 187
 188   return ((success > 0) ? 0 : -1);
 189 } /* int cow_read_values */
 190
 191 /* Forward declaration so the recursion below works */
 192 static int cow_read_bus (const char *path);
 193
 194 /*
 195  * cow_read_ds2409
 196  *
 197  * Handles:
 198  * - DS2409 - MicroLAN Coupler
 199  */
 200 static int cow_read_ds2409 (const char *path)
 201 {
 202   char subpath[4096];
 203   int status;
 204
 205   status = ssnprintf (subpath, sizeof (subpath), "%s/main", path);
 206   if ((status > 0) && (status < sizeof (subpath)))
 207     cow_read_bus (subpath);
 208
 209   status = ssnprintf (subpath, sizeof (subpath), "%s/aux", path);
 210   if ((status > 0) && (status < sizeof (subpath)))
 211     cow_read_bus (subpath);
 212
 213   return (0);
 214 } /* int cow_read_ds2409 */
 215
 216 static int cow_read_bus (const char *path)
 217 {
 218   char *buffer;
 219   size_t buffer_size;
 220   int status;
 221
 222   char *buffer_ptr;
 223   char *dummy;
 224   char *saveptr;
 225   char subpath[4096];
 226
 227   status = OW_get (path, &buffer, &buffer_size);
 228   if (status < 0)
 229   {
 230     ERROR ("onewire plugin: OW_get (%s) failed. status = %#x;",
 231         path, status);
 232     return (-1);
 233   }
 234   DEBUG ("onewire plugin: OW_get (%s) returned: %s",
 235       path, buffer);
 236
 237   dummy = buffer;
 238   saveptr = NULL;
 239   while ((buffer_ptr = strtok_r (dummy, ",/", &saveptr)) != NULL)
 240   {
 241     int i;
 242
 243     dummy = NULL;
 244
 245     if (strcmp ("/", path) == 0)
 246       status = ssnprintf (subpath, sizeof (subpath), "/%s", buffer_ptr);
 247     else
 248       status = ssnprintf (subpath, sizeof (subpath), "%s/%s",
 249           path, buffer_ptr);
 250     if ((status <= 0) || (status >= sizeof (subpath)))
 251       continue;
 252
 253     for (i = 0; i < ow_family_features_num; i++)
 254     {
 255       if (strncmp (ow_family_features[i].family, buffer_ptr,
 256             strlen (ow_family_features[i].family)) != 0)
 257         continue;
 258
 259       cow_read_values (subpath,
 260           buffer_ptr + strlen (ow_family_features[i].family),
 261           ow_family_features + i);
 262       break;
 263     }
 264     if (i < ow_family_features_num)
 265       continue;
 266
 267     /* DS2409 */
 268     if (strncmp ("1F.", buffer_ptr, strlen ("1F.")) == 0)
 269     {
 270       cow_read_ds2409 (subpath);
 271       continue;
 272     }
 273   } /* while (strtok_r) */
 274
 275   free (buffer);
 276   return (0);
 277 } /* int cow_read_bus */
 278
 279 static int cow_read (user_data_t *ud __attribute__((unused)))
 280 {
 281   return (cow_read_bus ("/"));
 282 } /* int cow_read */
 283
 284 static int cow_shutdown (void)
 285 {
 286   OW_finish ();
 287   ignorelist_free (sensor_list);
 288   return (0);
 289 } /* int cow_shutdown */
 290
 291 static int cow_init (void)
 292 {
 293   int status;
 294   struct timespec cb_interval;
 295
 296   if (device_g == NULL)
 297   {
 298     ERROR ("onewire plugin: cow_init: No device configured.");
 299     return (-1);
 300   }
 301
 302   status = (int) OW_init (device_g);
 303   if (status != 0)
 304   {
 305     ERROR ("onewire plugin: OW_init(%s) failed: %i.", device_g, status);
 306     return (1);
 307   }
 308
 309   CDTIME_T_TO_TIMESPEC (ow_interval, &cb_interval);
 310
 311   plugin_register_complex_read (/* group = */ NULL, "onewire", cow_read,
 312       (ow_interval != 0) ? &cb_interval : NULL,
 313       /* user data = */ NULL);
 314   plugin_register_shutdown ("onewire", cow_shutdown);
 315
 316   return (0);
 317 } /* int cow_init */
 318
 319 void module_register (void)
 320 {
 321   plugin_register_init ("onewire", cow_init);
 322   plugin_register_config ("onewire", cow_load_config,
 323     config_keys, config_keys_num);
 324 }
 325
 326 /* vim: set sw=2 sts=2 ts=8 et fdm=marker cindent : */