src/parser.c

   1
   2 /*
   3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   4  * Copyright (c) 2004, Andreas Tonnesen(andreto@olsr.org)
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * * Redistributions of source code must retain the above copyright
  12  *   notice, this list of conditions and the following disclaimer.
  13  * * Redistributions in binary form must reproduce the above copyright
  14  *   notice, this list of conditions and the following disclaimer in
  15  *   the documentation and/or other materials provided with the
  16  *   distribution.
  17  * * Neither the name of olsr.org, olsrd nor the names of its
  18  *   contributors may be used to endorse or promote products derived
  19  *   from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * Visit http://www.olsr.org for more information.
  35  *
  36  * If you find this software useful feel free to make a donation
  37  * to the project. For more information see the website or contact
  38  * the copyright holders.
  39  *
  40  */
  41
  42 #include "parser.h"
  43 #include "ipcalc.h"
  44 #include "defs.h"
  45 #include "process_package.h"
  46 #include "mantissa.h"
  47 #include "hysteresis.h"
  48 #include "duplicate_set.h"
  49 #include "mid_set.h"
  50 #include "olsr.h"
  51 #include "rebuild_packet.h"
  52 #include "net_os.h"
  53 #include "log.h"
  54 #include "print_packet.h"
  55 #include "net_olsr.h"
  56 #include "duplicate_handler.h"
  57
  58 #ifdef WIN32
  59 #undef EWOULDBLOCK
  60 #define EWOULDBLOCK WSAEWOULDBLOCK
  61 #undef errno
  62 #define errno WSAGetLastError()
  63 char *StrError(unsigned int ErrNo);
  64 #undef strerror
  65 #define strerror(x) StrError(x)
  66 #endif
  67
  68     /* Sven-Ola: On very slow devices used in huge networks
  69  * the amount of lq_tc messages is so high, that the
  70  * recv() loop never ends. This is a small hack to end
  71  * the loop in this cases
  72  */
  73
  74 unsigned int cpu_overload_exit = 0;
  75
  76 struct parse_function_entry *parse_functions;
  77 struct preprocessor_function_entry *preprocessor_functions;
  78 struct packetparser_function_entry *packetparser_functions;
  79
  80 static uint32_t inbuf_aligned[MAXMESSAGESIZE/sizeof(uint32_t) + 1];
  81 static char *inbuf = (char *)inbuf_aligned;
  82
  83 static bool disp_pack_in = false;
  84
  85 void
  86 parser_set_disp_pack_in(bool val)
  87 {
  88   disp_pack_in = val;
  89 }
  90
  91 /**
  92  *Initialize the parser.
  93  *
  94  *@return nada
  95  */
  96 void
  97 olsr_init_parser(void)
  98 {
  99   OLSR_PRINTF(3, "Initializing parser...\n");
 100
 101   /* Initialize the packet functions */
 102   olsr_init_package_process();
 103
 104 }
 105
 106 void
 107 olsr_destroy_parser(void) {
 108   struct parse_function_entry *pe, *pe_next;
 109   struct preprocessor_function_entry *ppe, *ppe_next;
 110   struct packetparser_function_entry *pae, *pae_next;
 111
 112   for (pe = parse_functions; pe; pe = pe_next) {
 113     pe_next = pe->next;
 114     free (pe);
 115   }
 116   for (ppe = preprocessor_functions; ppe; ppe = ppe_next) {
 117     ppe_next = ppe->next;
 118     free (ppe);
 119   }
 120   for (pae = packetparser_functions; pae; pae = pae_next) {
 121     pae_next = pae->next;
 122     free(pae);
 123   }
 124 }
 125
 126 void
 127 olsr_parser_add_function(parse_function * function, uint32_t type)
 128 {
 129   struct parse_function_entry *new_entry;
 130
 131   OLSR_PRINTF(3, "Parser: registering event for type %d\n", type);
 132
 133   new_entry = olsr_malloc(sizeof(struct parse_function_entry), "Register parse function");
 134
 135   new_entry->function = function;
 136   new_entry->type = type;
 137
 138   /* Queue */
 139   new_entry->next = parse_functions;
 140   parse_functions = new_entry;
 141
 142   OLSR_PRINTF(3, "Register parse function: Added function for type %d\n", type);
 143
 144 }
 145
 146 int
 147 olsr_parser_remove_function(parse_function * function, uint32_t type)
 148 {
 149   struct parse_function_entry *entry, *prev;
 150
 151   entry = parse_functions;
 152   prev = NULL;
 153
 154   while (entry) {
 155     if ((entry->function == function) && (entry->type == type)) {
 156       if (entry == parse_functions) {
 157         parse_functions = entry->next;
 158       } else {
 159         prev->next = entry->next;
 160       }
 161       free(entry);
 162       return 1;
 163     }
 164
 165     prev = entry;
 166     entry = entry->next;
 167   }
 168
 169   return 0;
 170 }
 171
 172 void
 173 olsr_preprocessor_add_function(preprocessor_function * function)
 174 {
 175   struct preprocessor_function_entry *new_entry;
 176
 177   OLSR_PRINTF(3, "Parser: registering preprocessor\n");
 178
 179   new_entry = olsr_malloc(sizeof(struct preprocessor_function_entry), "Register preprocessor function");
 180
 181   new_entry->function = function;
 182
 183   /* Queue */
 184   new_entry->next = preprocessor_functions;
 185   preprocessor_functions = new_entry;
 186
 187   OLSR_PRINTF(3, "Registered preprocessor function\n");
 188
 189 }
 190
 191 int
 192 olsr_preprocessor_remove_function(preprocessor_function * function)
 193 {
 194   struct preprocessor_function_entry *entry, *prev;
 195
 196   entry = preprocessor_functions;
 197   prev = NULL;
 198
 199   while (entry) {
 200     if (entry->function == function) {
 201       if (entry == preprocessor_functions) {
 202         preprocessor_functions = entry->next;
 203       } else {
 204         prev->next = entry->next;
 205       }
 206       free(entry);
 207       return 1;
 208     }
 209
 210     prev = entry;
 211     entry = entry->next;
 212   }
 213
 214   return 0;
 215 }
 216
 217 void
 218 olsr_packetparser_add_function(packetparser_function * function)
 219 {
 220   struct packetparser_function_entry *new_entry;
 221
 222   OLSR_PRINTF(3, "Parser: registering packetparser\n");
 223
 224   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
 225
 226   new_entry->function = function;
 227
 228   /* Queue */
 229   new_entry->next = packetparser_functions;
 230   packetparser_functions = new_entry;
 231
 232   OLSR_PRINTF(3, "Registered packetparser  function\n");
 233
 234 }
 235
 236 int
 237 olsr_packetparser_remove_function(packetparser_function * function)
 238 {
 239   struct packetparser_function_entry *entry, *prev;
 240
 241   entry = packetparser_functions;
 242   prev = NULL;
 243
 244   while (entry) {
 245     if (entry->function == function) {
 246       if (entry == packetparser_functions) {
 247         packetparser_functions = entry->next;
 248       } else {
 249         prev->next = entry->next;
 250       }
 251       free(entry);
 252       return 1;
 253     }
 254
 255     prev = entry;
 256     entry = entry->next;
 257   }
 258
 259   return 0;
 260 }
 261
 262 /**
 263  *Process a newly received OLSR packet. Checks the type
 264  *and to the neccessary convertions and call the
 265  *corresponding functions to handle the information.
 266  *@param from the sockaddr struct describing the sender
 267  *@param olsr the olsr struct containing the message
 268  *@param size the size of the message
 269  *@return nada
 270  */
 271
 272 void
 273 parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
 274 {
 275   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
 276   uint32_t count;
 277   uint32_t msgsize;
 278   uint16_t seqno;
 279   struct parse_function_entry *entry;
 280   struct packetparser_function_entry *packetparser;
 281
 282   count = size - ((char *)m - (char *)olsr);
 283
 284   /* minimum packet size is 4 */
 285   if (count < 4)
 286     return;
 287
 288   if (ntohs(olsr->olsr_packlen) !=(uint16_t) size) {
 289     struct ipaddr_str buf;
 290     OLSR_PRINTF(1, "Size error detected in received packet.\nRecieved %d, in packet %d\n", size, ntohs(olsr->olsr_packlen));
 291
 292     olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
 293     return;
 294   }
 295   // translate sequence number to host order
 296   olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
 297
 298   // call packetparser
 299   packetparser = packetparser_functions;
 300   while (packetparser) {
 301     packetparser->function(olsr, in_if, from_addr);
 302     packetparser = packetparser->next;
 303   }
 304
 305   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr));
 306
 307   /* Display packet */
 308   if (disp_pack_in)
 309     print_olsr_serialized_packet(stdout, (union olsr_packet *)olsr, size, from_addr);
 310
 311   /*
 312    * Hysteresis update - for every OLSR package
 313    */
 314   if (olsr_cnf->use_hysteresis) {
 315     if (olsr_cnf->ip_version == AF_INET) {
 316       /* IPv4 */
 317       update_hysteresis_incoming(from_addr, in_if, ntohs(olsr->olsr_seqno));
 318     } else {
 319       /* IPv6 */
 320       update_hysteresis_incoming(from_addr, in_if, ntohs(olsr->olsr_seqno));
 321     }
 322   }
 323
 324   for (; count > 0; m = (union olsr_message *)((char *)m + (msgsize))) {
 325     bool forward = true;
 326     bool validated;
 327
 328     /* minimum message size is 8 + ipsize */
 329     if (count < 8 + olsr_cnf->ipsize)
 330       break;
 331
 332     if (olsr_cnf->ip_version == AF_INET) {
 333       msgsize = ntohs(m->v4.olsr_msgsize);
 334       seqno = ntohs(m->v4.seqno);
 335     }
 336     else {
 337       msgsize = ntohs(m->v6.olsr_msgsize);
 338       seqno = ntohs(m->v6.seqno);
 339     }
 340
 341     /* sanity check for msgsize */
 342     if (msgsize < 8 + olsr_cnf->ipsize) {
 343       struct ipaddr_str buf;
 344       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
 345       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) is to small (%d bytes)"
 346           ", ignoring all further content of the packet\n",
 347           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
 348       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) is too small (%d bytes)"
 349           ", ignoring all further content of the packet\n",
 350           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
 351       break;
 352     }
 353
 354     if ((msgsize % 4) != 0) {
 355       struct ipaddr_str buf;
 356       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
 357       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) must be"
 358           " longword aligned, but has a length of %d bytes\n",
 359           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
 360       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) must be"
 361           " longword aligned, but has a length of %d bytes",
 362           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
 363       break;
 364     }
 365
 366     if (msgsize > count) {
 367       struct ipaddr_str buf;
 368       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
 369       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) says"
 370           " length=%d, but only %d bytes left\n",
 371           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
 372       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) says"
 373           " length=%d, but only %d bytes left",
 374           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
 375       break;
 376     }
 377
 378     count -= msgsize;
 379
 380     /*RFC 3626 section 3.4:
 381      *  2    If the time to live of the message is less than or equal to
 382      *  '0' (zero), or if the message was sent by the receiving node
 383      *  (i.e., the Originator Address of the message is the main
 384      *  address of the receiving node): the message MUST silently be
 385      *  dropped.
 386      */
 387
 388     /* Should be the same for IPv4 and IPv6 */
 389     validated = olsr_validate_address((union olsr_ip_addr *)&m->v4.originator);
 390     if (ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->main_addr) || !validated) {
 391 #ifdef DEBUG
 392       struct ipaddr_str buf;
 393       OLSR_PRINTF(3, "Not processing message originating from %s!\n",
 394                   olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
 395 #endif
 396 #ifndef NO_DUPLICATE_DETECTION_HANDLER
 397       if (validated) {
 398         olsr_test_originator_collision(m->v4.olsr_msgtype, seqno);
 399       }
 400 #endif
 401       continue;
 402     }
 403
 404     entry = parse_functions;
 405     while (entry) {
 406       /* Should be the same for IPv4 and IPv6 */
 407
 408       /* Promiscuous or exact match */
 409       if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
 410         if (!entry->function(m, in_if, from_addr))
 411           forward = false;
 412       }
 413       entry = entry->next;
 414     }
 415
 416     if (forward) {
 417       olsr_forward_message(m, in_if, from_addr);
 418     }
 419   }                             /* for olsr_msg */
 420 }
 421
 422 /**
 423  *Processing OLSR data from socket. Reading data, setting
 424  *wich interface recieved the message, Sends IPC(if used)
 425  *and passes the packet on to parse_packet().
 426  *
 427  *@param fd the filedescriptor that data should be read from.
 428  *@return nada
 429  */
 430 void
 431 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 432 {
 433   struct interface *olsr_in_if;
 434   union olsr_ip_addr from_addr;
 435   struct preprocessor_function_entry *entry;
 436   char *packet;
 437
 438   cpu_overload_exit = 0;
 439
 440   for (;;) {
 441     struct ipaddr_str buf;
 442     /* sockaddr_in6 is bigger than sockaddr !!!! */
 443     struct sockaddr_storage from;
 444     socklen_t fromlen;
 445     int cc;
 446
 447     if (32 < ++cpu_overload_exit) {
 448       OLSR_PRINTF(1, "CPU overload detected, ending olsr_input() loop\n");
 449       break;
 450     }
 451
 452     fromlen = sizeof(struct sockaddr_storage);
 453     cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf_aligned), 0, (struct sockaddr *)&from, &fromlen);
 454
 455     if (cc <= 0) {
 456       if (cc < 0 && errno != EWOULDBLOCK) {
 457         OLSR_PRINTF(1, "error recvfrom: %s", strerror(errno));
 458 #ifndef WIN32
 459         olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %m");
 460 #endif
 461       }
 462       break;
 463     }
 464     if (olsr_cnf->ip_version == AF_INET) {
 465       /* IPv4 sender address */
 466       memcpy(&from_addr.v4, &((struct sockaddr_in *)&from)->sin_addr, sizeof(from_addr.v4));
 467     } else {
 468       /* IPv6 sender address */
 469       memcpy(&from_addr.v6, &((struct sockaddr_in6 *)&from)->sin6_addr, sizeof(from_addr.v6));
 470     }
 471
 472 #ifdef DEBUG
 473     OLSR_PRINTF(5, "Recieved a packet from %s\n",
 474         olsr_ip_to_string(&buf, &from_addr));
 475 #endif
 476
 477     if ((olsr_cnf->ip_version == AF_INET) && (fromlen != sizeof(struct sockaddr_in)))
 478       break;
 479     else if ((olsr_cnf->ip_version == AF_INET6) && (fromlen != sizeof(struct sockaddr_in6)))
 480       break;
 481
 482     /* are we talking to ourselves? */
 483     if (if_ifwithaddr(&from_addr) != NULL)
 484       return;
 485
 486     if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
 487       OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
 488       olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
 489                   cc);
 490       return;
 491     }
 492     // call preprocessors
 493     entry = preprocessor_functions;
 494     packet = &inbuf[0];
 495
 496     while (entry) {
 497       packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
 498       // discard package ?
 499       if (packet == NULL) {
 500         return;
 501       }
 502       entry = entry->next;
 503     }
 504
 505     /*
 506      * &from - sender
 507      * &inbuf.olsr
 508      * cc - bytes read
 509      */
 510     parse_packet((struct olsr *)packet, cc, olsr_in_if, &from_addr);
 511
 512   }
 513 }
 514
 515 /**
 516  *Processing OLSR data from socket. Reading data, setting
 517  *wich interface recieved the message, Sends IPC(if used)
 518  *and passes the packet on to parse_packet().
 519  *
 520  *@param fd the filedescriptor that data should be read from.
 521  *@return nada
 522  */
 523 void
 524 olsr_input_hostemu(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 525 {
 526   /* sockaddr_in6 is bigger than sockaddr !!!! */
 527   struct sockaddr_storage from;
 528   socklen_t fromlen;
 529   struct interface *olsr_in_if;
 530   union olsr_ip_addr from_addr;
 531   uint16_t pcklen;
 532   struct preprocessor_function_entry *entry;
 533   char *packet;
 534
 535   /* Host emulator receives IP address first to emulate
 536      direct link */
 537
 538   int cc = recv(fd, (void*)from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
 539   if (cc != (int)olsr_cnf->ipsize) {
 540     fprintf(stderr, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
 541     memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
 542   }
 543
 544   /* are we talking to ourselves? */
 545   if (if_ifwithaddr(&from_addr) != NULL)
 546     return;
 547
 548   /* Extract size */
 549   if ((cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK)) != 2) {     /* Win needs a cast */
 550     if (cc <= 0) {
 551       fprintf(stderr, "Lost olsr_switch connection - exit!\n");
 552       olsr_exit(__func__, EXIT_FAILURE);
 553     }
 554     fprintf(stderr, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
 555     return;
 556   } else {
 557     pcklen = ntohs(pcklen);
 558   }
 559
 560   fromlen = sizeof(struct sockaddr_storage);
 561
 562   cc = olsr_recvfrom(fd, inbuf, pcklen, 0, (struct sockaddr *)&from, &fromlen);
 563
 564   if (cc <= 0) {
 565     if (cc < 0 && errno != EWOULDBLOCK) {
 566       const char *const err_msg = strerror(errno);
 567       OLSR_PRINTF(1, "error recvfrom: %s", err_msg);
 568       olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %s", err_msg);
 569     }
 570     return;
 571   }
 572
 573   if (cc != pcklen) {
 574     printf("Could not read whole packet(size %d, read %d)\n", pcklen, cc);
 575     return;
 576   }
 577
 578   if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
 579     struct ipaddr_str buf;
 580     OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
 581     olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
 582                 cc);
 583     return;
 584   }
 585   // call preprocessors
 586   entry = preprocessor_functions;
 587   packet = &inbuf[0];
 588
 589   while (entry) {
 590     packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
 591     // discard package ?
 592     if (packet == NULL) {
 593       return;
 594     }
 595     entry = entry->next;
 596   }
 597
 598   /*
 599    * &from - sender
 600    * &inbuf.olsr
 601    * cc - bytes read
 602    */
 603   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
 604
 605 }
 606
 607 /*
 608  * Local Variables:
 609  * c-basic-offset: 2
 610  * indent-tabs-mode: nil
 611  * End:
 612  */