src/modbus.c

   1 /**
   2  * collectd - src/modbus.c
   3  * Copyright (C) 2010,2011  noris network AG
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU Lesser General Public License as published by
   7  * the Free Software Foundation; only version 2.1 of the License is
   8  * applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors:
  20  *   Florian Forster <octo at noris.net>
  21  **/
  22
  23 #include "collectd.h"
  24
  25 #include "common.h"
  26 #include "configfile.h"
  27 #include "plugin.h"
  28
  29 #include <modbus.h>
  30 #include <netdb.h>
  31 #include <sys/socket.h>
  32
  33 #ifndef LIBMODBUS_VERSION_CHECK
  34 /* Assume version 2.0.3 */
  35 #define LEGACY_LIBMODBUS 1
  36 #else
  37 /* Assume version 2.9.2 */
  38 #endif
  39
  40 #ifndef MODBUS_TCP_DEFAULT_PORT
  41 #ifdef MODBUS_TCP_PORT
  42 #define MODBUS_TCP_DEFAULT_PORT MODBUS_TCP_PORT
  43 #else
  44 #define MODBUS_TCP_DEFAULT_PORT 502
  45 #endif
  46 #endif
  47
  48 /*
  49  * <Data "data_name">
  50  *   RegisterBase 1234
  51  *   RegisterCmd ReadHolding
  52  *   RegisterType float
  53  *   Type gauge
  54  *   Instance "..."
  55  * </Data>
  56  *
  57  * <Host "name">
  58  *   Address "addr"
  59  *   Port "1234"
  60  *   # Or:
  61  *   # Device "/dev/ttyUSB0"
  62  *   # Baudrate 38400
  63  *   # (Assumes 8N1)
  64  *   Interval 60
  65  *
  66  *   <Slave 1>
  67  *     Instance "foobar" # optional
  68  *     Collect "data_name"
  69  *   </Slave>
  70  * </Host>
  71  */
  72
  73 /*
  74  * Data structures
  75  */
  76 enum mb_register_type_e /* {{{ */
  77 { REG_TYPE_INT16,
  78   REG_TYPE_INT32,
  79   REG_TYPE_INT32_CDAB,
  80   REG_TYPE_UINT16,
  81   REG_TYPE_UINT32,
  82   REG_TYPE_UINT32_CDAB,
  83   REG_TYPE_FLOAT,
  84   REG_TYPE_FLOAT_CDAB }; /* }}} */
  85
  86 enum mb_mreg_type_e /* {{{ */
  87 { MREG_HOLDING,
  88   MREG_INPUT }; /* }}} */
  89 typedef enum mb_register_type_e mb_register_type_t;
  90 typedef enum mb_mreg_type_e mb_mreg_type_t;
  91
  92 /* TCP or RTU depending on what is specified in host config block */
  93 enum mb_conntype_e /* {{{ */
  94 { MBCONN_TCP,
  95   MBCONN_RTU }; /* }}} */
  96 typedef enum mb_conntype_e mb_conntype_t;
  97
  98 struct mb_data_s;
  99 typedef struct mb_data_s mb_data_t;
 100 struct mb_data_s /* {{{ */
 101 {
 102   char *name;
 103   int register_base;
 104   mb_register_type_t register_type;
 105   mb_mreg_type_t modbus_register_type;
 106   char type[DATA_MAX_NAME_LEN];
 107   char instance[DATA_MAX_NAME_LEN];
 108   double scale;
 109   double shift;
 110
 111   mb_data_t *next;
 112 }; /* }}} */
 113
 114 struct mb_slave_s /* {{{ */
 115 {
 116   int id;
 117   char instance[DATA_MAX_NAME_LEN];
 118   mb_data_t *collect;
 119 }; /* }}} */
 120 typedef struct mb_slave_s mb_slave_t;
 121
 122 struct mb_host_s /* {{{ */
 123 {
 124   char host[DATA_MAX_NAME_LEN];
 125   char node[NI_MAXHOST]; /* TCP hostname or RTU serial device */
 126   /* char service[NI_MAXSERV]; */
 127   int port;     /* for Modbus/TCP */
 128   int baudrate; /* for Modbus/RTU */
 129   mb_conntype_t conntype;
 130   cdtime_t interval;
 131
 132   mb_slave_t *slaves;
 133   size_t slaves_num;
 134
 135 #if LEGACY_LIBMODBUS
 136   modbus_param_t connection;
 137 #else
 138   modbus_t *connection;
 139 #endif
 140   _Bool is_connected;
 141 }; /* }}} */
 142 typedef struct mb_host_s mb_host_t;
 143
 144 struct mb_data_group_s;
 145 typedef struct mb_data_group_s mb_data_group_t;
 146 struct mb_data_group_s /* {{{ */
 147 {
 148   mb_data_t *registers;
 149   size_t registers_num;
 150
 151   mb_data_group_t *next;
 152 }; /* }}} */
 153
 154 /*
 155  * Global variables
 156  */
 157 static mb_data_t *data_definitions = NULL;
 158
 159 /*
 160  * Functions
 161  */
 162 static mb_data_t *data_get_by_name(mb_data_t *src, /* {{{ */
 163                                    const char *name) {
 164   if (name == NULL)
 165     return NULL;
 166
 167   for (mb_data_t *ptr = src; ptr != NULL; ptr = ptr->next)
 168     if (strcasecmp(ptr->name, name) == 0)
 169       return ptr;
 170
 171   return NULL;
 172 } /* }}} mb_data_t *data_get_by_name */
 173
 174 static int data_append(mb_data_t **dst, mb_data_t *src) /* {{{ */
 175 {
 176   mb_data_t *ptr;
 177
 178   if ((dst == NULL) || (src == NULL))
 179     return EINVAL;
 180
 181   ptr = *dst;
 182
 183   if (ptr == NULL) {
 184     *dst = src;
 185     return 0;
 186   }
 187
 188   while (ptr->next != NULL)
 189     ptr = ptr->next;
 190
 191   ptr->next = src;
 192
 193   return 0;
 194 } /* }}} int data_append */
 195
 196 /* Copy a single mb_data_t and append it to another list. */
 197 static int data_copy(mb_data_t **dst, const mb_data_t *src) /* {{{ */
 198 {
 199   mb_data_t *tmp;
 200   int status;
 201
 202   if ((dst == NULL) || (src == NULL))
 203     return EINVAL;
 204
 205   tmp = malloc(sizeof(*tmp));
 206   if (tmp == NULL)
 207     return ENOMEM;
 208   memcpy(tmp, src, sizeof(*tmp));
 209   tmp->name = NULL;
 210   tmp->next = NULL;
 211
 212   tmp->name = strdup(src->name);
 213   if (tmp->name == NULL) {
 214     sfree(tmp);
 215     return ENOMEM;
 216   }
 217
 218   status = data_append(dst, tmp);
 219   if (status != 0) {
 220     sfree(tmp->name);
 221     sfree(tmp);
 222     return status;
 223   }
 224
 225   return 0;
 226 } /* }}} int data_copy */
 227
 228 /* Lookup a single mb_data_t instance, copy it and append the copy to another
 229  * list. */
 230 static int data_copy_by_name(mb_data_t **dst, mb_data_t *src, /* {{{ */
 231                              const char *name) {
 232   mb_data_t *ptr;
 233
 234   if ((dst == NULL) || (src == NULL) || (name == NULL))
 235     return EINVAL;
 236
 237   ptr = data_get_by_name(src, name);
 238   if (ptr == NULL)
 239     return ENOENT;
 240
 241   return data_copy(dst, ptr);
 242 } /* }}} int data_copy_by_name */
 243
 244 /* Read functions */
 245
 246 static int mb_submit(mb_host_t *host, mb_slave_t *slave, /* {{{ */
 247                      mb_data_t *data, value_t value) {
 248   value_list_t vl = VALUE_LIST_INIT;
 249
 250   if ((host == NULL) || (slave == NULL) || (data == NULL))
 251     return EINVAL;
 252
 253   if (host->interval == 0)
 254     host->interval = plugin_get_interval();
 255
 256   if (slave->instance[0] == 0)
 257     snprintf(slave->instance, sizeof(slave->instance), "slave_%i", slave->id);
 258
 259   vl.values = &value;
 260   vl.values_len = 1;
 261   vl.interval = host->interval;
 262   sstrncpy(vl.host, host->host, sizeof(vl.host));
 263   sstrncpy(vl.plugin, "modbus", sizeof(vl.plugin));
 264   sstrncpy(vl.plugin_instance, slave->instance, sizeof(vl.plugin_instance));
 265   sstrncpy(vl.type, data->type, sizeof(vl.type));
 266   sstrncpy(vl.type_instance, data->instance, sizeof(vl.type_instance));
 267
 268   return plugin_dispatch_values(&vl);
 269 } /* }}} int mb_submit */
 270
 271 static float mb_register_to_float(uint16_t hi, uint16_t lo) /* {{{ */
 272 {
 273   union {
 274     uint8_t b[4];
 275     uint16_t s[2];
 276     float f;
 277   } conv;
 278
 279 #if BYTE_ORDER == LITTLE_ENDIAN
 280   /* little endian */
 281   conv.b[0] = lo & 0x00ff;
 282   conv.b[1] = (lo >> 8) & 0x00ff;
 283   conv.b[2] = hi & 0x00ff;
 284   conv.b[3] = (hi >> 8) & 0x00ff;
 285 #else
 286   conv.b[3] = lo & 0x00ff;
 287   conv.b[2] = (lo >> 8) & 0x00ff;
 288   conv.b[1] = hi & 0x00ff;
 289   conv.b[0] = (hi >> 8) & 0x00ff;
 290 #endif
 291
 292   return conv.f;
 293 } /* }}} float mb_register_to_float */
 294
 295 #if LEGACY_LIBMODBUS
 296 /* Version 2.0.3 */
 297 static int mb_init_connection(mb_host_t *host) /* {{{ */
 298 {
 299   int status;
 300
 301   if (host == NULL)
 302     return EINVAL;
 303
 304 #if COLLECT_DEBUG
 305   modbus_set_debug(&host->connection, 1);
 306 #endif
 307
 308   /* We'll do the error handling ourselves. */
 309   modbus_set_error_handling(&host->connection, NOP_ON_ERROR);
 310
 311   if (host->conntype == MBCONN_TCP) {
 312     if ((host->port < 1) || (host->port > 65535))
 313       host->port = MODBUS_TCP_DEFAULT_PORT;
 314
 315     DEBUG("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node,
 316           host->port);
 317
 318     modbus_init_tcp(&host->connection,
 319                     /* host = */ host->node,
 320                     /* port = */ host->port);
 321   } else /* MBCONN_RTU */
 322   {
 323     DEBUG("Modbus plugin: Trying to connect to \"%s\".", host->node);
 324
 325     modbus_init_rtu(&host->connection,
 326                     /* device = */ host->node,
 327                     /* baudrate = */ host->baudrate, 'N', 8, 1, 0);
 328   }
 329
 330   status = modbus_connect(&host->connection);
 331   if (status != 0) {
 332     ERROR("Modbus plugin: modbus_connect (%s, %i) failed with status %i.",
 333           host->node, host->port ? host->port : host->baudrate, status);
 334     return status;
 335   }
 336
 337   host->is_connected = 1;
 338   return 0;
 339 } /* }}} int mb_init_connection */
 340 /* #endif LEGACY_LIBMODBUS */
 341
 342 #else /* if !LEGACY_LIBMODBUS */
 343 /* Version 2.9.2 */
 344 static int mb_init_connection(mb_host_t *host) /* {{{ */
 345 {
 346   int status;
 347
 348   if (host == NULL)
 349     return EINVAL;
 350
 351   if (host->connection != NULL)
 352     return 0;
 353
 354   if (host->conntype == MBCONN_TCP) {
 355     if ((host->port < 1) || (host->port > 65535))
 356       host->port = MODBUS_TCP_DEFAULT_PORT;
 357
 358     DEBUG("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node,
 359           host->port);
 360
 361     host->connection = modbus_new_tcp(host->node, host->port);
 362     if (host->connection == NULL) {
 363       ERROR("Modbus plugin: Creating new Modbus/TCP object failed.");
 364       return -1;
 365     }
 366   } else {
 367     DEBUG("Modbus plugin: Trying to connect to \"%s\", baudrate %i.",
 368           host->node, host->baudrate);
 369
 370     host->connection = modbus_new_rtu(host->node, host->baudrate, 'N', 8, 1);
 371     if (host->connection == NULL) {
 372       ERROR("Modbus plugin: Creating new Modbus/RTU object failed.");
 373       return -1;
 374     }
 375   }
 376
 377 #if COLLECT_DEBUG
 378   modbus_set_debug(host->connection, 1);
 379 #endif
 380
 381   /* We'll do the error handling ourselves. */
 382   modbus_set_error_recovery(host->connection, 0);
 383
 384   status = modbus_connect(host->connection);
 385   if (status != 0) {
 386     ERROR("Modbus plugin: modbus_connect (%s, %i) failed with status %i.",
 387           host->node, host->port ? host->port : host->baudrate, status);
 388     modbus_free(host->connection);
 389     host->connection = NULL;
 390     return status;
 391   }
 392
 393   return 0;
 394 } /* }}} int mb_init_connection */
 395 #endif /* !LEGACY_LIBMODBUS */
 396
 397 #define CAST_TO_VALUE_T(ds, vt, raw, scale, shift)                             \
 398   do {                                                                         \
 399     if ((ds)->ds[0].type == DS_TYPE_COUNTER)                                   \
 400       (vt).counter = (((counter_t)(raw)*scale) + shift);                       \
 401     else if ((ds)->ds[0].type == DS_TYPE_GAUGE)                                \
 402       (vt).gauge = (((gauge_t)(raw)*scale) + shift);                           \
 403     else if ((ds)->ds[0].type == DS_TYPE_DERIVE)                               \
 404       (vt).derive = (((derive_t)(raw)*scale) + shift);                         \
 405     else /* if (ds->ds[0].type == DS_TYPE_ABSOLUTE) */                         \
 406       (vt).absolute = (((absolute_t)(raw)*scale) + shift);                     \
 407   } while (0)
 408
 409 static int mb_read_data(mb_host_t *host, mb_slave_t *slave, /* {{{ */
 410                         mb_data_t *data) {
 411   uint16_t values[2] = {0};
 412   int values_num;
 413   const data_set_t *ds;
 414   int status = 0;
 415
 416   if ((host == NULL) || (slave == NULL) || (data == NULL))
 417     return EINVAL;
 418
 419   ds = plugin_get_ds(data->type);
 420   if (ds == NULL) {
 421     ERROR("Modbus plugin: Type \"%s\" is not defined.", data->type);
 422     return -1;
 423   }
 424
 425   if (ds->ds_num != 1) {
 426     ERROR("Modbus plugin: The type \"%s\" has %" PRIsz " data sources. "
 427           "I can only handle data sets with only one data source.",
 428           data->type, ds->ds_num);
 429     return -1;
 430   }
 431
 432   if ((ds->ds[0].type != DS_TYPE_GAUGE) &&
 433       (data->register_type != REG_TYPE_INT32) &&
 434       (data->register_type != REG_TYPE_INT32_CDAB) &&
 435       (data->register_type != REG_TYPE_UINT32) &&
 436       (data->register_type != REG_TYPE_UINT32_CDAB)) {
 437     NOTICE(
 438         "Modbus plugin: The data source of type \"%s\" is %s, not gauge. "
 439         "This will most likely result in problems, because the register type "
 440         "is not UINT32.",
 441         data->type, DS_TYPE_TO_STRING(ds->ds[0].type));
 442   }
 443
 444   if ((data->register_type == REG_TYPE_INT32) ||
 445       (data->register_type == REG_TYPE_INT32_CDAB) ||
 446       (data->register_type == REG_TYPE_UINT32) ||
 447       (data->register_type == REG_TYPE_UINT32_CDAB) ||
 448       (data->register_type == REG_TYPE_FLOAT) ||
 449       (data->register_type == REG_TYPE_FLOAT_CDAB))
 450     values_num = 2;
 451   else
 452     values_num = 1;
 453
 454   if (host->connection == NULL) {
 455     status = EBADF;
 456   } else if (host->conntype == MBCONN_TCP) {
 457     /* getpeername() is used only to determine if the socket is connected, not
 458      * because we're really interested in the peer's IP address. */
 459     if (getpeername(modbus_get_socket(host->connection),
 460                     (void *)&(struct sockaddr_storage){0},
 461                     &(socklen_t){sizeof(struct sockaddr_storage)}) != 0)
 462       status = errno;
 463   }
 464
 465   if ((status == EBADF) || (status == ENOTSOCK) || (status == ENOTCONN)) {
 466     status = mb_init_connection(host);
 467     if (status != 0) {
 468       ERROR("Modbus plugin: mb_init_connection (%s/%s) failed. ", host->host,
 469             host->node);
 470       host->is_connected = 0;
 471       host->connection = NULL;
 472       return -1;
 473     }
 474   } else if (status != 0) {
 475 #if LEGACY_LIBMODBUS
 476     modbus_close(&host->connection);
 477 #else
 478     modbus_close(host->connection);
 479     modbus_free(host->connection);
 480 #endif
 481   }
 482
 483 #if LEGACY_LIBMODBUS
 484 /* Version 2.0.3: Pass the connection struct as a pointer and pass the slave
 485  * id to each call of "read_holding_registers". */
 486 #define modbus_read_registers(ctx, addr, nb, dest)                             \
 487   read_holding_registers(&(ctx), slave->id, (addr), (nb), (dest))
 488 #else /* if !LEGACY_LIBMODBUS */
 489   /* Version 2.9.2: Set the slave id once before querying the registers. */
 490   status = modbus_set_slave(host->connection, slave->id);
 491   if (status != 0) {
 492     ERROR("Modbus plugin: modbus_set_slave (%i) failed with status %i.",
 493           slave->id, status);
 494     return -1;
 495   }
 496 #endif
 497   if (data->modbus_register_type == MREG_INPUT) {
 498     status = modbus_read_input_registers(host->connection,
 499                                          /* start_addr = */ data->register_base,
 500                                          /* num_registers = */ values_num,
 501                                          /* buffer = */ values);
 502   } else {
 503     status = modbus_read_registers(host->connection,
 504                                    /* start_addr = */ data->register_base,
 505                                    /* num_registers = */ values_num,
 506                                    /* buffer = */ values);
 507   }
 508   if (status != values_num) {
 509     ERROR("Modbus plugin: modbus read function (%s/%s) failed. "
 510           " status = %i, start_addr = %i, values_num = %i. Giving up.",
 511           host->host, host->node, status, data->register_base, values_num);
 512 #if LEGACY_LIBMODBUS
 513     modbus_close(&host->connection);
 514 #else
 515     modbus_close(host->connection);
 516     modbus_free(host->connection);
 517 #endif
 518     host->connection = NULL;
 519     return -1;
 520   }
 521
 522   DEBUG("Modbus plugin: mb_read_data: Success! "
 523         "modbus_read_registers returned with status %i.",
 524         status);
 525
 526   if (data->register_type == REG_TYPE_FLOAT) {
 527     float float_value;
 528     value_t vt;
 529
 530     float_value = mb_register_to_float(values[0], values[1]);
 531     DEBUG("Modbus plugin: mb_read_data: "
 532           "Returned float value is %g",
 533           (double)float_value);
 534
 535     CAST_TO_VALUE_T(ds, vt, float_value, data->scale, data->shift);
 536     mb_submit(host, slave, data, vt);
 537   } else if (data->register_type == REG_TYPE_FLOAT_CDAB) {
 538     float float_value;
 539     value_t vt;
 540
 541     float_value = mb_register_to_float(values[1], values[0]);
 542     DEBUG("Modbus plugin: mb_read_data: "
 543           "Returned float value is %g",
 544           (double)float_value);
 545
 546     CAST_TO_VALUE_T(ds, vt, float_value, data->scale, data->shift);
 547     mb_submit(host, slave, data, vt);
 548   } else if (data->register_type == REG_TYPE_INT32) {
 549     union {
 550       uint32_t u32;
 551       int32_t i32;
 552     } v;
 553     value_t vt;
 554
 555     v.u32 = (((uint32_t)values[0]) << 16) | ((uint32_t)values[1]);
 556     DEBUG("Modbus plugin: mb_read_data: "
 557           "Returned int32 value is %" PRIi32,
 558           v.i32);
 559
 560     CAST_TO_VALUE_T(ds, vt, v.i32, data->scale, data->shift);
 561     mb_submit(host, slave, data, vt);
 562   } else if (data->register_type == REG_TYPE_INT32_CDAB) {
 563     union {
 564       uint32_t u32;
 565       int32_t i32;
 566     } v;
 567     value_t vt;
 568
 569     v.u32 = (((uint32_t)values[1]) << 16) | ((uint32_t)values[0]);
 570     DEBUG("Modbus plugin: mb_read_data: "
 571           "Returned int32 value is %" PRIi32,
 572           v.i32);
 573
 574     CAST_TO_VALUE_T(ds, vt, v.i32, data->scale, data->shift);
 575     mb_submit(host, slave, data, vt);
 576   } else if (data->register_type == REG_TYPE_INT16) {
 577     union {
 578       uint16_t u16;
 579       int16_t i16;
 580     } v;
 581     value_t vt;
 582
 583     v.u16 = values[0];
 584
 585     DEBUG("Modbus plugin: mb_read_data: "
 586           "Returned int16 value is %" PRIi16,
 587           v.i16);
 588
 589     CAST_TO_VALUE_T(ds, vt, v.i16, data->scale, data->shift);
 590     mb_submit(host, slave, data, vt);
 591   } else if (data->register_type == REG_TYPE_UINT32) {
 592     uint32_t v32;
 593     value_t vt;
 594
 595     v32 = (((uint32_t)values[0]) << 16) | ((uint32_t)values[1]);
 596     DEBUG("Modbus plugin: mb_read_data: "
 597           "Returned uint32 value is %" PRIu32,
 598           v32);
 599
 600     CAST_TO_VALUE_T(ds, vt, v32, data->scale, data->shift);
 601     mb_submit(host, slave, data, vt);
 602   } else if (data->register_type == REG_TYPE_UINT32_CDAB) {
 603     uint32_t v32;
 604     value_t vt;
 605
 606     v32 = (((uint32_t)values[1]) << 16) | ((uint32_t)values[0]);
 607     DEBUG("Modbus plugin: mb_read_data: "
 608           "Returned uint32 value is %" PRIu32,
 609           v32);
 610
 611     CAST_TO_VALUE_T(ds, vt, v32, data->scale, data->shift);
 612     mb_submit(host, slave, data, vt);
 613   } else /* if (data->register_type == REG_TYPE_UINT16) */
 614   {
 615     value_t vt;
 616
 617     DEBUG("Modbus plugin: mb_read_data: "
 618           "Returned uint16 value is %" PRIu16,
 619           values[0]);
 620
 621     CAST_TO_VALUE_T(ds, vt, values[0], data->scale, data->shift);
 622     mb_submit(host, slave, data, vt);
 623   }
 624
 625   return 0;
 626 } /* }}} int mb_read_data */
 627
 628 static int mb_read_slave(mb_host_t *host, mb_slave_t *slave) /* {{{ */
 629 {
 630   int success;
 631   int status;
 632
 633   if ((host == NULL) || (slave == NULL))
 634     return EINVAL;
 635
 636   success = 0;
 637   for (mb_data_t *data = slave->collect; data != NULL; data = data->next) {
 638     status = mb_read_data(host, slave, data);
 639     if (status == 0)
 640       success++;
 641   }
 642
 643   if (success == 0)
 644     return -1;
 645   else
 646     return 0;
 647 } /* }}} int mb_read_slave */
 648
 649 static int mb_read(user_data_t *user_data) /* {{{ */
 650 {
 651   mb_host_t *host;
 652   int success;
 653   int status;
 654
 655   if ((user_data == NULL) || (user_data->data == NULL))
 656     return EINVAL;
 657
 658   host = user_data->data;
 659
 660   success = 0;
 661   for (size_t i = 0; i < host->slaves_num; i++) {
 662     status = mb_read_slave(host, host->slaves + i);
 663     if (status == 0)
 664       success++;
 665   }
 666
 667   if (success == 0)
 668     return -1;
 669   else
 670     return 0;
 671 } /* }}} int mb_read */
 672
 673 /* Free functions */
 674
 675 static void data_free_one(mb_data_t *data) /* {{{ */
 676 {
 677   if (data == NULL)
 678     return;
 679
 680   sfree(data->name);
 681   sfree(data);
 682 } /* }}} void data_free_one */
 683
 684 static void data_free_all(mb_data_t *data) /* {{{ */
 685 {
 686   mb_data_t *next;
 687
 688   if (data == NULL)
 689     return;
 690
 691   next = data->next;
 692   data_free_one(data);
 693
 694   data_free_all(next);
 695 } /* }}} void data_free_all */
 696
 697 static void slaves_free_all(mb_slave_t *slaves, size_t slaves_num) /* {{{ */
 698 {
 699   if (slaves == NULL)
 700     return;
 701
 702   for (size_t i = 0; i < slaves_num; i++)
 703     data_free_all(slaves[i].collect);
 704   sfree(slaves);
 705 } /* }}} void slaves_free_all */
 706
 707 static void host_free(void *void_host) /* {{{ */
 708 {
 709   mb_host_t *host = void_host;
 710
 711   if (host == NULL)
 712     return;
 713
 714   slaves_free_all(host->slaves, host->slaves_num);
 715   sfree(host);
 716 } /* }}} void host_free */
 717
 718 /* Config functions */
 719
 720 static int mb_config_add_data(oconfig_item_t *ci) /* {{{ */
 721 {
 722   mb_data_t data = {0};
 723   int status;
 724
 725   data.name = NULL;
 726   data.register_type = REG_TYPE_UINT16;
 727   data.next = NULL;
 728   data.scale = 1;
 729   data.shift = 0;
 730
 731   status = cf_util_get_string(ci, &data.name);
 732   if (status != 0)
 733     return status;
 734
 735   for (int i = 0; i < ci->children_num; i++) {
 736     oconfig_item_t *child = ci->children + i;
 737
 738     if (strcasecmp("Type", child->key) == 0)
 739       status = cf_util_get_string_buffer(child, data.type, sizeof(data.type));
 740     else if (strcasecmp("Instance", child->key) == 0)
 741       status = cf_util_get_string_buffer(child, data.instance,
 742                                          sizeof(data.instance));
 743     else if (strcasecmp("Scale", child->key) == 0)
 744       status = cf_util_get_double(child, &data.scale);
 745     else if (strcasecmp("Shift", child->key) == 0)
 746       status = cf_util_get_double(child, &data.shift);
 747     else if (strcasecmp("RegisterBase", child->key) == 0)
 748       status = cf_util_get_int(child, &data.register_base);
 749     else if (strcasecmp("RegisterType", child->key) == 0) {
 750       char tmp[16];
 751       status = cf_util_get_string_buffer(child, tmp, sizeof(tmp));
 752       if (status != 0)
 753         /* do nothing */;
 754       else if (strcasecmp("Int16", tmp) == 0)
 755         data.register_type = REG_TYPE_INT16;
 756       else if (strcasecmp("Int32", tmp) == 0)
 757         data.register_type = REG_TYPE_INT32;
 758       else if (strcasecmp("Int32LE", tmp) == 0)
 759         data.register_type = REG_TYPE_INT32_CDAB;
 760       else if (strcasecmp("Uint16", tmp) == 0)
 761         data.register_type = REG_TYPE_UINT16;
 762       else if (strcasecmp("Uint32", tmp) == 0)
 763         data.register_type = REG_TYPE_UINT32;
 764       else if (strcasecmp("Uint32LE", tmp) == 0)
 765         data.register_type = REG_TYPE_UINT32_CDAB;
 766       else if (strcasecmp("Float", tmp) == 0)
 767         data.register_type = REG_TYPE_FLOAT;
 768       else if (strcasecmp("FloatLE", tmp) == 0)
 769         data.register_type = REG_TYPE_FLOAT_CDAB;
 770       else {
 771         ERROR("Modbus plugin: The register type \"%s\" is unknown.", tmp);
 772         status = -1;
 773       }
 774     } else if (strcasecmp("RegisterCmd", child->key) == 0) {
 775 #if LEGACY_LIBMODBUS
 776       ERROR("Modbus plugin: RegisterCmd parameter can not be used "
 777             "with your libmodbus version");
 778 #else
 779       char tmp[16];
 780       status = cf_util_get_string_buffer(child, tmp, sizeof(tmp));
 781       if (status != 0)
 782         /* do nothing */;
 783       else if (strcasecmp("ReadHolding", tmp) == 0)
 784         data.modbus_register_type = MREG_HOLDING;
 785       else if (strcasecmp("ReadInput", tmp) == 0)
 786         data.modbus_register_type = MREG_INPUT;
 787       else {
 788         ERROR("Modbus plugin: The modbus_register_type \"%s\" is unknown.",
 789               tmp);
 790         status = -1;
 791       }
 792 #endif
 793     } else {
 794       ERROR("Modbus plugin: Unknown configuration option: %s", child->key);
 795       status = -1;
 796     }
 797
 798     if (status != 0)
 799       break;
 800   } /* for (i = 0; i < ci->children_num; i++) */
 801
 802   assert(data.name != NULL);
 803   if (data.type[0] == 0) {
 804     ERROR("Modbus plugin: Data block \"%s\": No type has been specified.",
 805           data.name);
 806     status = -1;
 807   }
 808
 809   if (status == 0)
 810     data_copy(&data_definitions, &data);
 811
 812   sfree(data.name);
 813
 814   return status;
 815 } /* }}} int mb_config_add_data */
 816
 817 static int mb_config_set_host_address(mb_host_t *host, /* {{{ */
 818                                       const char *address) {
 819   struct addrinfo *ai_list;
 820   int status;
 821
 822   if ((host == NULL) || (address == NULL))
 823     return EINVAL;
 824
 825   struct addrinfo ai_hints = {
 826       /* XXX: libmodbus can only handle IPv4 addresses. */
 827       .ai_family = AF_INET,
 828       .ai_flags = AI_ADDRCONFIG};
 829
 830   status = getaddrinfo(address, /* service = */ NULL, &ai_hints, &ai_list);
 831   if (status != 0) {
 832     ERROR("Modbus plugin: getaddrinfo failed: %s",
 833           (status == EAI_SYSTEM) ? STRERRNO : gai_strerror(status));
 834     return status;
 835   }
 836
 837   for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
 838        ai_ptr = ai_ptr->ai_next) {
 839     status = getnameinfo(ai_ptr->ai_addr, ai_ptr->ai_addrlen, host->node,
 840                          sizeof(host->node),
 841                          /* service = */ NULL, /* length = */ 0,
 842                          /* flags = */ NI_NUMERICHOST);
 843     if (status == 0)
 844       break;
 845   } /* for (ai_ptr) */
 846
 847   freeaddrinfo(ai_list);
 848
 849   if (status != 0)
 850     ERROR("Modbus plugin: Unable to translate node name: \"%s\"", address);
 851   else /* if (status == 0) */
 852   {
 853     DEBUG("Modbus plugin: mb_config_set_host_address: %s -> %s", address,
 854           host->node);
 855   }
 856
 857   return status;
 858 } /* }}} int mb_config_set_host_address */
 859
 860 static int mb_config_add_slave(mb_host_t *host, oconfig_item_t *ci) /* {{{ */
 861 {
 862   mb_slave_t *slave;
 863   int status;
 864
 865   if ((host == NULL) || (ci == NULL))
 866     return EINVAL;
 867
 868   slave = realloc(host->slaves, sizeof(*slave) * (host->slaves_num + 1));
 869   if (slave == NULL)
 870     return ENOMEM;
 871   host->slaves = slave;
 872   slave = host->slaves + host->slaves_num;
 873   memset(slave, 0, sizeof(*slave));
 874   slave->collect = NULL;
 875
 876   status = cf_util_get_int(ci, &slave->id);
 877   if (status != 0)
 878     return status;
 879
 880   for (int i = 0; i < ci->children_num; i++) {
 881     oconfig_item_t *child = ci->children + i;
 882
 883     if (strcasecmp("Instance", child->key) == 0)
 884       status = cf_util_get_string_buffer(child, slave->instance,
 885                                          sizeof(slave->instance));
 886     else if (strcasecmp("Collect", child->key) == 0) {
 887       char buffer[1024];
 888       status = cf_util_get_string_buffer(child, buffer, sizeof(buffer));
 889       if (status == 0)
 890         data_copy_by_name(&slave->collect, data_definitions, buffer);
 891       status = 0; /* continue after failure. */
 892     } else {
 893       ERROR("Modbus plugin: Unknown configuration option: %s", child->key);
 894       status = -1;
 895     }
 896
 897     if (status != 0)
 898       break;
 899   }
 900
 901   if ((status == 0) && (slave->collect == NULL))
 902     status = EINVAL;
 903
 904   if (slave->id < 0)
 905     status = EINVAL;
 906
 907   if (status == 0)
 908     host->slaves_num++;
 909   else /* if (status != 0) */
 910     data_free_all(slave->collect);
 911
 912   return status;
 913 } /* }}} int mb_config_add_slave */
 914
 915 static int mb_config_add_host(oconfig_item_t *ci) /* {{{ */
 916 {
 917   mb_host_t *host;
 918   int status;
 919
 920   host = calloc(1, sizeof(*host));
 921   if (host == NULL)
 922     return ENOMEM;
 923   host->slaves = NULL;
 924
 925   status = cf_util_get_string_buffer(ci, host->host, sizeof(host->host));
 926   if (status != 0) {
 927     sfree(host);
 928     return status;
 929   }
 930   if (host->host[0] == 0) {
 931     sfree(host);
 932     return EINVAL;
 933   }
 934
 935   for (int i = 0; i < ci->children_num; i++) {
 936     oconfig_item_t *child = ci->children + i;
 937     status = 0;
 938
 939     if (strcasecmp("Address", child->key) == 0) {
 940       char buffer[NI_MAXHOST];
 941       status = cf_util_get_string_buffer(child, buffer, sizeof(buffer));
 942       if (status == 0)
 943         status = mb_config_set_host_address(host, buffer);
 944       if (status == 0)
 945         host->conntype = MBCONN_TCP;
 946     } else if (strcasecmp("Port", child->key) == 0) {
 947       host->port = cf_util_get_port_number(child);
 948       if (host->port <= 0)
 949         status = -1;
 950     } else if (strcasecmp("Device", child->key) == 0) {
 951       status = cf_util_get_string_buffer(child, host->node, sizeof(host->node));
 952       if (status == 0)
 953         host->conntype = MBCONN_RTU;
 954     } else if (strcasecmp("Baudrate", child->key) == 0)
 955       status = cf_util_get_int(child, &host->baudrate);
 956     else if (strcasecmp("Interval", child->key) == 0)
 957       status = cf_util_get_cdtime(child, &host->interval);
 958     else if (strcasecmp("Slave", child->key) == 0)
 959       /* Don't set status: Gracefully continue if a slave fails. */
 960       mb_config_add_slave(host, child);
 961     else {
 962       ERROR("Modbus plugin: Unknown configuration option: %s", child->key);
 963       status = -1;
 964     }
 965
 966     if (status != 0)
 967       break;
 968   } /* for (i = 0; i < ci->children_num; i++) */
 969
 970   assert(host->host[0] != 0);
 971   if (host->node[0] == 0) {
 972     ERROR("Modbus plugin: Data block \"%s\": No address or device has been "
 973           "specified.",
 974           host->host);
 975     status = -1;
 976   }
 977   if (host->conntype == MBCONN_RTU && !host->baudrate) {
 978     ERROR("Modbus plugin: Data block \"%s\": No serial baudrate has been "
 979           "specified.",
 980           host->host);
 981     status = -1;
 982   }
 983   if ((host->conntype == MBCONN_TCP && host->baudrate) ||
 984       (host->conntype == MBCONN_RTU && host->port)) {
 985     ERROR("Modbus plugin: Data block \"%s\": You've mixed up RTU and TCP "
 986           "options.",
 987           host->host);
 988     status = -1;
 989   }
 990
 991   if (status == 0) {
 992     char name[1024];
 993
 994     snprintf(name, sizeof(name), "modbus-%s", host->host);
 995
 996     plugin_register_complex_read(/* group = */ NULL, name,
 997                                  /* callback = */ mb_read,
 998                                  /* interval = */ host->interval,
 999                                  &(user_data_t){
1000                                      .data = host,
1001                                      .free_func = host_free,
1002                                  });
1003   } else {
1004     host_free(host);
1005   }
1006
1007   return status;
1008 } /* }}} int mb_config_add_host */
1009
1010 static int mb_config(oconfig_item_t *ci) /* {{{ */
1011 {
1012   if (ci == NULL)
1013     return EINVAL;
1014
1015   for (int i = 0; i < ci->children_num; i++) {
1016     oconfig_item_t *child = ci->children + i;
1017
1018     if (strcasecmp("Data", child->key) == 0)
1019       mb_config_add_data(child);
1020     else if (strcasecmp("Host", child->key) == 0)
1021       mb_config_add_host(child);
1022     else
1023       ERROR("Modbus plugin: Unknown configuration option: %s", child->key);
1024   }
1025
1026   return 0;
1027 } /* }}} int mb_config */
1028
1029 /* ========= */
1030
1031 static int mb_shutdown(void) /* {{{ */
1032 {
1033   data_free_all(data_definitions);
1034   data_definitions = NULL;
1035
1036   return 0;
1037 } /* }}} int mb_shutdown */
1038
1039 void module_register(void) {
1040   plugin_register_complex_config("modbus", mb_config);
1041   plugin_register_shutdown("modbus", mb_shutdown);
1042 } /* void module_register */