src/lwes_listener.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 "lwes_listener.h"
  21 #include "lwes_event.h"
  22 #include "lwes_time_functions.h"
  23 #include "lwes_marshall_functions.h"
  24
  25 struct lwes_listener *
  26 lwes_listener_create
  27   (LWES_SHORT_STRING address,
  28    LWES_SHORT_STRING iface,
  29    LWES_U_INT_32 port)
  30 {
  31   struct lwes_listener *listener =
  32     (struct lwes_listener *) malloc (sizeof (struct lwes_listener));
  33
  34   if ( listener == NULL )
  35     {
  36       return NULL;
  37     }
  38
  39   /* I originally was allocating on the stack, but that fails on freebsd,
  40      so I'll malloc and free this here */
  41   listener->buffer = (LWES_BYTE_P) malloc (sizeof (LWES_BYTE)*MAX_MSG_SIZE);
  42
  43   if ( listener->buffer == NULL )
  44     {
  45       if ( listener != NULL )
  46         free (listener);
  47       return NULL;
  48     }
  49
  50   listener->dtmp =
  51     (struct lwes_event_deserialize_tmp *)
  52       malloc (sizeof (struct lwes_event_deserialize_tmp));
  53   if ( listener->dtmp == NULL )
  54     {
  55       if ( listener->buffer != NULL )
  56         free (listener->buffer);
  57       if ( listener != NULL )
  58         free (listener);
  59       return NULL;
  60     }
  61
  62   if ( (lwes_net_open (&(listener->connection),address,iface,port) != 0) ||
  63        (lwes_net_recv_bind (&(listener->connection)) != 0) )
  64     {
  65       if ( listener->dtmp != NULL )
  66         free (listener->dtmp);
  67       if ( listener->buffer != NULL )
  68         free (listener->buffer);
  69       if ( listener != NULL )
  70         free (listener);
  71       return NULL;
  72     }
  73
  74   return listener;
  75 }
  76
  77 int
  78 lwes_listener_add_header_fields
  79   (struct lwes_listener *listener,
  80    LWES_BYTE_P bytes,
  81    size_t max,
  82    size_t *len)
  83 {
  84   size_t n = *len;
  85   size_t offset_to_num_attrs;
  86   size_t tmp_offset;
  87   LWES_U_INT_16 num_attrs;
  88   LWES_INT_64 receipt_time;
  89   LWES_IP_ADDR sender_ip;
  90   LWES_U_INT_16 sender_port;
  91
  92   /* grab some information from the packet and add it to the event */
  93   receipt_time = currentTimeMillisLongLong();
  94   sender_ip    = listener->connection.sender_ip_addr.sin_addr;
  95   sender_port  = ntohs (listener->connection.sender_ip_addr.sin_port);
  96
  97   /* deserialize the event name */
  98   offset_to_num_attrs = 0;
  99   if (unmarshall_SHORT_STRING (listener->dtmp->tmp_string,
 100                                (SHORT_STRING_MAX+1),
 101                                bytes,
 102                                max,
 103                                &offset_to_num_attrs) == 0)
 104     {
 105       return -1;
 106     }
 107
 108   /* keep track of offset of the number of attributes since
 109      we will change it */
 110   tmp_offset = offset_to_num_attrs;
 111   if (unmarshall_U_INT_16     (&num_attrs,
 112                                bytes,
 113                                max,
 114                                &tmp_offset) == 0)
 115     {
 116       return -2;
 117     }
 118
 119   /* add receipt time to the event */
 120   if (   marshall_SHORT_STRING   ((LWES_SHORT_STRING)"ReceiptTime",
 121                                   bytes,
 122                                   max,
 123                                   &n) == 0
 124       || marshall_BYTE           (LWES_INT_64_TOKEN,
 125                                   bytes,
 126                                   max,
 127                                   &n) == 0
 128       || marshall_INT_64         (receipt_time,
 129                                   bytes,
 130                                   max,
 131                                   &n) == 0)
 132     {
 133       return -3;
 134     }
 135   ++num_attrs;
 136
 137   /* add sender ip to the event */
 138   if (   marshall_SHORT_STRING   ((LWES_SHORT_STRING)"SenderIP",
 139                                   bytes,
 140                                   max,
 141                                   &n) == 0
 142       || marshall_BYTE           (LWES_IP_ADDR_TOKEN,
 143                                   bytes,
 144                                   max,
 145                                   &n) == 0
 146       ||  marshall_IP_ADDR       (sender_ip,
 147                                   bytes,
 148                                   max,
 149                                   &n) == 0)
 150     {
 151       return -4;
 152     }
 153   ++num_attrs;
 154
 155   /* add sender port to the event */
 156   if (    marshall_SHORT_STRING   ((LWES_SHORT_STRING)"SenderPort",
 157                                    bytes,
 158                                    max,
 159                                    &n) == 0
 160        || marshall_BYTE           (LWES_U_INT_16_TOKEN,
 161                                    bytes,
 162                                    max,
 163                                    &n) == 0
 164        || marshall_U_INT_16       (sender_port,
 165                                    bytes,
 166                                    max,
 167                                    &n) == 0)
 168     {
 169       return -5;
 170     }
 171   ++num_attrs;
 172
 173   /* finally put the new number of attributes into the appropriate place */
 174   if (marshall_U_INT_16      (num_attrs,
 175                               bytes,
 176                               max,
 177                               &offset_to_num_attrs) == 0)
 178     {
 179       return -6;
 180     }
 181
 182   *len = n;
 183   return 0;
 184 }
 185
 186 int
 187 lwes_listener_event_has_name
 188   (LWES_BYTE_P bytes,
 189    size_t len,
 190    LWES_CONST_SHORT_STRING name)
 191 {
 192   size_t serialized_name_len;
 193
 194   /* NULL bytes is an error */
 195   if (bytes == NULL)
 196     {
 197       return -1;
 198     }
 199
 200   /* minimum length is 1 byte of length and one character, so length
 201      should be at least 2 */
 202   if (len < 2)
 203     {
 204       return -1;
 205     }
 206
 207   /* event name must be non null */
 208   if (name == NULL)
 209     {
 210       return -1;
 211     }
 212
 213   /* first byte is the length */
 214   serialized_name_len = (LWES_BYTE)bytes[0];
 215
 216   /* compare the lengths of the serialized and passed in names */
 217   if (serialized_name_len != strlen (name))
 218     {
 219       return -1;
 220     }
 221
 222   /* finally compare the names themselves */
 223
 224   /* name is offset by one byte */
 225   return memcmp ((const unsigned char *)&(bytes[1]), name, strlen (name));
 226 }
 227
 228
 229 /* FIXME: Make private in next major release of lwes */
 230 int
 231 lwes_listener_recv_process_event
 232   (struct lwes_listener *listener,
 233    struct lwes_event *event,
 234    int len)
 235 {
 236   size_t n = len;
 237   int ret;
 238   if ((ret = lwes_listener_add_header_fields (listener,
 239                                               listener->buffer,
 240                                               MAX_MSG_SIZE,
 241                                               &n)) < 0)
 242     {
 243       return ret;
 244     }
 245
 246    return lwes_event_from_bytes
 247             (event, listener->buffer, n, 0, listener->dtmp );
 248 }
 249
 250 int
 251 lwes_listener_recv
 252   (struct lwes_listener *listener,
 253    struct lwes_event *event)
 254 {
 255   int n;
 256
 257   if ( (n = lwes_listener_recv_bytes (listener,
 258                                       listener->buffer,
 259                                       MAX_MSG_SIZE)) < 0 )
 260     {
 261       return n;
 262     }
 263
 264   return lwes_listener_recv_process_event (listener, event, n);
 265 }
 266
 267 int
 268 lwes_listener_recv_by
 269   (struct lwes_listener *listener,
 270    struct lwes_event *event,
 271    unsigned int timeout_ms)
 272 {
 273   int n;
 274
 275   if ( (n = lwes_listener_recv_bytes_by (listener,
 276                                          listener->buffer,
 277                                          MAX_MSG_SIZE,
 278                                          timeout_ms)) < 0 )
 279     {
 280       return n;
 281     }
 282
 283   return lwes_listener_recv_process_event (listener, event, n);
 284 }
 285
 286
 287 int
 288 lwes_listener_recv_bytes
 289   (struct lwes_listener *listener,
 290    LWES_BYTE_P bytes,
 291    size_t max)
 292 {
 293   int n = 0;
 294
 295   if ((n = lwes_net_recv_bytes (&(listener->connection),
 296                                 bytes,
 297                                 max)) < 0 )
 298     {
 299       return -2;
 300     }
 301
 302   return n;
 303 }
 304
 305 int
 306 lwes_listener_recv_bytes_by
 307   (struct lwes_listener *listener,
 308    LWES_BYTE_P bytes,
 309    size_t max,
 310    unsigned int timeout_ms)
 311 {
 312   int n = 0;
 313
 314   if ((n = lwes_net_recv_bytes_by (&(listener->connection),
 315                                    bytes,
 316                                    max,
 317                                    timeout_ms)) < 0 )
 318     {
 319       return -2;
 320     }
 321
 322   return n;
 323 }
 324
 325
 326 int
 327 lwes_listener_destroy
 328   (struct lwes_listener *listener)
 329 {
 330   int ret = 0;
 331
 332   ret = lwes_net_close (&(listener->connection));
 333
 334   if ( listener->buffer != NULL )
 335     free (listener->buffer);
 336   if ( listener->dtmp != NULL )
 337     free (listener->dtmp);
 338   if ( listener != NULL )
 339     free (listener);
 340
 341   return ret;
 342 }