third_party/libevent/event_tagging.c

   1 /*
   2  * Copyright (c) 2003, 2004 Niels Provos <provos@citi.umich.edu>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #ifdef HAVE_SYS_TYPES_H
  33 #include <sys/types.h>
  34 #endif
  35 #ifdef HAVE_SYS_PARAM_H
  36 #include <sys/param.h>
  37 #endif
  38
  39 #ifdef WIN32
  40 #define WIN32_LEAN_AND_MEAN
  41 #include <winsock2.h>
  42 #include <windows.h>
  43 #undef WIN32_LEAN_AND_MEAN
  44 #else
  45 #include <sys/ioctl.h>
  46 #endif
  47
  48 #include <sys/queue.h>
  49 #ifdef HAVE_SYS_TIME_H
  50 #include <sys/time.h>
  51 #endif
  52
  53 #include <errno.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #ifndef WIN32
  58 #include <syslog.h>
  59 #endif
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #endif
  63
  64 #include "event.h"
  65 #include "evutil.h"
  66 #include "log.h"
  67
  68 int evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf);
  69 int evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t tag);
  70 int evtag_decode_tag(ev_uint32_t *ptag, struct evbuffer *evbuf);
  71
  72 static struct evbuffer *_buf;   /* not thread safe */
  73
  74 void
  75 evtag_init(void)
  76 {
  77         if (_buf != NULL)
  78                 return;
  79
  80         if ((_buf = evbuffer_new()) == NULL)
  81                 event_err(1, "%s: malloc", __func__);
  82 }
  83
  84 /*
  85  * We encode integer's by nibbles; the first nibble contains the number
  86  * of significant nibbles - 1;  this allows us to encode up to 64-bit
  87  * integers.  This function is byte-order independent.
  88  */
  89
  90 void
  91 encode_int(struct evbuffer *evbuf, ev_uint32_t number)
  92 {
  93         int off = 1, nibbles = 0;
  94         ev_uint8_t data[5];
  95
  96         memset(data, 0, sizeof(ev_uint32_t)+1);
  97         while (number) {
  98                 if (off & 0x1)
  99                         data[off/2] = (data[off/2] & 0xf0) | (number & 0x0f);
 100                 else
 101                         data[off/2] = (data[off/2] & 0x0f) |
 102                             ((number & 0x0f) << 4);
 103                 number >>= 4;
 104                 off++;
 105         }
 106
 107         if (off > 2)
 108                 nibbles = off - 2;
 109
 110         /* Off - 1 is the number of encoded nibbles */
 111         data[0] = (data[0] & 0x0f) | ((nibbles & 0x0f) << 4);
 112
 113         evbuffer_add(evbuf, data, (off + 1) / 2);
 114 }
 115
 116 /*
 117  * Support variable length encoding of tags; we use the high bit in each
 118  * octet as a continuation signal.
 119  */
 120
 121 int
 122 evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t tag)
 123 {
 124         int bytes = 0;
 125         ev_uint8_t data[5];
 126
 127         memset(data, 0, sizeof(data));
 128         do {
 129                 ev_uint8_t lower = tag & 0x7f;
 130                 tag >>= 7;
 131
 132                 if (tag)
 133                         lower |= 0x80;
 134
 135                 data[bytes++] = lower;
 136         } while (tag);
 137
 138         if (evbuf != NULL)
 139                 evbuffer_add(evbuf, data, bytes);
 140
 141         return (bytes);
 142 }
 143
 144 static int
 145 decode_tag_internal(ev_uint32_t *ptag, struct evbuffer *evbuf, int dodrain)
 146 {
 147         ev_uint32_t number = 0;
 148         ev_uint8_t *data = EVBUFFER_DATA(evbuf);
 149         int len = EVBUFFER_LENGTH(evbuf);
 150         int count = 0, shift = 0, done = 0;
 151
 152         while (count++ < len) {
 153                 ev_uint8_t lower = *data++;
 154                 number |= (lower & 0x7f) << shift;
 155                 shift += 7;
 156
 157                 if (!(lower & 0x80)) {
 158                         done = 1;
 159                         break;
 160                 }
 161         }
 162
 163         if (!done)
 164                 return (-1);
 165
 166         if (dodrain)
 167                 evbuffer_drain(evbuf, count);
 168
 169         if (ptag != NULL)
 170                 *ptag = number;
 171
 172         return (count);
 173 }
 174
 175 int
 176 evtag_decode_tag(ev_uint32_t *ptag, struct evbuffer *evbuf)
 177 {
 178         return (decode_tag_internal(ptag, evbuf, 1 /* dodrain */));
 179 }
 180
 181 /*
 182  * Marshal a data type, the general format is as follows:
 183  *
 184  * tag number: one byte; length: var bytes; payload: var bytes
 185  */
 186
 187 void
 188 evtag_marshal(struct evbuffer *evbuf, ev_uint32_t tag,
 189     const void *data, ev_uint32_t len)
 190 {
 191         evtag_encode_tag(evbuf, tag);
 192         encode_int(evbuf, len);
 193         evbuffer_add(evbuf, (void *)data, len);
 194 }
 195
 196 /* Marshaling for integers */
 197 void
 198 evtag_marshal_int(struct evbuffer *evbuf, ev_uint32_t tag, ev_uint32_t integer)
 199 {
 200         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 201         encode_int(_buf, integer);
 202
 203         evtag_encode_tag(evbuf, tag);
 204         encode_int(evbuf, EVBUFFER_LENGTH(_buf));
 205         evbuffer_add_buffer(evbuf, _buf);
 206 }
 207
 208 void
 209 evtag_marshal_string(struct evbuffer *buf, ev_uint32_t tag, const char *string)
 210 {
 211         evtag_marshal(buf, tag, string, strlen(string));
 212 }
 213
 214 void
 215 evtag_marshal_timeval(struct evbuffer *evbuf, ev_uint32_t tag, struct timeval *tv)
 216 {
 217         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 218
 219         encode_int(_buf, tv->tv_sec);
 220         encode_int(_buf, tv->tv_usec);
 221
 222         evtag_marshal(evbuf, tag, EVBUFFER_DATA(_buf),
 223             EVBUFFER_LENGTH(_buf));
 224 }
 225
 226 static int
 227 decode_int_internal(ev_uint32_t *pnumber, struct evbuffer *evbuf, int dodrain)
 228 {
 229         ev_uint32_t number = 0;
 230         ev_uint8_t *data = EVBUFFER_DATA(evbuf);
 231         int len = EVBUFFER_LENGTH(evbuf);
 232         int nibbles = 0;
 233
 234         if (!len)
 235                 return (-1);
 236
 237         nibbles = ((data[0] & 0xf0) >> 4) + 1;
 238         if (nibbles > 8 || (nibbles >> 1) + 1 > len)
 239                 return (-1);
 240         len = (nibbles >> 1) + 1;
 241
 242         while (nibbles > 0) {
 243                 number <<= 4;
 244                 if (nibbles & 0x1)
 245                         number |= data[nibbles >> 1] & 0x0f;
 246                 else
 247                         number |= (data[nibbles >> 1] & 0xf0) >> 4;
 248                 nibbles--;
 249         }
 250
 251         if (dodrain)
 252                 evbuffer_drain(evbuf, len);
 253
 254         *pnumber = number;
 255
 256         return (len);
 257 }
 258
 259 int
 260 evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf)
 261 {
 262         return (decode_int_internal(pnumber, evbuf, 1) == -1 ? -1 : 0);
 263 }
 264
 265 int
 266 evtag_peek(struct evbuffer *evbuf, ev_uint32_t *ptag)
 267 {
 268         return (decode_tag_internal(ptag, evbuf, 0 /* dodrain */));
 269 }
 270
 271 int
 272 evtag_peek_length(struct evbuffer *evbuf, ev_uint32_t *plength)
 273 {
 274         struct evbuffer tmp;
 275         int res, len;
 276
 277         len = decode_tag_internal(NULL, evbuf, 0 /* dodrain */);
 278         if (len == -1)
 279                 return (-1);
 280
 281         tmp = *evbuf;
 282         tmp.buffer += len;
 283         tmp.off -= len;
 284
 285         res = decode_int_internal(plength, &tmp, 0);
 286         if (res == -1)
 287                 return (-1);
 288
 289         *plength += res + len;
 290
 291         return (0);
 292 }
 293
 294 int
 295 evtag_payload_length(struct evbuffer *evbuf, ev_uint32_t *plength)
 296 {
 297         struct evbuffer tmp;
 298         int res, len;
 299
 300         len = decode_tag_internal(NULL, evbuf, 0 /* dodrain */);
 301         if (len == -1)
 302                 return (-1);
 303
 304         tmp = *evbuf;
 305         tmp.buffer += len;
 306         tmp.off -= len;
 307
 308         res = decode_int_internal(plength, &tmp, 0);
 309         if (res == -1)
 310                 return (-1);
 311
 312         return (0);
 313 }
 314
 315 int
 316 evtag_consume(struct evbuffer *evbuf)
 317 {
 318         ev_uint32_t len;
 319         if (decode_tag_internal(NULL, evbuf, 1 /* dodrain */) == -1)
 320                 return (-1);
 321         if (evtag_decode_int(&len, evbuf) == -1)
 322                 return (-1);
 323         evbuffer_drain(evbuf, len);
 324
 325         return (0);
 326 }
 327
 328 /* Reads the data type from an event buffer */
 329
 330 int
 331 evtag_unmarshal(struct evbuffer *src, ev_uint32_t *ptag, struct evbuffer *dst)
 332 {
 333         ev_uint32_t len;
 334         ev_uint32_t integer;
 335
 336         if (decode_tag_internal(ptag, src, 1 /* dodrain */) == -1)
 337                 return (-1);
 338         if (evtag_decode_int(&integer, src) == -1)
 339                 return (-1);
 340         len = integer;
 341
 342         if (EVBUFFER_LENGTH(src) < len)
 343                 return (-1);
 344
 345         if (evbuffer_add(dst, EVBUFFER_DATA(src), len) == -1)
 346                 return (-1);
 347
 348         evbuffer_drain(src, len);
 349
 350         return (len);
 351 }
 352
 353 /* Marshaling for integers */
 354
 355 int
 356 evtag_unmarshal_int(struct evbuffer *evbuf, ev_uint32_t need_tag,
 357     ev_uint32_t *pinteger)
 358 {
 359         ev_uint32_t tag;
 360         ev_uint32_t len;
 361         ev_uint32_t integer;
 362
 363         if (decode_tag_internal(&tag, evbuf, 1 /* dodrain */) == -1)
 364                 return (-1);
 365         if (need_tag != tag)
 366                 return (-1);
 367         if (evtag_decode_int(&integer, evbuf) == -1)
 368                 return (-1);
 369         len = integer;
 370
 371         if (EVBUFFER_LENGTH(evbuf) < len)
 372                 return (-1);
 373
 374         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 375         if (evbuffer_add(_buf, EVBUFFER_DATA(evbuf), len) == -1)
 376                 return (-1);
 377
 378         evbuffer_drain(evbuf, len);
 379
 380         return (evtag_decode_int(pinteger, _buf));
 381 }
 382
 383 /* Unmarshal a fixed length tag */
 384
 385 int
 386 evtag_unmarshal_fixed(struct evbuffer *src, ev_uint32_t need_tag, void *data,
 387     size_t len)
 388 {
 389         ev_uint32_t tag;
 390
 391         /* Initialize this event buffer so that we can read into it */
 392         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 393
 394         /* Now unmarshal a tag and check that it matches the tag we want */
 395         if (evtag_unmarshal(src, &tag, _buf) == -1 || tag != need_tag)
 396                 return (-1);
 397
 398         if (EVBUFFER_LENGTH(_buf) != len)
 399                 return (-1);
 400
 401         memcpy(data, EVBUFFER_DATA(_buf), len);
 402         return (0);
 403 }
 404
 405 int
 406 evtag_unmarshal_string(struct evbuffer *evbuf, ev_uint32_t need_tag,
 407     char **pstring)
 408 {
 409         ev_uint32_t tag;
 410
 411         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 412
 413         if (evtag_unmarshal(evbuf, &tag, _buf) == -1 || tag != need_tag)
 414                 return (-1);
 415
 416         *pstring = calloc(EVBUFFER_LENGTH(_buf) + 1, 1);
 417         if (*pstring == NULL)
 418                 event_err(1, "%s: calloc", __func__);
 419         evbuffer_remove(_buf, *pstring, EVBUFFER_LENGTH(_buf));
 420
 421         return (0);
 422 }
 423
 424 int
 425 evtag_unmarshal_timeval(struct evbuffer *evbuf, ev_uint32_t need_tag,
 426     struct timeval *ptv)
 427 {
 428         ev_uint32_t tag;
 429         ev_uint32_t integer;
 430
 431         evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
 432         if (evtag_unmarshal(evbuf, &tag, _buf) == -1 || tag != need_tag)
 433                 return (-1);
 434
 435         if (evtag_decode_int(&integer, _buf) == -1)
 436                 return (-1);
 437         ptv->tv_sec = integer;
 438         if (evtag_decode_int(&integer, _buf) == -1)
 439                 return (-1);
 440         ptv->tv_usec = integer;
 441
 442         return (0);
 443 }