+
+ pn.head = (part_header_t *) *ret_buffer;
+ pn.value = (uint64_t *) (pn.head + 1);
+
+ pn.head->type = htons (type);
+ pn.head->length = htons (12);
+ *pn.value = htonll (value);
+
+ *ret_buffer = (char *) (pn.value + 1);
+ *ret_buffer_len -= 12;
+
+ 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)
+{
+ part_string_t ps;
+ int len;
+
+ len = 4 + str_len + 1;
+ if (*ret_buffer_len < len)
+ return (-1);
+ *ret_buffer_len -= len;
+
+ ps.head = (part_header_t *) *ret_buffer;
+ ps.value = (char *) (ps.head + 1);
+
+ ps.head->type = htons ((uint16_t) type);
+ ps.head->length = htons ((uint16_t) str_len + 5);
+ if (str_len > 0)
+ memcpy (ps.value, str, str_len);
+ ps.value[str_len] = '\0';
+ *ret_buffer = (void *) (ps.value + (str_len + 1));
+
+ 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;
+ part_values_t pv;
+ int i;
+
+ uint16_t h_length;
+ uint16_t h_type;
+ uint16_t h_num;
+
+ if (buffer_len < (15))
+ {
+ DEBUG ("network plugin: packet is too short: buffer_len = %i",
+ buffer_len);
+ return (-1);
+ }
+
+ pv.head = (part_header_t *) buffer;
+ h_length = ntohs (pv.head->length);
+ h_type = ntohs (pv.head->type);
+
+ assert (h_type == TYPE_VALUES);
+
+ pv.num_values = (uint16_t *) (pv.head + 1);
+ h_num = ntohs (*pv.num_values);
+
+ if (h_num != ((h_length - 6) / 9))
+ {
+ DEBUG ("`length' and `num of values' don't match");
+ return (-1);
+ }
+
+ pv.values_types = (uint8_t *) (pv.num_values + 1);
+ pv.values = (value_t *) (pv.values_types + h_num);
+
+ for (i = 0; i < h_num; i++)
+ if (pv.values_types[i] == DS_TYPE_COUNTER)
+ pv.values[i].counter = ntohll (pv.values[i].counter);
+
+ *ret_buffer = (void *) (pv.values + h_num);
+ *ret_buffer_len = buffer_len - h_length;
+ *ret_num_values = h_num;
+ *ret_values = pv.values;
+
+ return (0);
+} /* int parse_part_values */
+
+static int parse_part_number (void **ret_buffer, int *ret_buffer_len,
+ uint64_t *value)
+{
+ part_number_t pn;
+ uint16_t len;
+
+ pn.head = (part_header_t *) *ret_buffer;
+ pn.value = (uint64_t *) (pn.head + 1);
+
+ len = ntohs (pn.head->length);
+ if (len != 12)
+ return (-1);
+ if (len > *ret_buffer_len)
+ return (-1);
+ *value = ntohll (*pn.value);
+
+ *ret_buffer = (void *) (pn.value + 1);
+ *ret_buffer_len -= len;
+
+ 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;
+ part_string_t ps;
+
+ uint16_t h_length;
+ uint16_t h_type;
+
+ DEBUG ("network plugin: parse_part_string: ret_buffer = %p;"
+ " ret_buffer_len = %i; output = %p; output_len = %i;",
+ *ret_buffer, *ret_buffer_len,
+ (void *) output, output_len);
+
+ ps.head = (part_header_t *) buffer;
+
+ h_length = ntohs (ps.head->length);
+ h_type = ntohs (ps.head->type);
+
+ DEBUG ("network plugin: parse_part_string: length = %hu; type = %hu;",
+ h_length, h_type);
+
+ if (buffer_len < h_length)
+ {
+ DEBUG ("packet is too short");
+ return (-1);
+ }
+ assert ((h_type == TYPE_HOST)
+ || (h_type == TYPE_PLUGIN)
+ || (h_type == TYPE_PLUGIN_INSTANCE)
+ || (h_type == TYPE_TYPE)
+ || (h_type == TYPE_TYPE_INSTANCE));
+
+ ps.value = buffer + 4;
+ if (ps.value[h_length - 5] != '\0')
+ {
+ DEBUG ("String does not end with a nullbyte");
+ return (-1);
+ }
+
+ if (output_len < (h_length - 4))
+ {
+ DEBUG ("output buffer is too small");
+ return (-1);
+ }
+ strcpy (output, ps.value);
+
+ DEBUG ("network plugin: parse_part_string: output = %s", output);
+
+ *ret_buffer = (void *) (buffer + h_length);
+ *ret_buffer_len = buffer_len - h_length;
+
+ return (0);
+} /* int parse_part_string */
+
+static int parse_packet (void *buffer, int buffer_len)
+{
+ part_header_t *header;
+ 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)))
+ {
+ header = (part_header_t *) buffer;
+
+ if (ntohs (header->length) > buffer_len)
+ break;
+ /* Assure that this loop terminates eventually */
+ if (ntohs (header->length) < 4)
+ break;
+
+ if (ntohs (header->type) == TYPE_VALUES)
+ {
+ status = parse_part_values (&buffer, &buffer_len,
+ &vl.values, &vl.values_len);
+
+ if (status != 0)
+ {
+ DEBUG ("parse_part_values failed.");
+ break;
+ }
+
+ if ((vl.time > 0)
+ && (strlen (vl.host) > 0)
+ && (strlen (vl.plugin) > 0)
+ && (strlen (type) > 0)
+ && (cache_check (type, &vl) == 0))
+ {
+ DEBUG ("network plugin: parse_packet:"
+ " dispatching values");
+ plugin_dispatch_values (type, &vl);
+ }
+ else
+ {
+ DEBUG ("network plugin: parse_packet:"
+ " NOT dispatching values");
+ }
+ }
+ else if (ntohs (header->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 (ntohs (header->type) == TYPE_INTERVAL)
+ {
+ uint64_t tmp = 0;
+ status = parse_part_number (&buffer, &buffer_len, &tmp);
+ if (status == 0)
+ vl.interval = (int) tmp;
+ }
+ else if (ntohs (header->type) == TYPE_HOST)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.host, sizeof (vl.host));
+ DEBUG ("network plugin: parse_packet: vl.host = %s", vl.host);
+ }
+ else if (ntohs (header->type) == TYPE_PLUGIN)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.plugin, sizeof (vl.plugin));
+ DEBUG ("network plugin: parse_packet: vl.plugin = %s", vl.plugin);
+ }
+ else if (ntohs (header->type) == TYPE_PLUGIN_INSTANCE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.plugin_instance, sizeof (vl.plugin_instance));
+ DEBUG ("network plugin: parse_packet: vl.plugin_instance = %s", vl.plugin_instance);
+ }
+ else if (ntohs (header->type) == TYPE_TYPE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ type, sizeof (type));
+ DEBUG ("network plugin: parse_packet: type = %s", type);
+ }
+ else if (ntohs (header->type) == TYPE_TYPE_INSTANCE)
+ {
+ status = parse_part_string (&buffer, &buffer_len,
+ vl.type_instance, sizeof (vl.type_instance));
+ DEBUG ("network plugin: parse_packet: vl.type_instance = %s", vl.type_instance);
+ }
+ else
+ {
+ DEBUG ("network plugin: parse_packet: Unknown part"
+ " type: 0x%0hx", ntohs (header->type));
+ buffer = ((char *) buffer) + ntohs (header->length);
+ }
+ } /* while (buffer_len > sizeof (part_header_t)) */
+
+ return (0);
+} /* 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;