+
+ pkg_values_types = (uint8_t *) malloc (num_values * sizeof (uint8_t));
+ if (pkg_values_types == NULL)
+ {
+ ERROR ("network plugin: write_part_values: malloc failed.");
+ return (-1);
+ }
+
+ pkg_values = (value_t *) malloc (num_values * sizeof (value_t));
+ if (pkg_values == NULL)
+ {
+ free (pkg_values_types);
+ ERROR ("network plugin: write_part_values: malloc failed.");
+ return (-1);
+ }
+
+ pkg_ph.type = htons (TYPE_VALUES);
+ pkg_ph.length = htons (packet_len);
+
+ pkg_num_values = htons ((uint16_t) vl->values_len);
+
+ for (i = 0; i < num_values; i++)
+ {
+ if (ds->ds[i].type == DS_TYPE_COUNTER)
+ {
+ pkg_values_types[i] = DS_TYPE_COUNTER;
+ pkg_values[i].counter = htonll (vl->values[i].counter);
+ }
+ else
+ {
+ pkg_values_types[i] = DS_TYPE_GAUGE;
+ pkg_values[i].gauge = htond (vl->values[i].gauge);
+ }
+ }
+
+ /*
+ * Use `memcpy' to write everything to the buffer, because the pointer
+ * may be unaligned and some architectures, such as SPARC, can't handle
+ * that.
+ */
+ packet_ptr = *ret_buffer;
+ offset = 0;
+ memcpy (packet_ptr + offset, &pkg_ph, sizeof (pkg_ph));
+ offset += sizeof (pkg_ph);
+ memcpy (packet_ptr + offset, &pkg_num_values, sizeof (pkg_num_values));
+ offset += sizeof (pkg_num_values);
+ memcpy (packet_ptr + offset, pkg_values_types, num_values * sizeof (uint8_t));
+ offset += num_values * sizeof (uint8_t);
+ memcpy (packet_ptr + offset, pkg_values, num_values * sizeof (value_t));
+ offset += num_values * sizeof (value_t);
+
+ assert (offset == packet_len);
+
+ *ret_buffer = packet_ptr + packet_len;
+ *ret_buffer_len -= packet_len;
+
+ free (pkg_values_types);
+ free (pkg_values);
+
+ return (0);
+} /* int write_part_values */
+
+static int write_part_number (char **ret_buffer, int *ret_buffer_len,
+ int type, uint64_t value)
+{
+ char *packet_ptr;
+ int packet_len;
+
+ part_header_t pkg_head;
+ uint64_t pkg_value;
+
+ int offset;
+
+ packet_len = sizeof (pkg_head) + sizeof (pkg_value);
+
+ if (*ret_buffer_len < packet_len)
+ return (-1);
+
+ pkg_head.type = htons (type);
+ pkg_head.length = htons (packet_len);
+ pkg_value = htonll (value);
+
+ packet_ptr = *ret_buffer;
+ offset = 0;
+ memcpy (packet_ptr + offset, &pkg_head, sizeof (pkg_head));
+ offset += sizeof (pkg_head);
+ memcpy (packet_ptr + offset, &pkg_value, sizeof (pkg_value));
+ offset += sizeof (pkg_value);
+
+ assert (offset == packet_len);
+
+ *ret_buffer = packet_ptr + packet_len;
+ *ret_buffer_len -= packet_len;
+
+ return (0);
+} /* int write_part_number */
+
+static int write_part_string (char **ret_buffer, int *ret_buffer_len,
+ int type, const char *str, int str_len)
+{
+ char *buffer;
+ int buffer_len;
+
+ uint16_t pkg_type;
+ uint16_t pkg_length;
+
+ int offset;
+
+ buffer_len = 2 * sizeof (uint16_t) + str_len + 1;
+ if (*ret_buffer_len < buffer_len)
+ return (-1);
+
+ pkg_type = htons (type);
+ pkg_length = htons (buffer_len);
+
+ buffer = *ret_buffer;
+ offset = 0;
+ memcpy (buffer + offset, (void *) &pkg_type, sizeof (pkg_type));
+ offset += sizeof (pkg_type);
+ memcpy (buffer + offset, (void *) &pkg_length, sizeof (pkg_length));
+ offset += sizeof (pkg_length);
+ memcpy (buffer + offset, str, str_len);
+ offset += str_len;
+ memset (buffer + offset, '\0', 1);
+ offset += 1;
+
+ assert (offset == buffer_len);
+
+ *ret_buffer = buffer + buffer_len;
+ *ret_buffer_len -= buffer_len;
+
+ return (0);
+} /* int write_part_string */
+
+static int parse_part_values (void **ret_buffer, int *ret_buffer_len,
+ value_t **ret_values, int *ret_num_values)
+{
+ char *buffer = *ret_buffer;
+ int buffer_len = *ret_buffer_len;
+
+ uint16_t tmp16;
+ size_t exp_size;
+ int i;
+
+ uint16_t pkg_length;
+ uint16_t pkg_type;
+ uint16_t pkg_numval;
+
+ uint8_t *pkg_types;
+ value_t *pkg_values;
+
+ if (buffer_len < (15))
+ {
+ DEBUG ("network plugin: packet is too short: buffer_len = %i",
+ buffer_len);
+ return (-1);
+ }
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_type = ntohs (tmp16);
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_length = ntohs (tmp16);
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_numval = ntohs (tmp16);
+
+ assert (pkg_type == TYPE_VALUES);
+
+ exp_size = 3 * sizeof (uint16_t)
+ + pkg_numval * (sizeof (uint8_t) + sizeof (value_t));
+ if (buffer_len < exp_size)
+ {
+ WARNING ("network plugin: parse_part_values: "
+ "Packet too short: "
+ "Chunk of size %u expected, "
+ "but buffer has only %i bytes left.",
+ (unsigned int) exp_size, buffer_len);
+ return (-1);
+ }
+
+ if (pkg_length != exp_size)
+ {
+ WARNING ("network plugin: parse_part_values: "
+ "Length and number of values "
+ "in the packet don't match.");
+ return (-1);
+ }
+
+ pkg_types = (uint8_t *) malloc (pkg_numval * sizeof (uint8_t));
+ pkg_values = (value_t *) malloc (pkg_numval * sizeof (value_t));
+ if ((pkg_types == NULL) || (pkg_values == NULL))
+ {
+ sfree (pkg_types);
+ sfree (pkg_values);
+ ERROR ("network plugin: parse_part_values: malloc failed.");
+ return (-1);
+ }
+
+ memcpy ((void *) pkg_types, (void *) buffer, pkg_numval * sizeof (uint8_t));
+ buffer += pkg_numval * sizeof (uint8_t);
+ memcpy ((void *) pkg_values, (void *) buffer, pkg_numval * sizeof (value_t));
+ buffer += pkg_numval * sizeof (value_t);
+
+ for (i = 0; i < pkg_numval; i++)
+ {
+ if (pkg_types[i] == DS_TYPE_COUNTER)
+ pkg_values[i].counter = ntohll (pkg_values[i].counter);
+ else if (pkg_types[i] == DS_TYPE_GAUGE)
+ pkg_values[i].gauge = ntohd (pkg_values[i].gauge);
+ }
+
+ *ret_buffer = buffer;
+ *ret_buffer_len = buffer_len - pkg_length;
+ *ret_num_values = pkg_numval;
+ *ret_values = pkg_values;
+
+ sfree (pkg_types);
+
+ return (0);
+} /* int parse_part_values */
+
+static int parse_part_number (void **ret_buffer, int *ret_buffer_len,
+ uint64_t *value)
+{
+ char *buffer = *ret_buffer;
+ int buffer_len = *ret_buffer_len;
+
+ uint16_t tmp16;
+ uint64_t tmp64;
+ size_t exp_size = 2 * sizeof (uint16_t) + sizeof (uint64_t);
+
+ uint16_t pkg_length;
+ uint16_t pkg_type;
+
+ if (buffer_len < exp_size)
+ {
+ WARNING ("network plugin: parse_part_number: "
+ "Packet too short: "
+ "Chunk of size %u expected, "
+ "but buffer has only %i bytes left.",
+ (unsigned int) exp_size, buffer_len);
+ return (-1);
+ }
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_type = ntohs (tmp16);
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_length = ntohs (tmp16);
+
+ memcpy ((void *) &tmp64, buffer, sizeof (tmp64));
+ buffer += sizeof (tmp64);
+ *value = ntohll (tmp64);
+
+ *ret_buffer = buffer;
+ *ret_buffer_len = buffer_len - pkg_length;
+
+ return (0);
+} /* int parse_part_number */
+
+static int parse_part_string (void **ret_buffer, int *ret_buffer_len,
+ char *output, int output_len)
+{
+ char *buffer = *ret_buffer;
+ int buffer_len = *ret_buffer_len;
+
+ uint16_t tmp16;
+ size_t header_size = 2 * sizeof (uint16_t);
+
+ uint16_t pkg_length;
+ uint16_t pkg_type;
+
+ if (buffer_len < header_size)
+ {
+ WARNING ("network plugin: parse_part_string: "
+ "Packet too short: "
+ "Chunk of at least size %u expected, "
+ "but buffer has only %i bytes left.",
+ (unsigned int) header_size, buffer_len);
+ return (-1);
+ }
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_type = ntohs (tmp16);
+
+ memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
+ buffer += sizeof (tmp16);
+ pkg_length = ntohs (tmp16);
+
+ /* Check that packet fits in the input buffer */
+ if (pkg_length > buffer_len)
+ {
+ WARNING ("network plugin: parse_part_string: "
+ "Packet too big: "
+ "Chunk of size %hu received, "
+ "but buffer has only %i bytes left.",
+ pkg_length, buffer_len);
+ return (-1);
+ }
+
+ /* Check that pkg_length is in the valid range */
+ if (pkg_length <= header_size)
+ {
+ WARNING ("network plugin: parse_part_string: "
+ "Packet too short: "
+ "Header claims this packet is only %hu "
+ "bytes long.", pkg_length);
+ return (-1);
+ }
+
+ /* Check that the package data fits into the output buffer.
+ * The previous if-statement ensures that:
+ * `pkg_length > header_size' */
+ if ((pkg_length - header_size) > output_len)
+ {
+ WARNING ("network plugin: parse_part_string: "
+ "Output buffer too small.");
+ return (-1);
+ }
+
+ /* All sanity checks successfull, let's copy the data over */
+ output_len = pkg_length - header_size;
+ memcpy ((void *) output, (void *) buffer, output_len);
+ buffer += output_len;
+
+ /* For some very weird reason '\0' doesn't do the trick on SPARC in
+ * this statement. */
+ if (output[output_len - 1] != 0)
+ {
+ WARNING ("network plugin: parse_part_string: "
+ "Received string does not end "
+ "with a NULL-byte.");
+ return (-1);
+ }
+
+ *ret_buffer = buffer;
+ *ret_buffer_len = buffer_len - pkg_length;
+
+ return (0);
+} /* int parse_part_string */
+
+static int parse_packet (void *buffer, int buffer_len)
+{
+ int status;
+
+ value_list_t vl = VALUE_LIST_INIT;
+ char type[DATA_MAX_NAME_LEN];
+
+ DEBUG ("network plugin: parse_packet: buffer = %p; buffer_len = %i;",
+ buffer, buffer_len);
+
+ memset (&vl, '\0', sizeof (vl));
+ memset (&type, '\0', sizeof (type));
+ status = 0;
+
+ while ((status == 0) && (buffer_len > sizeof (part_header_t)))
+ {
+ uint16_t pkg_length;
+ uint16_t pkg_type;
+
+ memcpy ((void *) &pkg_type,
+ (void *) buffer,
+ sizeof (pkg_type));
+ memcpy ((void *) &pkg_length,
+ (void *) (buffer + sizeof (pkg_type)),
+ sizeof (pkg_length));
+
+ pkg_length = ntohs (pkg_length);
+ pkg_type = ntohs (pkg_type);
+
+ if (pkg_length > buffer_len)
+ break;
+ /* Ensure that this loop terminates eventually */
+ if (pkg_length < (2 * sizeof (uint16_t)))
+ break;
+
+ if (pkg_type == TYPE_VALUES)
+ {
+ status = parse_part_values (&buffer, &buffer_len,
+ &vl.values, &vl.values_len);
+
+ if (status != 0)
+ break;
+
+ if ((vl.time > 0)
+ && (strlen (vl.host) > 0)
+ && (strlen (vl.plugin) > 0)
+ && (strlen (type) > 0)
+ && (cache_check (type, &vl) == 0))
+ {
+ plugin_dispatch_values (type, &vl);
+ }
+ else
+ {
+ DEBUG ("network plugin: parse_packet:"
+ " NOT dispatching values");
+ }
+
+ sfree (vl.values);
+ }
+ else if (pkg_type == TYPE_TIME)
+ {
+ uint64_t tmp = 0;
+ status = parse_part_number (&buffer, &buffer_len, &tmp);
+ if (status == 0)
+ vl.time = (time_t) tmp;
+ }
+ else if (pkg_type == TYPE_INTERVAL)
+ {
+ uint64_t tmp = 0;
+ status = parse_part_number (&buffer, &buffer_len, &tmp);
+ if (status == 0)
+ vl.interval = (int) tmp;
+ }
+ else if (pkg_type == TYPE_HOST)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.host, sizeof (vl.host));
+ }
+ else if (pkg_type == TYPE_PLUGIN)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.plugin, sizeof (vl.plugin));
+ }
+ else if (pkg_type == TYPE_PLUGIN_INSTANCE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.plugin_instance, sizeof (vl.plugin_instance));
+ }
+ else if (pkg_type == TYPE_TYPE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ type, sizeof (type));
+ }
+ else if (pkg_type == TYPE_TYPE_INSTANCE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.type_instance, sizeof (vl.type_instance));
+ }
+ else
+ {
+ DEBUG ("network plugin: parse_packet: Unknown part"
+ " type: 0x%04hx", pkg_type);
+ buffer = ((char *) buffer) + pkg_length;
+ }
+ } /* while (buffer_len > sizeof (part_header_t)) */
+
+ return (status);
+} /* int parse_packet */
+
+static void free_sockent (sockent_t *se)
+{
+ sockent_t *next;
+ while (se != NULL)
+ {
+ next = se->next;
+ free (se->addr);
+ free (se);
+ se = next;