src/lwes_event.c

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