src/lwes_event.c

   1 /*======================================================================*
   2  * Copyright (C) 2008 Light Weight Event System                         *
   3  * All rights reserved.                                                 *
   4  *                                                                      *
   5  * This program is free software; you can redistribute it and/or modify *
   6  * it under the terms of the GNU General Public License as published by *
   7  * the Free Software Foundation; either version 2 of the License, or    *
   8  * (at your option) any later version.                                  *
   9  *                                                                      *
  10  * This program is distributed in the hope that it will be useful,      *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
  13  * GNU General Public License for more details.                         *
  14  *                                                                      *
  15  * You should have received a copy of the GNU General Public License    *
  16  * along with this program; if not, write to the Free Software          *
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                   *
  18  * Boston, MA 02110-1301 USA.                                           *
  19  *======================================================================*/
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <arpa/inet.h>
  24 #include <limits.h>
  25 #include <errno.h>
  26
  27 #include "lwes_event.h"
  28 #include "lwes_hash.h"
  29 #include "lwes_marshall_functions.h"
  30
  31 /*************************************************************************
  32   PRIVATE API prototypes, shouldn't be called by a user of the library.
  33  *************************************************************************/
  34
  35 /* Create the memory for an event attribute */
  36 static struct lwes_event_attribute *
  37 lwes_event_attribute_create
  38   (LWES_BYTE attrType,
  39    void *    attrValue);
  40
  41 static int
  42 lwes_event_add
  43   (struct lwes_event*       event,
  44    LWES_CONST_SHORT_STRING  attrNameIn,
  45    LWES_BYTE                attrType,
  46    void*                    attrValue);
  47
  48 int
  49 lwes_INT_64_from_hex_string
  50   (const char *buffer,
  51    LWES_INT_64* an_int64);
  52
  53 int
  54 lwes_U_INT_64_from_hex_string
  55   (const char *buffer,
  56    LWES_U_INT_64* a_uint64);
  57
  58 /*************************************************************************
  59   PUBLIC API
  60  *************************************************************************/
  61 struct lwes_event *
  62 lwes_event_create_no_name
  63   (struct lwes_event_type_db *db)
  64 {
  65   struct lwes_event *event =
  66      (struct lwes_event *)malloc (sizeof (struct lwes_event));
  67
  68   if (event == NULL)
  69     {
  70       return NULL;
  71     }
  72
  73   event->eventName            = NULL;
  74   event->number_of_attributes = 0;
  75   event->type_db              = db;
  76   event->attributes           = lwes_hash_create ();
  77   if (event->attributes == NULL)
  78     {
  79       free(event);
  80       return NULL;
  81     }
  82
  83   return event;
  84 }
  85
  86 /* PUBLIC : Create the memory for an event */
  87 struct lwes_event *
  88 lwes_event_create
  89   (struct lwes_event_type_db *db,
  90    LWES_CONST_SHORT_STRING name)
  91 {
  92   struct lwes_event *event;
  93
  94   if (name == NULL)
  95     {
  96       return NULL;
  97     }
  98
  99   event = (struct lwes_event *)malloc (sizeof (struct lwes_event));
 100
 101   if (event == NULL)
 102     {
 103       return NULL;
 104     }
 105
 106   event->eventName            = NULL;
 107   event->number_of_attributes = 0;
 108   event->type_db              = db;
 109   event->attributes           = lwes_hash_create ();
 110   if (event->attributes == NULL)
 111     {
 112       free(event);
 113       return NULL;
 114     }
 115
 116   if (lwes_event_set_name (event,name) < 0)
 117     {
 118       /* Having problems, bail and return NULL */
 119       lwes_hash_destroy (event->attributes);
 120       free (event);
 121       return NULL;
 122     }
 123
 124   return event;
 125 }
 126
 127 struct lwes_event *
 128 lwes_event_create_with_encoding
 129   (struct lwes_event_type_db *db,
 130    LWES_CONST_SHORT_STRING name,
 131    LWES_INT_16 encoding)
 132 {
 133   struct lwes_event *event;
 134
 135   if (name == NULL)
 136     {
 137       return NULL;
 138     }
 139
 140   event = (struct lwes_event *)malloc(sizeof(struct lwes_event));
 141
 142   if (event == NULL)
 143     {
 144       return NULL;
 145     }
 146
 147   event->eventName            = NULL;
 148   event->number_of_attributes = 0;
 149   event->type_db              = db;
 150   event->attributes           = lwes_hash_create ();
 151
 152   if (event->attributes == NULL)
 153     {
 154       free (event);
 155       return NULL;
 156     }
 157
 158   if (lwes_event_set_name(event,name) < 0)
 159     {
 160       /* Having memory problems, bail */
 161       lwes_hash_destroy (event->attributes);
 162       free (event);
 163       return NULL;
 164     }
 165
 166   if (lwes_event_set_encoding (event,encoding) < 0)
 167     {
 168       /* problem setting encoding, free up memory and bail */
 169       lwes_hash_destroy (event->attributes);
 170       if (event->eventName != NULL)
 171         {
 172           free (event->eventName);
 173         }
 174       free (event);
 175       return NULL;
 176     }
 177
 178   return event;
 179 }
 180
 181 int
 182 lwes_event_set_name
 183   (struct lwes_event *event,
 184    LWES_CONST_SHORT_STRING name)
 185 {
 186   if (event == NULL || name == NULL || event->eventName != NULL)
 187     {
 188       return -1;
 189     }
 190
 191   event->eventName =
 192     (LWES_SHORT_STRING) malloc (sizeof (LWES_CHAR)*(strlen (name)+1));
 193
 194   if (event->eventName == NULL)
 195     {
 196       return -3;
 197     }
 198
 199   strcpy (event->eventName,name);
 200
 201   return 0;
 202 }
 203
 204 int
 205 lwes_event_set_encoding
 206   (struct lwes_event *event,
 207    LWES_INT_16 encoding)
 208 {
 209   LWES_INT_16 tmp_encoding;
 210
 211   if (event == NULL)
 212     {
 213       return -1;
 214     }
 215
 216   if ( lwes_event_get_INT_16 (event, LWES_ENCODING, &tmp_encoding) == -1 )
 217     {
 218       return lwes_event_set_INT_16 (event, LWES_ENCODING, encoding);
 219     }
 220   return -1;
 221 }
 222
 223
 224 int
 225 lwes_event_get_name
 226   (struct lwes_event *event, LWES_SHORT_STRING *name)
 227 {
 228   if (event == NULL || name == NULL)
 229     {
 230       return -1;
 231     }
 232   *name = event->eventName;
 233   return 0;
 234 }
 235
 236 int
 237 lwes_event_get_number_of_attributes
 238   (struct lwes_event *event,
 239    LWES_U_INT_16 *number)
 240 {
 241   if (event == NULL || number == NULL)
 242     {
 243       return -1;
 244     }
 245   *number = event->number_of_attributes;
 246   return 0;
 247 }
 248
 249 int
 250 lwes_event_get_encoding
 251   (struct lwes_event *event,
 252    LWES_INT_16 *encoding)
 253 {
 254   if (event == NULL || encoding == NULL)
 255     {
 256       return -1;
 257     }
 258
 259   return lwes_event_get_INT_16 (event,
 260                                 (LWES_SHORT_STRING)LWES_ENCODING,
 261                                 encoding);
 262 }
 263
 264 /* PUBLIC : Cleanup the memory for an event */
 265 int
 266 lwes_event_destroy
 267   (struct lwes_event *event)
 268 {
 269   struct lwes_event_attribute *tmp = NULL;
 270   struct lwes_hash_enumeration e;
 271
 272   if (event == NULL)
 273     {
 274       return 0;
 275     }
 276
 277   /* free the parts of the event */
 278   if (event->eventName != NULL)
 279     {
 280       free(event->eventName);
 281     }
 282
 283   /* clear out the hash */
 284   if (lwes_hash_keys (event->attributes, &e))
 285     {
 286       while (lwes_hash_enumeration_has_more_elements (&e))
 287         {
 288           LWES_SHORT_STRING tmpAttrName =
 289             lwes_hash_enumeration_next_element (&e);
 290           tmp =
 291             (struct lwes_event_attribute *)lwes_hash_remove (event->attributes,
 292                                                              tmpAttrName);
 293           /* free the attribute name and value*/
 294           if (tmpAttrName != NULL)
 295             {
 296               free(tmpAttrName);
 297             }
 298           if (tmp->value != NULL)
 299             {
 300               free(tmp->value);
 301             }
 302           /* free the attribute itself*/
 303           if (tmp != NULL)
 304             {
 305               free(tmp);
 306             }
 307         }
 308     }
 309
 310   /* free the now empty hash */
 311   lwes_hash_destroy (event->attributes);
 312
 313   /* finally free the event structure */
 314   free (event);
 315
 316   return 0;
 317 }
 318
 319 /* PUBLIC : serialize the event and put it into a byte array */
 320 int
 321 lwes_event_to_bytes
 322   (struct lwes_event *event,
 323    LWES_BYTE_P bytes,
 324    size_t num_bytes,
 325    size_t offset)
 326 {
 327   struct lwes_event_attribute *tmp;
 328   struct lwes_event_attribute *encodingAttr;
 329   size_t tmpOffset = offset;
 330   struct lwes_hash_enumeration e;
 331   int ret = 0;
 332
 333   if (   event == NULL
 334       || bytes == NULL
 335       || num_bytes == 0
 336       || offset >= num_bytes)
 337     {
 338       return -1;
 339     }
 340
 341   /* start with the event name */
 342   if (marshall_SHORT_STRING (event->eventName,
 343                               bytes,
 344                               num_bytes,
 345                               &tmpOffset))
 346     {
 347       /* then the number of attributes */
 348       if (marshall_U_INT_16     (event->number_of_attributes,
 349                                   bytes,
 350                                   num_bytes,
 351                                   &tmpOffset))
 352         {
 353           /* handle encoding first if it is set */
 354           encodingAttr =
 355             (struct lwes_event_attribute *)
 356               lwes_hash_get (event->attributes,
 357                              (LWES_SHORT_STRING)LWES_ENCODING);
 358
 359           if (encodingAttr)
 360             {
 361               void* encodingValue = encodingAttr->value;
 362               LWES_BYTE encodingType = encodingAttr->type;
 363               if (encodingValue)
 364                 {
 365                   if (encodingType == LWES_INT_16_TOKEN)
 366                     {
 367                       if (marshall_SHORT_STRING
 368                             ((LWES_SHORT_STRING)LWES_ENCODING,
 369                              bytes,
 370                              num_bytes,
 371                              &tmpOffset) == 0
 372                           ||
 373                           marshall_BYTE
 374                             (encodingType,
 375                              bytes,
 376                              num_bytes,
 377                              &tmpOffset) == 0
 378                           ||
 379                           marshall_INT_16
 380                             (*((LWES_INT_16 *)encodingValue),
 381                              bytes,
 382                              num_bytes,
 383                              &tmpOffset) == 0)
 384                         {
 385                           return -2;
 386                         }
 387                     }
 388                   else
 389                     {
 390                       return -3;
 391                     }
 392                 }
 393               else
 394                 {
 395                   return -4;
 396                 }
 397             }
 398
 399           /* now iterate over all the other values in the hash */
 400           if (lwes_hash_keys (event->attributes, &e))
 401             {
 402               while (lwes_hash_enumeration_has_more_elements (&e) && ret == 0)
 403                 {
 404                   LWES_SHORT_STRING tmpAttrName =
 405                     lwes_hash_enumeration_next_element (&e);
 406
 407                   /* skip encoding as we've dealt with it above */
 408                   if (! strcmp(tmpAttrName, LWES_ENCODING))
 409                     {
 410                       continue;
 411                     }
 412
 413                   tmp =
 414                     (struct lwes_event_attribute *)
 415                       lwes_hash_get (event->attributes, tmpAttrName);
 416
 417                   if (marshall_SHORT_STRING (tmpAttrName,
 418                                              bytes,
 419                                              num_bytes,
 420                                              &tmpOffset) == 0)
 421                     {
 422                       ret = -5;
 423                     }
 424                   else
 425                     {
 426                       if (marshall_BYTE (tmp->type,
 427                                          bytes,
 428                                          num_bytes,
 429                                          &tmpOffset) == 0)
 430                         {
 431                           ret = -6;
 432                         }
 433                       else
 434                         {
 435                           if (tmp->type == LWES_U_INT_16_TOKEN)
 436                             {
 437                               if (marshall_U_INT_16 (*((LWES_U_INT_16 *)tmp->value),
 438                                                      bytes,
 439                                                      num_bytes,
 440                                                      &tmpOffset) == 0)
 441                                 {
 442                                   ret = -7;
 443                                 }
 444                             }
 445                           else if (tmp->type == LWES_INT_16_TOKEN)
 446                             {
 447                               if (marshall_INT_16 (*((LWES_INT_16 *)tmp->value),
 448                                                    bytes,
 449                                                    num_bytes,
 450                                                    &tmpOffset) == 0)
 451                                 {
 452                                   ret = -8;
 453                                 }
 454                             }
 455                           else if (tmp->type == LWES_U_INT_32_TOKEN)
 456                             {
 457                               if (marshall_U_INT_32 (*((LWES_U_INT_32 *)tmp->value),
 458                                                      bytes,
 459                                                      num_bytes,
 460                                                      &tmpOffset) == 0)
 461                                 {
 462                                   ret = -9;
 463                                 }
 464                             }
 465                           else if (tmp->type == LWES_INT_32_TOKEN)
 466                             {
 467                               if (marshall_INT_32 (*((LWES_INT_32 *)tmp->value),
 468                                                    bytes,
 469                                                    num_bytes,
 470                                                    &tmpOffset) == 0)
 471                                 {
 472                                   ret = -10;
 473                                 }
 474                             }
 475                           else if (tmp->type == LWES_U_INT_64_TOKEN)
 476                             {
 477                               if (marshall_U_INT_64 (*((LWES_U_INT_64 *)tmp->value),
 478                                                      bytes,
 479                                                      num_bytes,
 480                                                      &tmpOffset) == 0)
 481                                 {
 482                                   ret = -11;
 483                                 }
 484                             }
 485                           else if (tmp->type == LWES_INT_64_TOKEN)
 486                             {
 487                               if (marshall_INT_64 (*((LWES_INT_64 *)tmp->value),
 488                                                    bytes,
 489                                                    num_bytes,
 490                                                    &tmpOffset) == 0)
 491                                 {
 492                                   ret = -12;
 493                                 }
 494                             }
 495                           else if (tmp->type == LWES_BOOLEAN_TOKEN)
 496                             {
 497                               if (marshall_BOOLEAN (*((LWES_BOOLEAN *)tmp->value),
 498                                                     bytes,
 499                                                     num_bytes,
 500                                                     &tmpOffset) == 0)
 501                                 {
 502                                   ret = -13;
 503                                 }
 504                             }
 505                           else if (tmp->type == LWES_IP_ADDR_TOKEN)
 506                             {
 507                               if (marshall_IP_ADDR (*((LWES_IP_ADDR *)tmp->value),
 508                                                     bytes,
 509                                                     num_bytes,
 510                                                     &tmpOffset) == 0)
 511                                 {
 512                                   ret = -14;
 513                                 }
 514                             }
 515                           else if (tmp->type == LWES_STRING_TOKEN)
 516                             {
 517                               if (marshall_LONG_STRING ((LWES_LONG_STRING)tmp->value,
 518                                                         bytes,
 519                                                         num_bytes,
 520                                                         &tmpOffset) == 0)
 521                                 {
 522                                   ret = -15;
 523                                 }
 524                             }
 525                           else
 526                             {
 527                               /* should never be reached, but if it does,
 528                                * there's some sort of  corruption with this
 529                                * attribute of the event, so skip it */
 530                             }
 531                         }
 532                     }
 533                 }
 534             }
 535         }
 536       else
 537         {
 538           ret = -16;
 539         }
 540     }
 541   else
 542     {
 543       ret = -17;
 544     }
 545
 546   return ((ret < 0) ? ret : (int)(tmpOffset-offset));
 547 }
 548
 549 /* PUBLIC : deserialize the event from a byte array and into an event */
 550 int
 551 lwes_event_from_bytes
 552   (struct lwes_event *event,
 553    LWES_BYTE_P bytes,
 554    size_t num_bytes,
 555    size_t offset,
 556    struct lwes_event_deserialize_tmp *dtmp)
 557 {
 558   int i;
 559   LWES_U_INT_16 tmp_number_of_attributes = 0;
 560   size_t tmpOffset = offset;
 561
 562   LWES_BYTE         tmp_byte;
 563   LWES_U_INT_16     tmp_uint16;
 564   LWES_INT_16       tmp_int16;
 565   LWES_U_INT_32     tmp_uint32;
 566   LWES_INT_32       tmp_int32;
 567   LWES_U_INT_64     tmp_uint64;
 568   LWES_INT_64       tmp_int64;
 569   LWES_BOOLEAN      tmp_boolean;
 570   LWES_IP_ADDR      tmp_ip_addr;
 571   LWES_SHORT_STRING tmp_short_str;
 572   LWES_LONG_STRING  tmp_long_str;
 573
 574   if (   event == NULL
 575       || bytes == NULL
 576       || num_bytes == 0
 577       || offset >= num_bytes
 578       || dtmp == NULL)
 579     {
 580       return -1;
 581     }
 582
 583   tmp_short_str = dtmp->tmp_string;
 584   tmp_long_str  = dtmp->tmp_string_long;
 585
 586   /* unmarshall the event name */
 587   if (unmarshall_SHORT_STRING (tmp_short_str,
 588                                 (SHORT_STRING_MAX+1),
 589                                 bytes,
 590                                 num_bytes,
 591                                 &tmpOffset))
 592     {
 593       /* copies the data out of tmp_short_str */
 594       if (lwes_event_set_name (event, tmp_short_str) == 0)
 595         {
 596           /* unmarshall the number of elements */
 597           if (unmarshall_U_INT_16 (&tmp_uint16,bytes,num_bytes,&tmpOffset))
 598             {
 599               tmp_number_of_attributes = tmp_uint16;
 600
 601               for (i = 0; i < tmp_number_of_attributes; i++)
 602                 {
 603                   /* unmarshall the attribute name */
 604                   if (unmarshall_SHORT_STRING (tmp_short_str,
 605                                                 (SHORT_STRING_MAX+1),
 606                                                 bytes,
 607                                                 num_bytes,
 608                                                 &tmpOffset))
 609                     {
 610                       /* unmarshall the type id */
 611                       if (unmarshall_BYTE         (&tmp_byte,
 612                                                     bytes,
 613                                                     num_bytes,
 614                                                     &tmpOffset))
 615                         {
 616                           if (tmp_byte == LWES_U_INT_16_TOKEN)
 617                             {
 618                               if (unmarshall_U_INT_16     (&tmp_uint16,
 619                                                             bytes,
 620                                                             num_bytes,
 621                                                             &tmpOffset))
 622                                 {
 623                                   if (lwes_event_set_U_INT_16 (event,
 624                                                                 tmp_short_str,
 625                                                                 tmp_uint16)
 626                                        < 0)
 627                                     {
 628                                       return -2;
 629                                     }
 630                                 }
 631                               else
 632                                 {
 633                                   return -3;
 634                                 }
 635                             }
 636                           else if (tmp_byte == LWES_INT_16_TOKEN)
 637                             {
 638                               if (unmarshall_INT_16       (&tmp_int16,
 639                                                             bytes,
 640                                                             num_bytes,
 641                                                             &tmpOffset))
 642                                 {
 643                                   if (lwes_event_set_INT_16   (event,
 644                                                                 tmp_short_str,
 645                                                                 tmp_int16)
 646                                        < 0)
 647                                     {
 648                                       return -4;
 649                                     }
 650                                  }
 651                               else
 652                                 {
 653                                   return -5;
 654                                 }
 655                             }
 656                           else if (tmp_byte == LWES_U_INT_32_TOKEN)
 657                             {
 658                               if (unmarshall_U_INT_32     (&tmp_uint32,
 659                                                             bytes,
 660                                                             num_bytes,
 661                                                             &tmpOffset))
 662                                 {
 663                                   if (lwes_event_set_U_INT_32 (event,
 664                                                                 tmp_short_str,
 665                                                                 tmp_uint32)
 666                                        < 0)
 667                                     {
 668                                       return -6;
 669                                     }
 670                                 }
 671                               else
 672                                 {
 673                                   return -7;
 674                                 }
 675                             }
 676                           else if (tmp_byte == LWES_INT_32_TOKEN)
 677                             {
 678                               if (unmarshall_INT_32       (&tmp_int32,
 679                                                             bytes,
 680                                                             num_bytes,
 681                                                             &tmpOffset))
 682                                 {
 683                                   if (lwes_event_set_INT_32   (event,
 684                                                                 tmp_short_str,
 685                                                                 tmp_int32)
 686                                        < 0)
 687                                     {
 688                                       return -8;
 689                                     }
 690                                 }
 691                               else
 692                                 {
 693                                   return -9;
 694                                 }
 695                             }
 696                           else if (tmp_byte == LWES_U_INT_64_TOKEN)
 697                             {
 698                               if (unmarshall_U_INT_64     (&tmp_uint64,
 699                                                             bytes,
 700                                                             num_bytes,
 701                                                             &tmpOffset))
 702                                 {
 703                                   if (lwes_event_set_U_INT_64 (event,
 704                                                                 tmp_short_str,
 705                                                                 tmp_uint64)
 706                                        < 0)
 707                                     {
 708                                       return -10;
 709                                     }
 710                                 }
 711                               else
 712                                 {
 713                                   return -11;
 714                                 }
 715                             }
 716                           else if (tmp_byte == LWES_INT_64_TOKEN)
 717                             {
 718                               if (unmarshall_INT_64         (&tmp_int64,
 719                                                               bytes,
 720                                                               num_bytes,
 721                                                               &tmpOffset))
 722                                 {
 723                                   if (lwes_event_set_INT_64     (event,
 724                                                                   tmp_short_str,
 725                                                                   tmp_int64)
 726                                        < 0)
 727                                     {
 728                                       return -12;
 729                                     }
 730                                 }
 731                               else
 732                                 {
 733                                   return -13;
 734                                 }
 735                             }
 736                           else if (tmp_byte == LWES_BOOLEAN_TOKEN)
 737                             {
 738                               if (unmarshall_BOOLEAN        (&tmp_boolean,
 739                                                               bytes,
 740                                                               num_bytes,
 741                                                               &tmpOffset))
 742                                 {
 743                                   if (lwes_event_set_BOOLEAN    (event,
 744                                                                   tmp_short_str,
 745                                                                   tmp_boolean)
 746                                        < 0)
 747                                     {
 748                                       return -14;
 749                                     }
 750                                 }
 751                               else
 752                                 {
 753                                   return -15;
 754                                 }
 755                             }
 756                           else if (tmp_byte == LWES_IP_ADDR_TOKEN)
 757                             {
 758                               if (unmarshall_IP_ADDR        (&tmp_ip_addr,
 759                                                               bytes,
 760                                                               num_bytes,
 761                                                               &tmpOffset))
 762                                 {
 763                                   if (lwes_event_set_IP_ADDR (event,
 764                                                                tmp_short_str,
 765                                                                tmp_ip_addr)
 766                                        < 0)
 767                                     {
 768                                       return -16;
 769                                     }
 770                                 }
 771                               else
 772                                 {
 773                                   return -17;
 774                                 }
 775                             }
 776                           else if (tmp_byte == LWES_STRING_TOKEN)
 777                             {
 778                               if (unmarshall_LONG_STRING (tmp_long_str,
 779                                                            (LONG_STRING_MAX+1),
 780                                                            bytes,
 781                                                            num_bytes,
 782                                                            &tmpOffset))
 783                                 {
 784                                   if (lwes_event_set_STRING (event,
 785                                                               tmp_short_str,
 786                                                               tmp_long_str)
 787                                        < 0)
 788                                     {
 789                                       return -18;
 790                                     }
 791                                 }
 792                               else
 793                                 {
 794                                   return -19;
 795                                 }
 796                             }
 797                           else
 798                             {
 799                               return -20;
 800                             }
 801                         }
 802                       else
 803                         {
 804                           return -21;
 805                         }
 806                     }
 807                   else
 808                     {
 809                       return -22;
 810                     }
 811                 }
 812             }
 813           else
 814             {
 815               return -23;
 816             }
 817         }
 818       else
 819         {
 820           return -24;
 821         }
 822      }
 823    else
 824      {
 825        return -25;
 826      }
 827
 828   return (int)(tmpOffset-offset);
 829 }
 830
 831 int lwes_event_set_U_INT_16 (struct lwes_event *       event,
 832                              LWES_CONST_SHORT_STRING   attrName,
 833                              LWES_U_INT_16             value)
 834 {
 835   int ret = 0;
 836   LWES_U_INT_16 *attrValue;
 837
 838   if (event == NULL || attrName == NULL)
 839     {
 840       return -1;
 841     }
 842
 843   attrValue = (LWES_U_INT_16 *)malloc (sizeof (LWES_U_INT_16));
 844
 845   if (attrValue == NULL)
 846     {
 847       return -3;
 848     }
 849   *attrValue = value;
 850
 851   ret = lwes_event_add (event, attrName, LWES_U_INT_16_TOKEN, attrValue);
 852   if (ret < 0)
 853     {
 854       free (attrValue);
 855     }
 856   return ret;
 857 }
 858
 859 int lwes_event_set_INT_16 (struct lwes_event *       event,
 860                            LWES_CONST_SHORT_STRING   attrName,
 861                            LWES_INT_16               value)
 862 {
 863   int ret = 0;
 864   LWES_INT_16 *attrValue;
 865
 866   if (event == NULL || attrName == NULL)
 867     {
 868       return -1;
 869     }
 870
 871   attrValue = (LWES_INT_16 *)malloc (sizeof (LWES_INT_16));
 872
 873   if (attrValue == NULL)
 874     {
 875       return -3;
 876     }
 877   *attrValue = value;
 878
 879   ret = lwes_event_add (event, attrName, LWES_INT_16_TOKEN, attrValue);
 880   if (ret < 0)
 881     {
 882       free(attrValue);
 883     }
 884   return ret;
 885 }
 886
 887 int lwes_event_set_U_INT_32 (struct lwes_event *       event,
 888                              LWES_CONST_SHORT_STRING   attrName,
 889                              LWES_U_INT_32             value)
 890 {
 891   int ret = 0;
 892   LWES_U_INT_32 *attrValue;
 893
 894   if (event == NULL || attrName == NULL)
 895     {
 896       return -1;
 897     }
 898
 899   attrValue = (LWES_U_INT_32 *)malloc(sizeof(LWES_U_INT_32));
 900
 901   if (attrValue == NULL)
 902     {
 903       return -3;
 904     }
 905   *attrValue = value;
 906
 907   ret = lwes_event_add (event, attrName, LWES_U_INT_32_TOKEN, attrValue);
 908   if (ret < 0)
 909     {
 910       free (attrValue);
 911     }
 912   return ret;
 913 }
 914
 915 int lwes_event_set_INT_32 (struct lwes_event *       event,
 916                            LWES_CONST_SHORT_STRING   attrName,
 917                            LWES_INT_32               value)
 918 {
 919   int ret = 0;
 920   LWES_INT_32 *attrValue;
 921
 922   if (event == NULL || attrName == NULL)
 923     {
 924       return -1;
 925     }
 926
 927   attrValue = (LWES_INT_32 *)malloc (sizeof (LWES_INT_32));
 928
 929   if (attrValue == NULL)
 930     {
 931       return -3;
 932     }
 933   *attrValue = value;
 934
 935   ret = lwes_event_add (event, attrName, LWES_INT_32_TOKEN, attrValue);
 936   if (ret < 0)
 937     {
 938       free(attrValue);
 939     }
 940   return ret;
 941 }
 942
 943 int lwes_event_set_U_INT_64 (struct lwes_event *       event,
 944                              LWES_CONST_SHORT_STRING   attrName,
 945                              LWES_U_INT_64             value)
 946 {
 947   int ret = 0;
 948   LWES_U_INT_64 *attrValue;
 949
 950   if (event == NULL || attrName == NULL)
 951     {
 952       return -1;
 953     }
 954
 955   attrValue = (LWES_U_INT_64 *)malloc (sizeof (LWES_U_INT_64));
 956
 957   if (attrValue == NULL)
 958     {
 959       return -3;
 960     }
 961   *attrValue = value;
 962
 963   ret = lwes_event_add (event, attrName, LWES_U_INT_64_TOKEN, attrValue);
 964   if (ret < 0)
 965     {
 966       free (attrValue);
 967     }
 968   return ret;
 969 }
 970
 971 int lwes_event_set_U_INT_64_w_string (struct lwes_event *     event,
 972                                       LWES_CONST_SHORT_STRING attrName,
 973                                       LWES_CONST_SHORT_STRING uint64_string)
 974 {
 975   LWES_INT_64 u_int_64;
 976   if (event == NULL || attrName == NULL || uint64_string == NULL)
 977     {
 978       return -1;
 979     }
 980   if (lwes_INT_64_from_hex_string (uint64_string, &u_int_64) < 0)
 981     {
 982       return -2;
 983     }
 984   return lwes_event_set_U_INT_64 (event, attrName, u_int_64);
 985 }
 986
 987 int lwes_event_set_INT_64 (struct lwes_event *       event,
 988                            LWES_CONST_SHORT_STRING   attrName,
 989                            LWES_INT_64               value)
 990 {
 991   int ret = 0;
 992   LWES_INT_64 *attrValue;
 993
 994   if (event == NULL || attrName == NULL)
 995     {
 996       return -1;
 997     }
 998
 999   attrValue = (LWES_INT_64 *)malloc (sizeof (LWES_INT_64));
1000
1001   if (attrValue == NULL)
1002     {
1003       return -3;
1004     }
1005   *attrValue = value;
1006
1007   ret = lwes_event_add (event, attrName, LWES_INT_64_TOKEN, attrValue);
1008   if (ret < 0)
1009     {
1010       free (attrValue);
1011     }
1012   return ret;
1013 }
1014
1015 int lwes_event_set_INT_64_w_string (struct lwes_event       *event,
1016                                     LWES_CONST_SHORT_STRING  attrName,
1017                                     LWES_CONST_SHORT_STRING  int64_string)
1018 {
1019   LWES_INT_64 int_64;
1020
1021   if (event == NULL || attrName == NULL || int64_string == NULL)
1022     {
1023       return -1;
1024     }
1025
1026   if (lwes_INT_64_from_hex_string (int64_string,&int_64) < 0)
1027     {
1028       return -2;
1029     }
1030   return lwes_event_set_INT_64 (event, attrName, int_64);
1031 }
1032
1033 int lwes_event_set_STRING (struct lwes_event *       event,
1034                            LWES_CONST_SHORT_STRING   attrName,
1035                            LWES_CONST_LONG_STRING    value)
1036 {
1037   int ret = 0;
1038   LWES_LONG_STRING attrValue;
1039
1040   if (event == NULL || attrName == NULL || value == NULL)
1041     {
1042       return -1;
1043     }
1044
1045   attrValue = (LWES_LONG_STRING)malloc (sizeof (LWES_CHAR)*(strlen (value)+1));
1046   if (attrValue == NULL)
1047     {
1048       return -3;
1049     }
1050   strcpy(attrValue,value);
1051
1052   ret = lwes_event_add (event, attrName, LWES_STRING_TOKEN, (void*)attrValue);
1053   if (ret < 0)
1054     {
1055       free (attrValue);
1056     }
1057   return ret;
1058 }
1059
1060 int lwes_event_set_IP_ADDR (struct lwes_event *       event,
1061                             LWES_CONST_SHORT_STRING   attrName,
1062                             LWES_IP_ADDR              value)
1063 {
1064   int ret = 0;
1065   LWES_IP_ADDR *attrValue;
1066
1067   if (event == NULL || attrName == NULL)
1068     {
1069       return -1;
1070     }
1071
1072   attrValue = (LWES_IP_ADDR *)malloc (sizeof (LWES_IP_ADDR));
1073
1074   if (attrValue == NULL)
1075     {
1076       return -3;
1077     }
1078   *attrValue = value;
1079
1080   ret = lwes_event_add (event, attrName, LWES_IP_ADDR_TOKEN, attrValue);
1081   if (ret < 0)
1082     {
1083       free (attrValue);
1084     }
1085   return ret;
1086 }
1087
1088 int lwes_event_set_IP_ADDR_w_string (struct lwes_event *       event,
1089                                      LWES_CONST_SHORT_STRING   attrName,
1090                                      LWES_CONST_SHORT_STRING  value)
1091 {
1092   int ret = 0;
1093   struct in_addr *attrValue;
1094
1095   if (event == NULL || attrName == NULL || value == NULL)
1096     {
1097       return -1;
1098     }
1099
1100   attrValue = (LWES_IP_ADDR *)malloc (sizeof (LWES_IP_ADDR));
1101   if (attrValue == NULL)
1102     {
1103       return -3;
1104     }
1105   attrValue->s_addr = inet_addr (value);
1106
1107   ret = lwes_event_add (event, attrName, LWES_IP_ADDR_TOKEN, attrValue);
1108   if (ret < 0)
1109     {
1110       free (attrValue);
1111     }
1112   return ret;
1113 }
1114
1115 int lwes_event_set_BOOLEAN (struct lwes_event       * event,
1116                             LWES_CONST_SHORT_STRING   attrName,
1117                             LWES_BOOLEAN              value)
1118 {
1119   int ret = 0;
1120   LWES_BOOLEAN *attrValue;
1121
1122   if (event == NULL || attrName == NULL)
1123     {
1124       return -1;
1125     }
1126
1127   attrValue = (LWES_BOOLEAN *)malloc (sizeof (LWES_BOOLEAN));
1128   if (attrValue == NULL)
1129     {
1130       return -3;
1131     }
1132   *attrValue = value;
1133
1134   ret = lwes_event_add (event, attrName, LWES_BOOLEAN_TOKEN, attrValue);
1135   if (ret < 0)
1136     {
1137       free (attrValue);
1138     }
1139   return ret;
1140 }
1141
1142
1143 /* ACCESSOR METHODS */
1144
1145 int lwes_event_get_U_INT_16 (struct lwes_event       *event,
1146                              LWES_CONST_SHORT_STRING  name,
1147                              LWES_U_INT_16           *value)
1148 {
1149   struct lwes_event_attribute *tmp;
1150
1151   if (event == NULL || name == NULL || value == NULL)
1152     {
1153       return -1;
1154     }
1155
1156   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1157
1158   if (tmp)
1159     {
1160       *value = (*((LWES_U_INT_16 *)tmp->value));
1161       return 0;
1162     }
1163
1164   return -1;
1165 }
1166
1167 int lwes_event_get_INT_16 (struct lwes_event       *event,
1168                            LWES_CONST_SHORT_STRING  name,
1169                            LWES_INT_16             *value)
1170 {
1171   struct lwes_event_attribute *tmp;
1172
1173   if (event == NULL || name == NULL || value == NULL)
1174     {
1175       return -1;
1176     }
1177
1178   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1179
1180   if (tmp)
1181     {
1182       *value = (*((LWES_INT_16 *)tmp->value));
1183       return 0;
1184     }
1185   return -1;
1186 }
1187
1188 int lwes_event_get_U_INT_32 (struct lwes_event       *event,
1189                              LWES_CONST_SHORT_STRING  name,
1190                              LWES_U_INT_32           *value)
1191 {
1192   struct lwes_event_attribute *tmp;
1193
1194   if (event == NULL || name == NULL || value == NULL)
1195     {
1196       return -1;
1197     }
1198
1199   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1200
1201   if (tmp)
1202     {
1203       *value = (*((LWES_U_INT_32 *)tmp->value));
1204       return 0;
1205     }
1206
1207   return -1;
1208 }
1209
1210 int lwes_event_get_INT_32 (struct lwes_event       *event,
1211                            LWES_CONST_SHORT_STRING  name,
1212                            LWES_INT_32             *value)
1213 {
1214   struct lwes_event_attribute *tmp;
1215
1216   if (event == NULL || name == NULL || value == NULL)
1217     {
1218       return -1;
1219     }
1220
1221   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1222
1223   if (tmp)
1224     {
1225       *value = (*((LWES_INT_32 *)tmp->value));
1226       return 0;
1227     }
1228
1229   return -1;
1230 }
1231
1232 int lwes_event_get_U_INT_64 (struct lwes_event       *event,
1233                              LWES_CONST_SHORT_STRING  name,
1234                              LWES_U_INT_64           *value)
1235 {
1236   struct lwes_event_attribute *tmp;
1237
1238   if (event == NULL || name == NULL || value == NULL)
1239     {
1240       return -1;
1241     }
1242
1243   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1244
1245   if (tmp)
1246     {
1247       *value = (*((LWES_U_INT_64 *)tmp->value));
1248       return 0;
1249     }
1250
1251   return -1;
1252 }
1253
1254 int lwes_event_get_INT_64 (struct lwes_event       *event,
1255                            LWES_CONST_SHORT_STRING  name,
1256                            LWES_INT_64             *value)
1257 {
1258   struct lwes_event_attribute *tmp;
1259
1260   if (event == NULL || name == NULL || value == NULL)
1261     {
1262       return -1;
1263     }
1264
1265   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1266
1267   if (tmp)
1268     {
1269       *value = (*((LWES_INT_64 *)tmp->value));
1270       return 0;
1271     }
1272
1273   return -1;
1274 }
1275
1276 int lwes_event_get_STRING (struct lwes_event       *event,
1277                            LWES_CONST_SHORT_STRING  name,
1278                            LWES_LONG_STRING        *value)
1279 {
1280   struct lwes_event_attribute *tmp;
1281
1282   if (event == NULL || name == NULL || value == NULL)
1283     {
1284       return -1;
1285     }
1286
1287   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1288
1289   if (tmp)
1290     {
1291       *value = (((LWES_LONG_STRING)tmp->value));
1292       return 0;
1293     }
1294
1295   return -1;
1296 }
1297 int lwes_event_get_IP_ADDR (struct lwes_event       *event,
1298                             LWES_CONST_SHORT_STRING  name,
1299                             LWES_IP_ADDR            *value)
1300 {
1301   struct lwes_event_attribute *tmp;
1302
1303   if (event == NULL || name == NULL || value == NULL)
1304     {
1305       return -1;
1306     }
1307
1308   tmp = (struct lwes_event_attribute *)lwes_hash_get (event->attributes, name);
1309
1310   if (tmp)
1311     {
1312       *value = (*((LWES_IP_ADDR *)tmp->value));
1313       return 0;
1314     }
1315   return -1;
1316 }
1317
1318 int lwes_event_get_BOOLEAN (struct lwes_event       *event,
1319                             LWES_CONST_SHORT_STRING  name,
1320                             LWES_BOOLEAN            *value)
1321 {
1322   struct lwes_event_attribute *tmp;
1323
1324   if (event == NULL || name == NULL || value == NULL)
1325     {
1326       return -1;
1327     }
1328
1329   tmp = (struct lwes_event_attribute *)lwes_hash_get(event->attributes, name);
1330
1331   if (tmp)
1332     {
1333       *value = (*((LWES_BOOLEAN *)tmp->value));
1334       return 0;
1335     }
1336   return -1;
1337 }
1338
1339 /*************************************************************************
1340   PRIVATE API
1341  *************************************************************************/
1342 /* Create the memory for an attribute */
1343 static struct lwes_event_attribute *
1344 lwes_event_attribute_create (LWES_BYTE attrType, void *attrValue)
1345 {
1346   struct lwes_event_attribute *attribute =
1347     (struct lwes_event_attribute *)
1348       malloc (sizeof (struct lwes_event_attribute));
1349
1350   if (attribute == NULL)
1351     {
1352       return NULL;
1353     }
1354
1355   attribute->type  = attrType;
1356   attribute->value = attrValue;
1357
1358   return attribute;
1359 }
1360
1361 /* add an attribute to an event */
1362 static int
1363 lwes_event_add (struct lwes_event*       event,
1364                 LWES_CONST_SHORT_STRING  attrNameIn,
1365                 LWES_BYTE                attrType,
1366                 void*                    attrValue)
1367 {
1368   struct lwes_event_attribute* attribute = NULL;
1369   LWES_SHORT_STRING            attrName  = NULL;
1370   int ret                                = 0;
1371
1372   /* check against the event db */
1373   if (event->type_db != NULL
1374        && lwes_event_type_db_check_for_attribute (event->type_db,
1375                                                   attrNameIn,
1376                                                   event->eventName) == 0)
1377     {
1378       return -1;
1379     }
1380   if (event->type_db != NULL
1381        && lwes_event_type_db_check_for_type (event->type_db,
1382                                              attrType,
1383                                              attrNameIn,
1384                                              event->eventName) == 0)
1385     {
1386       return -2;
1387     }
1388
1389   /* copy the attribute name */
1390   attrName =
1391       (LWES_SHORT_STRING) malloc( sizeof(LWES_CHAR)*(strlen (attrNameIn)+1));
1392   if (attrName == NULL)
1393     {
1394       return -3;
1395     }
1396   attrName[0] = '\0';
1397   strcat (attrName,attrNameIn);
1398
1399   /* create the attribute */
1400   attribute = lwes_event_attribute_create (attrType, attrValue);
1401   if (attribute == NULL)
1402     {
1403       free (attrName);
1404       return -3;
1405     }
1406
1407   /* Try and put something into the hash */
1408   ret = lwes_hash_put (event->attributes, attrName, attribute);
1409
1410   /* return code greater than or equal to 0 is okay, so increment the
1411    * number_of_attributes, otherwise, send out the failure value
1412    */
1413   if (ret < 0)
1414     {
1415       free (attribute);
1416       free (attrName);
1417       return ret;
1418     }
1419   event->number_of_attributes++;
1420
1421   return event->number_of_attributes;
1422 }
1423
1424 int
1425 lwes_U_INT_64_from_hex_string
1426   (const char *buffer,
1427    LWES_U_INT_64* a_uint64)
1428 {
1429   char *endptr;
1430
1431   /* manpage for strtoull suggests setting errno to zero then checking
1432    * for error afterwards
1433    */
1434   errno = 0;
1435   *a_uint64 = strtoull (buffer, &endptr, 16);
1436
1437   /* it's considered an error if it overflows (ie, errno is ERANGE)
1438    * or if the entire string is not used (ie, in_length is greater than
1439    * out_length)
1440    */
1441   if (errno == ERANGE
1442       || ((int)strlen (buffer) > (int)(endptr - buffer)))
1443     {
1444       return -1;
1445     }
1446
1447   return 0;
1448 }
1449
1450 int
1451 lwes_INT_64_from_hex_string
1452   (const char *buffer,
1453    LWES_INT_64* an_int64)
1454 {
1455   /*
1456    * totally bogus, but on freebsd strtoll for hex can not reach the
1457    * maximum hex value of 0xffffffffffffffff, so instead I use
1458    * strtoull which does reach the upper range, and then cast
1459    */
1460   LWES_U_INT_64 a_uint64;
1461   int ret;
1462
1463   ret = lwes_U_INT_64_from_hex_string (buffer, &a_uint64);
1464
1465   if (ret < 0)
1466     {
1467       return ret;
1468     }
1469
1470   *an_int64 = (LWES_INT_64)a_uint64;
1471
1472   return 0;
1473 }
1474
1475 int
1476 lwes_event_keys
1477   (struct lwes_event * event,
1478    struct lwes_event_enumeration *enumeration)
1479 {
1480   return lwes_hash_keys (event->attributes, &(enumeration->hash_enum));
1481 }
1482
1483 int
1484 lwes_event_enumeration_next_element
1485   (struct lwes_event_enumeration *enumeration,
1486    LWES_CONST_SHORT_STRING *key,
1487    LWES_TYPE *type)
1488 {
1489   LWES_SHORT_STRING tmpAttrName =
1490      lwes_hash_enumeration_next_element (&(enumeration->hash_enum));
1491   (*key) = NULL;
1492   (*type) = LWES_TYPE_UNDEFINED;
1493
1494   if ( tmpAttrName != NULL)
1495     {
1496       struct lwes_event_attribute *tmp =
1497          (struct lwes_event_attribute *)
1498            lwes_hash_get (enumeration->hash_enum.enum_hash, (tmpAttrName));
1499       if (tmp != NULL)
1500         {
1501           (*type) = (LWES_TYPE) (tmp->type);
1502           (*key) = tmpAttrName;
1503           return 1;
1504         }
1505     }
1506   return 0;
1507 }
1508
1509