src/zeromq_borrowed.c

   1 /**
   2  * collectd - src/zeromq.c
   3  * Copyright (C) 2005-2010  Florian octo Forster
   4  * Copyright (C) 2009       Aman Gupta
   5  * Copyright (C) 2010       Julien Ammous
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; only version 2 of the License is applicable.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  *
  20  * Authors:
  21  *   Florian octo Forster <octo at verplant.org>
  22  *   Aman Gupta <aman at tmm1.net>
  23  *   Julien Ammous
  24  **/
  25
  26 //
  27 // mostly copy/pasted from network.c ...
  28 // this whole file will be dropped as soon as
  29 // it can be replaced by network_buffer library
  30 //
  31
  32 static value_list_t     send_buffer_vl = VALUE_LIST_STATIC;
  33
  34 static uint64_t stats_values_not_dispatched = 0;
  35 static uint64_t stats_values_dispatched = 0;
  36
  37 /*                      1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
  38  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  39  * +-------+-----------------------+-------------------------------+
  40  * ! Ver.  !                       ! Length                        !
  41  * +-------+-----------------------+-------------------------------+
  42  */
  43 struct part_header_s
  44 {
  45         uint16_t type;
  46         uint16_t length;
  47 };
  48 typedef struct part_header_s part_header_t;
  49
  50 // we do not want to crypt here
  51 #undef HAVE_LIBGCRYPT
  52
  53 static _Bool check_receive_okay (const value_list_t *vl) /* {{{ */
  54 {
  55   uint64_t time_sent = 0;
  56   int status;
  57
  58   status = uc_meta_data_get_unsigned_int (vl,
  59       "zeromq:time_sent", &time_sent);
  60
  61   /* This is a value we already sent. Don't allow it to be received again in
  62    * order to avoid looping. */
  63   if ((status == 0) && (time_sent >= ((uint64_t) vl->time)))
  64     return (0);
  65
  66   return (1);
  67 } /* }}} _Bool check_receive_okay */
  68
  69 static int network_dispatch_values (value_list_t *vl, /* {{{ */
  70     const char *username)
  71 {
  72   int status;
  73
  74   // DEBUG("host: %s", vl->host);
  75   // DEBUG("plugin: %s", vl->plugin);
  76   // DEBUG("plugin_instance: %s", vl->plugin_instance);
  77   // DEBUG("type: %s", vl->type);
  78   // DEBUG("type_instance: %s", vl->type_instance);
  79
  80   if ((vl->time <= 0)
  81       || (strlen (vl->host) <= 0)
  82       || (strlen (vl->plugin) <= 0)
  83       || (strlen (vl->type) <= 0))
  84     return (-EINVAL);
  85
  86   if (!check_receive_okay (vl))
  87   {
  88 #if COLLECT_DEBUG
  89     char name[6*DATA_MAX_NAME_LEN];
  90     FORMAT_VL (name, sizeof (name), vl);
  91     name[sizeof (name) - 1] = 0;
  92     DEBUG ("network plugin: network_dispatch_values: "
  93         "NOT dispatching %s.", name);
  94 #endif
  95     stats_values_not_dispatched++;
  96     return (0);
  97   }
  98
  99   assert (vl->meta == NULL);
 100
 101   vl->meta = meta_data_create ();
 102   if (vl->meta == NULL)
 103   {
 104     ERROR ("network plugin: meta_data_create failed.");
 105     return (-ENOMEM);
 106   }
 107
 108   status = meta_data_add_boolean (vl->meta, "zeromq:received", 1);
 109   if (status != 0)
 110   {
 111     ERROR ("network plugin: meta_data_add_boolean failed.");
 112     meta_data_destroy (vl->meta);
 113     vl->meta = NULL;
 114     return (status);
 115   }
 116
 117   if (username != NULL)
 118   {
 119     status = meta_data_add_string (vl->meta, "zeromq:username", username);
 120     if (status != 0)
 121     {
 122       ERROR ("network plugin: meta_data_add_string failed.");
 123       meta_data_destroy (vl->meta);
 124       vl->meta = NULL;
 125       return (status);
 126     }
 127   }
 128
 129   // DEBUG("dispatching %d values", vl->values_len);
 130   plugin_dispatch_values (vl);
 131   stats_values_dispatched++;
 132
 133   meta_data_destroy (vl->meta);
 134   vl->meta = NULL;
 135
 136   return (0);
 137 } /* }}} int network_dispatch_values */
 138
 139 static int write_part_values (char **ret_buffer, int *ret_buffer_len, const data_set_t *ds, const value_list_t *vl)
 140 {
 141   char *packet_ptr;
 142   int packet_len;
 143   int num_values;
 144
 145   part_header_t pkg_ph;
 146   uint16_t      pkg_num_values;
 147   uint8_t      *pkg_values_types;
 148   value_t      *pkg_values;
 149
 150   int offset;
 151   int i;
 152
 153   num_values = vl->values_len;
 154   packet_len = sizeof (part_header_t) + sizeof (uint16_t)
 155     + (num_values * sizeof (uint8_t))
 156     + (num_values * sizeof (value_t));
 157
 158   if (*ret_buffer_len < packet_len)
 159     return (-1);
 160
 161   pkg_values_types = (uint8_t *) malloc (num_values * sizeof (uint8_t));
 162   if (pkg_values_types == NULL)
 163   {
 164     ERROR ("network plugin: write_part_values: malloc failed.");
 165     return (-1);
 166   }
 167
 168   pkg_values = (value_t *) malloc (num_values * sizeof (value_t));
 169   if (pkg_values == NULL)
 170   {
 171     free (pkg_values_types);
 172     ERROR ("network plugin: write_part_values: malloc failed.");
 173     return (-1);
 174   }
 175
 176   pkg_ph.type = htons (TYPE_VALUES);
 177   pkg_ph.length = htons (packet_len);
 178
 179   pkg_num_values = htons ((uint16_t) vl->values_len);
 180
 181   for (i = 0; i < num_values; i++)
 182   {
 183     pkg_values_types[i] = (uint8_t) ds->ds[i].type;
 184     switch (ds->ds[i].type)
 185     {
 186       case DS_TYPE_COUNTER:
 187         pkg_values[i].counter = htonll (vl->values[i].counter);
 188         break;
 189
 190       case DS_TYPE_GAUGE:
 191         pkg_values[i].gauge = htond (vl->values[i].gauge);
 192         break;
 193
 194       case DS_TYPE_DERIVE:
 195         pkg_values[i].derive = htonll (vl->values[i].derive);
 196         break;
 197
 198       case DS_TYPE_ABSOLUTE:
 199         pkg_values[i].absolute = htonll (vl->values[i].absolute);
 200         break;
 201
 202       default:
 203         free (pkg_values_types);
 204         free (pkg_values);
 205         ERROR ("network plugin: write_part_values: "
 206             "Unknown data source type: %i",
 207             ds->ds[i].type);
 208         return (-1);
 209     } /* switch (ds->ds[i].type) */
 210   } /* for (num_values) */
 211
 212   /*
 213    * Use `memcpy' to write everything to the buffer, because the pointer
 214    * may be unaligned and some architectures, such as SPARC, can't handle
 215    * that.
 216    */
 217   packet_ptr = *ret_buffer;
 218   offset = 0;
 219   memcpy (packet_ptr + offset, &pkg_ph, sizeof (pkg_ph));
 220   offset += sizeof (pkg_ph);
 221   memcpy (packet_ptr + offset, &pkg_num_values, sizeof (pkg_num_values));
 222   offset += sizeof (pkg_num_values);
 223   memcpy (packet_ptr + offset, pkg_values_types, num_values * sizeof (uint8_t));
 224   offset += num_values * sizeof (uint8_t);
 225   memcpy (packet_ptr + offset, pkg_values, num_values * sizeof (value_t));
 226   offset += num_values * sizeof (value_t);
 227
 228   assert (offset == packet_len);
 229
 230   *ret_buffer = packet_ptr + packet_len;
 231   *ret_buffer_len -= packet_len;
 232
 233   free (pkg_values_types);
 234   free (pkg_values);
 235
 236   return (0);
 237 } /* int write_part_values */
 238
 239 static int write_part_number (char **ret_buffer, int *ret_buffer_len,
 240     int type, uint64_t value)
 241 {
 242   char *packet_ptr;
 243   int packet_len;
 244
 245   part_header_t pkg_head;
 246   uint64_t pkg_value;
 247
 248   int offset;
 249
 250   packet_len = sizeof (pkg_head) + sizeof (pkg_value);
 251
 252   if (*ret_buffer_len < packet_len)
 253     return (-1);
 254
 255   pkg_head.type = htons (type);
 256   pkg_head.length = htons (packet_len);
 257   pkg_value = htonll (value);
 258
 259   packet_ptr = *ret_buffer;
 260   offset = 0;
 261   memcpy (packet_ptr + offset, &pkg_head, sizeof (pkg_head));
 262   offset += sizeof (pkg_head);
 263   memcpy (packet_ptr + offset, &pkg_value, sizeof (pkg_value));
 264   offset += sizeof (pkg_value);
 265
 266   assert (offset == packet_len);
 267
 268   *ret_buffer = packet_ptr + packet_len;
 269   *ret_buffer_len -= packet_len;
 270
 271   return (0);
 272 } /* int write_part_number */
 273
 274 static int write_part_string (char **ret_buffer, int *ret_buffer_len,
 275     int type, const char *str, int str_len)
 276 {
 277   char *buffer;
 278   int buffer_len;
 279
 280   uint16_t pkg_type;
 281   uint16_t pkg_length;
 282
 283   int offset;
 284
 285   buffer_len = 2 * sizeof (uint16_t) + str_len + 1;
 286   if (*ret_buffer_len < buffer_len)
 287     return (-1);
 288
 289   pkg_type = htons (type);
 290   pkg_length = htons (buffer_len);
 291
 292   buffer = *ret_buffer;
 293   offset = 0;
 294   memcpy (buffer + offset, (void *) &pkg_type, sizeof (pkg_type));
 295   offset += sizeof (pkg_type);
 296   memcpy (buffer + offset, (void *) &pkg_length, sizeof (pkg_length));
 297   offset += sizeof (pkg_length);
 298   memcpy (buffer + offset, str, str_len);
 299   offset += str_len;
 300   memset (buffer + offset, '\0', 1);
 301   offset += 1;
 302
 303   assert (offset == buffer_len);
 304
 305   *ret_buffer = buffer + buffer_len;
 306   *ret_buffer_len -= buffer_len;
 307
 308   return (0);
 309 } /* int write_part_string */
 310
 311 static int parse_part_values (void **ret_buffer, size_t *ret_buffer_len,
 312     value_t **ret_values, int *ret_num_values)
 313 {
 314   char *buffer = *ret_buffer;
 315   size_t buffer_len = *ret_buffer_len;
 316
 317   uint16_t tmp16;
 318   size_t exp_size;
 319   int   i;
 320
 321   uint16_t pkg_length;
 322   uint16_t pkg_type;
 323   uint16_t pkg_numval;
 324
 325   uint8_t *pkg_types;
 326   value_t *pkg_values;
 327
 328   if (buffer_len < 15)
 329   {
 330     NOTICE ("network plugin: packet is too short: "
 331         "buffer_len = %zu", buffer_len);
 332     return (-1);
 333   }
 334
 335   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 336   buffer += sizeof (tmp16);
 337   pkg_type = ntohs (tmp16);
 338
 339   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 340   buffer += sizeof (tmp16);
 341   pkg_length = ntohs (tmp16);
 342
 343   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 344   buffer += sizeof (tmp16);
 345   pkg_numval = ntohs (tmp16);
 346
 347   assert (pkg_type == TYPE_VALUES);
 348
 349   exp_size = 3 * sizeof (uint16_t)
 350     + pkg_numval * (sizeof (uint8_t) + sizeof (value_t));
 351   if ((buffer_len < 0) || (buffer_len < exp_size))
 352   {
 353     WARNING ("network plugin: parse_part_values: "
 354         "Packet too short: "
 355         "Chunk of size %zu expected, "
 356         "but buffer has only %zu bytes left.",
 357         exp_size, buffer_len);
 358     return (-1);
 359   }
 360
 361   if (pkg_length != exp_size)
 362   {
 363     WARNING ("network plugin: parse_part_values: "
 364         "Length and number of values "
 365         "in the packet don't match.");
 366     return (-1);
 367   }
 368
 369   pkg_types = (uint8_t *) malloc (pkg_numval * sizeof (uint8_t));
 370   pkg_values = (value_t *) malloc (pkg_numval * sizeof (value_t));
 371   if ((pkg_types == NULL) || (pkg_values == NULL))
 372   {
 373     sfree (pkg_types);
 374     sfree (pkg_values);
 375     ERROR ("network plugin: parse_part_values: malloc failed.");
 376     return (-1);
 377   }
 378
 379   memcpy ((void *) pkg_types, (void *) buffer, pkg_numval * sizeof (uint8_t));
 380   buffer += pkg_numval * sizeof (uint8_t);
 381   memcpy ((void *) pkg_values, (void *) buffer, pkg_numval * sizeof (value_t));
 382   buffer += pkg_numval * sizeof (value_t);
 383
 384   for (i = 0; i < pkg_numval; i++)
 385   {
 386     switch (pkg_types[i])
 387     {
 388       case DS_TYPE_COUNTER:
 389         pkg_values[i].counter = (counter_t) ntohll (pkg_values[i].counter);
 390         break;
 391
 392       case DS_TYPE_GAUGE:
 393         pkg_values[i].gauge = (gauge_t) ntohd (pkg_values[i].gauge);
 394         break;
 395
 396       case DS_TYPE_DERIVE:
 397         pkg_values[i].derive = (derive_t) ntohll (pkg_values[i].derive);
 398         break;
 399
 400       case DS_TYPE_ABSOLUTE:
 401         pkg_values[i].absolute = (absolute_t) ntohll (pkg_values[i].absolute);
 402         break;
 403
 404       default:
 405         NOTICE ("network plugin: parse_part_values: "
 406       "Don't know how to handle data source type %"PRIu8,
 407       pkg_types[i]);
 408         sfree (pkg_types);
 409         sfree (pkg_values);
 410         return (-1);
 411     } /* switch (pkg_types[i]) */
 412   }
 413
 414   *ret_buffer     = buffer;
 415   *ret_buffer_len = buffer_len - pkg_length;
 416   *ret_num_values = pkg_numval;
 417   *ret_values     = pkg_values;
 418
 419   sfree (pkg_types);
 420
 421   return (0);
 422 } /* int parse_part_values */
 423
 424 static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
 425     value_list_t *vl_def,
 426     const data_set_t *ds, const value_list_t *vl)
 427 {
 428   char *buffer_orig = buffer;
 429
 430   if (write_part_string (&buffer, &buffer_size, TYPE_HOST, vl->host, strlen (vl->host)) != 0)
 431     return (-1);
 432
 433   if (write_part_number (&buffer, &buffer_size, TYPE_TIME, (uint64_t) vl->time))
 434     return (-1);
 435
 436   if (write_part_number (&buffer, &buffer_size, TYPE_INTERVAL, (uint64_t) vl->interval))
 437     return (-1);
 438
 439   if (write_part_string (&buffer, &buffer_size, TYPE_PLUGIN, vl->plugin, strlen (vl->plugin)) != 0)
 440     return (-1);
 441
 442   if (write_part_string (&buffer, &buffer_size, TYPE_PLUGIN_INSTANCE, vl->plugin_instance, strlen (vl->plugin_instance)) != 0)
 443     return (-1);
 444
 445   if (write_part_string (&buffer, &buffer_size, TYPE_TYPE, vl->type, strlen (vl->type)) != 0)
 446     return (-1);
 447
 448   if (write_part_string (&buffer, &buffer_size, TYPE_TYPE_INSTANCE, vl->type_instance, strlen (vl->type_instance)) != 0)
 449     return (-1);
 450
 451   if (write_part_values (&buffer, &buffer_size, ds, vl) != 0)
 452     return (-1);
 453
 454   return (buffer - buffer_orig);
 455 } /* }}} int add_to_buffer */
 456
 457 static int parse_part_number (void **ret_buffer, size_t *ret_buffer_len,
 458     uint64_t *value)
 459 {
 460   char *buffer = *ret_buffer;
 461   size_t buffer_len = *ret_buffer_len;
 462
 463   uint16_t tmp16;
 464   uint64_t tmp64;
 465   size_t exp_size = 2 * sizeof (uint16_t) + sizeof (uint64_t);
 466
 467   uint16_t pkg_length;
 468   uint16_t pkg_type;
 469
 470   if ((buffer_len < 0) || ((size_t) buffer_len < exp_size))
 471   {
 472     WARNING ("network plugin: parse_part_number: "
 473         "Packet too short: "
 474         "Chunk of size %zu expected, "
 475         "but buffer has only %zu bytes left.",
 476         exp_size, buffer_len);
 477     return (-1);
 478   }
 479
 480   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 481   buffer += sizeof (tmp16);
 482   pkg_type = ntohs (tmp16);
 483
 484   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 485   buffer += sizeof (tmp16);
 486   pkg_length = ntohs (tmp16);
 487
 488   memcpy ((void *) &tmp64, buffer, sizeof (tmp64));
 489   buffer += sizeof (tmp64);
 490   *value = ntohll (tmp64);
 491
 492   *ret_buffer = buffer;
 493   *ret_buffer_len = buffer_len - pkg_length;
 494
 495   return (0);
 496 } /* int parse_part_number */
 497
 498 static int parse_part_string (void **ret_buffer, size_t *ret_buffer_len,
 499     char *output, int output_len)
 500 {
 501   char *buffer = *ret_buffer;
 502   size_t buffer_len = *ret_buffer_len;
 503
 504   uint16_t tmp16;
 505   size_t header_size = 2 * sizeof (uint16_t);
 506
 507   uint16_t pkg_length;
 508   uint16_t pkg_type;
 509
 510   if ((buffer_len < 0) || (buffer_len < header_size))
 511   {
 512     WARNING ("network plugin: parse_part_string: "
 513         "Packet too short: "
 514         "Chunk of at least size %zu expected, "
 515         "but buffer has only %zu bytes left.",
 516         header_size, buffer_len);
 517     return (-1);
 518   }
 519
 520   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 521   buffer += sizeof (tmp16);
 522   pkg_type = ntohs (tmp16);
 523
 524   memcpy ((void *) &tmp16, buffer, sizeof (tmp16));
 525   buffer += sizeof (tmp16);
 526   pkg_length = ntohs (tmp16);
 527
 528   /* Check that packet fits in the input buffer */
 529   if (pkg_length > buffer_len)
 530   {
 531     WARNING ("network plugin: parse_part_string: "
 532         "Packet too big: "
 533         "Chunk of size %"PRIu16" received, "
 534         "but buffer has only %zu bytes left.",
 535         pkg_length, buffer_len);
 536     return (-1);
 537   }
 538
 539   /* Check that pkg_length is in the valid range */
 540   if (pkg_length <= header_size)
 541   {
 542     WARNING ("network plugin: parse_part_string: "
 543         "Packet too short: "
 544         "Header claims this packet is only %hu "
 545         "bytes long.", pkg_length);
 546     return (-1);
 547   }
 548
 549   /* Check that the package data fits into the output buffer.
 550    * The previous if-statement ensures that:
 551    * `pkg_length > header_size' */
 552   if ((output_len < 0)
 553       || ((size_t) output_len < ((size_t) pkg_length - header_size)))
 554   {
 555     WARNING ("network plugin: parse_part_string: "
 556         "Output buffer too small.");
 557     return (-1);
 558   }
 559
 560   /* All sanity checks successfull, let's copy the data over */
 561   output_len = pkg_length - header_size;
 562   memcpy ((void *) output, (void *) buffer, output_len);
 563   buffer += output_len;
 564
 565   /* For some very weird reason '\0' doesn't do the trick on SPARC in
 566    * this statement. */
 567   if (output[output_len - 1] != 0)
 568   {
 569     WARNING ("network plugin: parse_part_string: "
 570         "Received string does not end "
 571         "with a NULL-byte.");
 572     return (-1);
 573   }
 574
 575   *ret_buffer = buffer;
 576   *ret_buffer_len = buffer_len - pkg_length;
 577
 578   return (0);
 579 } /* int parse_part_string */
 580
 581
 582 static int parse_packet (void *se, /* {{{ */
 583     void *buffer, size_t buffer_size, int flags,
 584     const char *username)
 585 {
 586   int status;
 587
 588   value_list_t vl = VALUE_LIST_INIT;
 589   notification_t n;
 590
 591 #if HAVE_LIBGCRYPT
 592   int packet_was_signed = (flags & PP_SIGNED);
 593         int packet_was_encrypted = (flags & PP_ENCRYPTED);
 594   int printed_ignore_warning = 0;
 595 #endif /* HAVE_LIBGCRYPT */
 596
 597
 598   memset (&vl, '\0', sizeof (vl));
 599   memset (&n, '\0', sizeof (n));
 600   status = 0;
 601
 602   while ((status == 0) && (0 < buffer_size)
 603       && ((unsigned int) buffer_size > sizeof (part_header_t)))
 604   {
 605     uint16_t pkg_length;
 606     uint16_t pkg_type;
 607
 608     memcpy ((void *) &pkg_type,
 609         (void *) buffer,
 610         sizeof (pkg_type));
 611     memcpy ((void *) &pkg_length,
 612         (void *) (buffer + sizeof (pkg_type)),
 613         sizeof (pkg_length));
 614
 615     pkg_length = ntohs (pkg_length);
 616     pkg_type = ntohs (pkg_type);
 617
 618     if (pkg_length > buffer_size)
 619       break;
 620     /* Ensure that this loop terminates eventually */
 621     if (pkg_length < (2 * sizeof (uint16_t)))
 622       break;
 623
 624     if (pkg_type == TYPE_ENCR_AES256)
 625     {
 626       // status = parse_part_encr_aes256 (se,
 627       //     &buffer, &buffer_size, flags);
 628       // if (status != 0)
 629       // {
 630         ERROR ("network plugin: Decrypting AES256 "
 631             "part failed "
 632             "with status %i.", status);
 633         break;
 634       // }
 635     }
 636 #if HAVE_LIBGCRYPT
 637     else if ((se->data.server.security_level == SECURITY_LEVEL_ENCRYPT)
 638         && (packet_was_encrypted == 0))
 639     {
 640       if (printed_ignore_warning == 0)
 641       {
 642         INFO ("network plugin: Unencrypted packet or "
 643             "part has been ignored.");
 644         printed_ignore_warning = 1;
 645       }
 646       buffer = ((char *) buffer) + pkg_length;
 647       continue;
 648     }
 649 #endif /* HAVE_LIBGCRYPT */
 650     else if (pkg_type == TYPE_SIGN_SHA256)
 651     {
 652       // status = parse_part_sign_sha256 (se,
 653       //                                   &buffer, &buffer_size, flags);
 654       // if (status != 0)
 655       // {
 656         ERROR ("network plugin: Verifying HMAC-SHA-256 "
 657             "signature failed "
 658             "with status %i.", status);
 659         break;
 660       // }
 661     }
 662 #if HAVE_LIBGCRYPT
 663     else if ((se->data.server.security_level == SECURITY_LEVEL_SIGN)
 664         && (packet_was_encrypted == 0)
 665         && (packet_was_signed == 0))
 666     {
 667       if (printed_ignore_warning == 0)
 668       {
 669         INFO ("network plugin: Unsigned packet or "
 670             "part has been ignored.");
 671         printed_ignore_warning = 1;
 672       }
 673       buffer = ((char *) buffer) + pkg_length;
 674       continue;
 675     }
 676 #endif /* HAVE_LIBGCRYPT */
 677     else if (pkg_type == TYPE_VALUES)
 678     {
 679       status = parse_part_values (&buffer, &buffer_size,
 680           &vl.values, &vl.values_len);
 681       if (status != 0)
 682         break;
 683
 684       network_dispatch_values (&vl, username);
 685
 686       sfree (vl.values);
 687     }
 688     else if (pkg_type == TYPE_TIME)
 689     {
 690       uint64_t tmp = 0;
 691       status = parse_part_number (&buffer, &buffer_size,
 692           &tmp);
 693       if (status == 0)
 694       {
 695         vl.time = (time_t) tmp;
 696         n.time = (time_t) tmp;
 697       }
 698     }
 699     else if (pkg_type == TYPE_INTERVAL)
 700     {
 701       uint64_t tmp = 0;
 702       status = parse_part_number (&buffer, &buffer_size,
 703           &tmp);
 704       if (status == 0)
 705         vl.interval = (int) tmp;
 706     }
 707     else if (pkg_type == TYPE_HOST)
 708     {
 709       status = parse_part_string (&buffer, &buffer_size,
 710           vl.host, sizeof (vl.host));
 711       if (status == 0)
 712         sstrncpy (n.host, vl.host, sizeof (n.host));
 713     }
 714     else if (pkg_type == TYPE_PLUGIN)
 715     {
 716       status = parse_part_string (&buffer, &buffer_size,
 717           vl.plugin, sizeof (vl.plugin));
 718       if (status == 0)
 719         sstrncpy (n.plugin, vl.plugin,
 720             sizeof (n.plugin));
 721     }
 722     else if (pkg_type == TYPE_PLUGIN_INSTANCE)
 723     {
 724       status = parse_part_string (&buffer, &buffer_size,
 725           vl.plugin_instance,
 726           sizeof (vl.plugin_instance));
 727       if (status == 0)
 728         sstrncpy (n.plugin_instance,
 729             vl.plugin_instance,
 730             sizeof (n.plugin_instance));
 731     }
 732     else if (pkg_type == TYPE_TYPE)
 733     {
 734       status = parse_part_string (&buffer, &buffer_size,
 735           vl.type, sizeof (vl.type));
 736       if (status == 0)
 737         sstrncpy (n.type, vl.type, sizeof (n.type));
 738     }
 739     else if (pkg_type == TYPE_TYPE_INSTANCE)
 740     {
 741       status = parse_part_string (&buffer, &buffer_size,
 742           vl.type_instance,
 743           sizeof (vl.type_instance));
 744       if (status == 0)
 745         sstrncpy (n.type_instance, vl.type_instance,
 746             sizeof (n.type_instance));
 747     }
 748     else if (pkg_type == TYPE_MESSAGE)
 749     {
 750       status = parse_part_string (&buffer, &buffer_size,
 751           n.message, sizeof (n.message));
 752
 753       if (status != 0)
 754       {
 755         /* do nothing */
 756       }
 757       else if ((n.severity != NOTIF_FAILURE)
 758           && (n.severity != NOTIF_WARNING)
 759           && (n.severity != NOTIF_OKAY))
 760       {
 761         INFO ("network plugin: "
 762             "Ignoring notification with "
 763             "unknown severity %i.",
 764             n.severity);
 765       }
 766       else if (n.time <= 0)
 767       {
 768         INFO ("network plugin: "
 769             "Ignoring notification with "
 770             "time == 0.");
 771       }
 772       else if (strlen (n.message) <= 0)
 773       {
 774         INFO ("network plugin: "
 775             "Ignoring notification with "
 776             "an empty message.");
 777       }
 778       else
 779       {
 780         plugin_dispatch_notification (&n);
 781       }
 782     }
 783     else if (pkg_type == TYPE_SEVERITY)
 784     {
 785       uint64_t tmp = 0;
 786       status = parse_part_number (&buffer, &buffer_size,
 787           &tmp);
 788       if (status == 0)
 789         n.severity = (int) tmp;
 790     }
 791     else
 792     {
 793       DEBUG ("network plugin: parse_packet: Unknown part"
 794           " type: 0x%04hx", pkg_type);
 795       buffer = ((char *) buffer) + pkg_length;
 796     }
 797   } /* while (buffer_size > sizeof (part_header_t)) */
 798
 799   if (status == 0 && buffer_size > 0)
 800     WARNING ("network plugin: parse_packet: Received truncated "
 801         "packet, try increasing `MaxPacketSize'");
 802
 803   return (status);
 804 } /* }}} int parse_packet */
 805