gateway: work around kernel IPIP module initialisation bug
[olsrd.git] / src / parser.c
index 00adc85..6132d74 100644 (file)
@@ -1,6 +1,7 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
- * Copyright (c) 2004-2009, the olsr.org team - see HISTORY file
+ * Copyright (c) 2004, Andreas Tonnesen(andreto@olsr.org)
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include "defs.h"
 #include "process_package.h"
 #include "mantissa.h"
+#include "hysteresis.h"
 #include "duplicate_set.h"
 #include "mid_set.h"
 #include "olsr.h"
+#include "rebuild_packet.h"
 #include "net_os.h"
 #include "log.h"
-#include "print_packet.h"
 #include "net_olsr.h"
+#include "duplicate_handler.h"
 
-#include <errno.h>
-#include <stdlib.h>
-
-#ifdef WIN32
+#ifdef _WIN32
 #undef EWOULDBLOCK
 #define EWOULDBLOCK WSAEWOULDBLOCK
 #undef errno
 #define errno WSAGetLastError()
+char *StrError(unsigned int ErrNo);
 #undef strerror
 #define strerror(x) StrError(x)
-extern char *StrError(unsigned int ErrNo);
-#endif
-
-static void parse_packet(struct olsr *, int, struct interface *, union olsr_ip_addr *);
+#endif /* _WIN32 */
 
-
-/* Sven-Ola: On very slow devices used in huge networks
+    /* Sven-Ola: On very slow devices used in huge networks
  * the amount of lq_tc messages is so high, that the
  * recv() loop never ends. This is a small hack to end
  * the loop in this cases
  */
 
-static struct parse_function_entry *parse_functions;
-static struct preprocessor_function_entry *preprocessor_functions;
-static struct packetparser_function_entry *packetparser_functions;
+unsigned int cpu_overload_exit = 0;
+
+struct parse_function_entry *parse_functions;
+struct preprocessor_function_entry *preprocessor_functions;
+struct packetparser_function_entry *packetparser_functions;
+
+static uint32_t inbuf_aligned[MAXMESSAGESIZE/sizeof(uint32_t) + 1];
+static char *inbuf = (char *)inbuf_aligned;
 
 /**
  *Initialize the parser.
  *
  *@return nada
  */
-void olsr_init_parser(void)
+void
+olsr_init_parser(void)
 {
-  OLSR_INFO(LOG_PACKET_PARSING, "Initializing parser...\n");
+  OLSR_PRINTF(3, "Initializing parser...\n");
 
   /* Initialize the packet functions */
   olsr_init_package_process();
+
 }
 
-void olsr_deinit_parser(void)
-{
-  OLSR_INFO(LOG_PACKET_PARSING, "Deinitializing parser...\n");
-  olsr_deinit_package_process();
+void
+olsr_destroy_parser(void) {
+  struct parse_function_entry *pe, *pe_next;
+  struct preprocessor_function_entry *ppe, *ppe_next;
+  struct packetparser_function_entry *pae, *pae_next;
+
+  for (pe = parse_functions; pe; pe = pe_next) {
+    pe_next = pe->next;
+    free (pe);
+  }
+  for (ppe = preprocessor_functions; ppe; ppe = ppe_next) {
+    ppe_next = ppe->next;
+    free (ppe);
+  }
+  for (pae = packetparser_functions; pae; pae = pae_next) {
+    pae_next = pae->next;
+    free(pae);
+  }
 }
 
-void olsr_parser_add_function(parse_function *function, uint32_t type)
+void
+olsr_parser_add_function(parse_function * function, uint32_t type)
 {
   struct parse_function_entry *new_entry;
 
-  new_entry = olsr_malloc(sizeof(*new_entry), "Register parse function");
+  OLSR_PRINTF(3, "Parser: registering event for type %d\n", type);
+
+  new_entry = olsr_malloc(sizeof(struct parse_function_entry), "Register parse function");
 
   new_entry->function = function;
   new_entry->type = type;
@@ -109,16 +130,19 @@ void olsr_parser_add_function(parse_function *function, uint32_t type)
   new_entry->next = parse_functions;
   parse_functions = new_entry;
 
-  OLSR_INFO(LOG_PACKET_PARSING, "Register parse function: Added function for type %u\n", type);
+  OLSR_PRINTF(3, "Register parse function: Added function for type %d\n", type);
+
 }
 
-int olsr_parser_remove_function(parse_function *function, uint32_t type)
+int
+olsr_parser_remove_function(parse_function * function, uint32_t type)
 {
   struct parse_function_entry *entry, *prev;
 
-  for (entry = parse_functions, prev = NULL;
-       entry != NULL;
-       prev = entry, entry = entry->next) {
+  entry = parse_functions;
+  prev = NULL;
+
+  while (entry) {
     if ((entry->function == function) && (entry->type == type)) {
       if (entry == parse_functions) {
         parse_functions = entry->next;
@@ -128,31 +152,42 @@ int olsr_parser_remove_function(parse_function *function, uint32_t type)
       free(entry);
       return 1;
     }
+
+    prev = entry;
+    entry = entry->next;
   }
+
   return 0;
 }
 
-void olsr_preprocessor_add_function(preprocessor_function *function)
+void
+olsr_preprocessor_add_function(preprocessor_function * function)
 {
   struct preprocessor_function_entry *new_entry;
 
-  new_entry = olsr_malloc(sizeof(*new_entry), "Register preprocessor function");
+  OLSR_PRINTF(3, "Parser: registering preprocessor\n");
+
+  new_entry = olsr_malloc(sizeof(struct preprocessor_function_entry), "Register preprocessor function");
+
   new_entry->function = function;
 
   /* Queue */
   new_entry->next = preprocessor_functions;
   preprocessor_functions = new_entry;
 
-  OLSR_INFO(LOG_PACKET_PARSING, "Registered preprocessor function\n");
+  OLSR_PRINTF(3, "Registered preprocessor function\n");
+
 }
 
-int olsr_preprocessor_remove_function(preprocessor_function *function)
+int
+olsr_preprocessor_remove_function(preprocessor_function * function)
 {
   struct preprocessor_function_entry *entry, *prev;
 
-  for (entry = preprocessor_functions, prev = NULL;
-       entry != NULL;
-       prev = entry, entry = entry->next) {
+  entry = preprocessor_functions;
+  prev = NULL;
+
+  while (entry) {
     if (entry->function == function) {
       if (entry == preprocessor_functions) {
         preprocessor_functions = entry->next;
@@ -162,14 +197,21 @@ int olsr_preprocessor_remove_function(preprocessor_function *function)
       free(entry);
       return 1;
     }
+
+    prev = entry;
+    entry = entry->next;
   }
+
   return 0;
 }
 
-void olsr_packetparser_add_function(packetparser_function *function)
+void
+olsr_packetparser_add_function(packetparser_function * function)
 {
   struct packetparser_function_entry *new_entry;
 
+  OLSR_PRINTF(3, "Parser: registering packetparser\n");
+
   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
 
   new_entry->function = function;
@@ -178,16 +220,19 @@ void olsr_packetparser_add_function(packetparser_function *function)
   new_entry->next = packetparser_functions;
   packetparser_functions = new_entry;
 
-  OLSR_INFO(LOG_PACKET_PARSING, "Registered packetparser  function\n");
+  OLSR_PRINTF(3, "Registered packetparser  function\n");
+
 }
 
-int olsr_packetparser_remove_function(packetparser_function *function)
+int
+olsr_packetparser_remove_function(packetparser_function * function)
 {
   struct packetparser_function_entry *entry, *prev;
 
-  for (entry = packetparser_functions, prev = NULL;
-       entry!= NULL;
-       prev = entry, entry = entry->next) {
+  entry = packetparser_functions;
+  prev = NULL;
+
+  while (entry) {
     if (entry->function == function) {
       if (entry == packetparser_functions) {
         packetparser_functions = entry->next;
@@ -197,61 +242,45 @@ int olsr_packetparser_remove_function(packetparser_function *function)
       free(entry);
       return 1;
     }
-  }
-  return 0;
-}
 
-/**
- * Shared code to parse the message headers and validate the message originator.
- */
-const unsigned char *
-olsr_parse_msg_hdr(const union olsr_message *msg, struct olsrmsg_hdr *msg_hdr)
-{
-  const unsigned char *curr = (const void *)msg;
-  if (!msg) {
-    return NULL;
+    prev = entry;
+    entry = entry->next;
   }
 
-  pkt_get_u8(&curr, &msg_hdr->type);
-  pkt_get_reltime(&curr, &msg_hdr->vtime);
-  pkt_get_u16(&curr, &msg_hdr->size);
-  pkt_get_ipaddress(&curr, &msg_hdr->originator);
-  pkt_get_u8(&curr, &msg_hdr->ttl);
-  pkt_get_u8(&curr, &msg_hdr->hopcnt);
-  pkt_get_u16(&curr, &msg_hdr->seqno);
-
-  if (!olsr_validate_address(&msg_hdr->originator)) {
-    return NULL;
-  }
-  return curr;
+  return 0;
 }
 
 /**
  *Process a newly received OLSR packet. Checks the type
  *and to the neccessary convertions and call the
  *corresponding functions to handle the information.
- *@param from the sockaddr struct describing the sender
  *@param olsr the olsr struct containing the message
  *@param size the size of the message
- *@return nada
+ *@param in_if the incoming interface
+ *@param from_addr the sockaddr struct describing the sender
  */
-static void parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
+
+void
+parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
 {
   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
-  int msgsize;
+  uint32_t count;
+  uint32_t msgsize;
+  uint16_t seqno;
   struct parse_function_entry *entry;
   struct packetparser_function_entry *packetparser;
-  int count = size - ((char *)m - (char *)olsr);
-#if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
-  struct ipaddr_str buf;
-#endif
 
-  if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version)) {
+  count = size - ((char *)m - (char *)olsr);
+
+  /* minimum packet size is 4 */
+  if (count < 4)
     return;
-  }
-  if (ntohs(olsr->olsr_packlen) != size) {
-    OLSR_WARN(LOG_PACKET_PARSING, "Size error detected in received packet from %s.\nRecieved %d, in packet %d\n",
-        olsr_ip_to_string(&buf, from_addr), size, ntohs(olsr->olsr_packlen));
+
+  if (ntohs(olsr->olsr_packlen) !=(uint16_t) size) {
+    struct ipaddr_str buf;
+    OLSR_PRINTF(1, "Size error detected in received packet.\nReceived %d, in packet %d\n", size, ntohs(olsr->olsr_packlen));
+
+    olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
     return;
   }
 
@@ -259,35 +288,83 @@ static void parse_packet(struct olsr *olsr, int size, struct interface *in_if, u
   olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
 
   // call packetparser
-  for (packetparser = packetparser_functions; packetparser != NULL; packetparser = packetparser->next) {
+  packetparser = packetparser_functions;
+  while (packetparser) {
     packetparser->function(olsr, in_if, from_addr);
+    packetparser = packetparser->next;
   }
 
   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr));
 
-  /* Display packet */
-  if (olsr_cnf->disp_packets_in) {
-    print_olsr_serialized_packet(stdout, (union olsr_packet *)olsr, size, from_addr);
+  /*
+   * Hysteresis update - for every OLSR package
+   */
+  if (olsr_cnf->use_hysteresis) {
+    if (olsr_cnf->ip_version == AF_INET) {
+      /* IPv4 */
+      update_hysteresis_incoming(from_addr, in_if, olsr->olsr_seqno);
+    } else {
+      /* IPv6 */
+      update_hysteresis_incoming(from_addr, in_if, olsr->olsr_seqno);
+    }
   }
-  msgsize = ntohs(olsr_cnf->ip_version == AF_INET ? m->v4.olsr_msgsize : m->v6.olsr_msgsize);
 
-  for (; count > 0; m = (union olsr_message *)((char *)m + msgsize)) {
+  for (; count > 0; m = (union olsr_message *)((char *)m + (msgsize))) {
     bool forward = true;
+    bool validated;
+
+    /* minimum message size is 8 + ipsize */
+    if (count < 8 + olsr_cnf->ipsize)
+      break;
+
+    if (olsr_cnf->ip_version == AF_INET) {
+      msgsize = ntohs(m->v4.olsr_msgsize);
+      seqno = ntohs(m->v4.seqno);
+    }
+    else {
+      msgsize = ntohs(m->v6.olsr_msgsize);
+      seqno = ntohs(m->v6.seqno);
+    }
 
-    if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version)) {
+    /* sanity check for msgsize */
+    if (msgsize < 8 + olsr_cnf->ipsize) {
+      struct ipaddr_str buf;
+      union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
+      OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) is to small (%d bytes)"
+          ", ignoring all further content of the packet\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
+      olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) is too small (%d bytes)"
+          ", ignoring all further content of the packet\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
       break;
     }
-    msgsize = ntohs(olsr_cnf->ip_version == AF_INET ? m->v4.olsr_msgsize : m->v6.olsr_msgsize);
 
-    count -= msgsize;
+    if ((msgsize % 4) != 0) {
+      struct ipaddr_str buf;
+      union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
+      OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) must be"
+          " longword aligned, but has a length of %d bytes\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
+      olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) must be"
+          " longword aligned, but has a length of %d bytes",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
+      break;
+    }
 
-    /* Check size of message */
-    if (count < 0) {
-      OLSR_WARN(LOG_PACKET_PARSING, "packet length error in  packet received from %s!",
-                  olsr_ip_to_string(&buf, from_addr));
+    if (msgsize > count) {
+      struct ipaddr_str buf;
+      union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
+      OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) says"
+          " length=%d, but only %d bytes left\n",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
+      olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) says"
+          " length=%d, but only %d bytes left",
+          olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
       break;
     }
 
+    count -= msgsize;
+
     /*RFC 3626 section 3.4:
      *  2    If the time to live of the message is less than or equal to
      *  '0' (zero), or if the message was sent by the receiving node
@@ -297,109 +374,123 @@ static void parse_packet(struct olsr *olsr, int size, struct interface *in_if, u
      */
 
     /* Should be the same for IPv4 and IPv6 */
-    if (olsr_ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->router_id)
-        || !olsr_validate_address((union olsr_ip_addr *)&m->v4.originator)) {
-      OLSR_INFO(LOG_PACKET_PARSING, "Not processing message originating from %s!\n",
-                  olsr_ip_to_string(&buf,(union olsr_ip_addr *)&m->v4.originator));
+    validated = olsr_validate_address((union olsr_ip_addr *)&m->v4.originator);
+    if (ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->main_addr) || !validated) {
+#ifdef DEBUG
+      struct ipaddr_str buf;
+      OLSR_PRINTF(3, "Not processing message originating from %s!\n",
+                  olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
+#endif /* DEBUG */
+#ifndef NO_DUPLICATE_DETECTION_HANDLER
+      if (validated) {
+        olsr_test_originator_collision(m->v4.olsr_msgtype, seqno);
+      }
+#endif /* NO_DUPLICATE_DETECTION_HANDLER */
       continue;
     }
 
-    for (entry = parse_functions; entry != NULL; entry = entry->next) {
+    entry = parse_functions;
+    while (entry) {
       /* Should be the same for IPv4 and IPv6 */
+
       /* Promiscuous or exact match */
       if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
         if (!entry->function(m, in_if, from_addr))
           forward = false;
       }
+      entry = entry->next;
     }
 
     if (forward) {
       olsr_forward_message(m, in_if, from_addr);
     }
-  } /* for olsr_msg */
+  }                             /* for olsr_msg */
 }
 
 /**
  *Processing OLSR data from socket. Reading data, setting
- *wich interface recieved the message, Sends IPC(if used)
+ *wich interface received the message, Sends IPC(if used)
  *and passes the packet on to parse_packet().
  *
  *@param fd the filedescriptor that data should be read from.
- *@return nada
+ *@param data unused
+ *@param flags unused
  */
 void
-olsr_input(int fd, void *data __attribute__((unused)), unsigned int flags __attribute__((unused)))
+olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 {
-  unsigned int cpu_overload_exit = 0;
-#ifndef REMOVE_LOG_DEBUG
-      char addrbuf[128];
-#endif
-#ifndef REMOVE_LOG_WARN
-      struct ipaddr_str buf;
-#endif
+  struct interface *olsr_in_if;
+  union olsr_ip_addr from_addr;
+  struct preprocessor_function_entry *entry;
+  char *packet;
+
+  cpu_overload_exit = 0;
 
   for (;;) {
-    struct interface *olsr_in_if;
-    union olsr_ip_addr from_addr;
-    struct preprocessor_function_entry *entry;
-    char *packet;
+    struct ipaddr_str buf;
     /* sockaddr_in6 is bigger than sockaddr !!!! */
     struct sockaddr_storage from;
     socklen_t fromlen;
     int cc;
-    char inbuf[MAXMESSAGESIZE+1];
 
     if (32 < ++cpu_overload_exit) {
-      OLSR_WARN(LOG_PACKET_PARSING, "CPU overload detected, ending olsr_input() loop\n");
+      OLSR_PRINTF(1, "CPU overload detected, ending olsr_input() loop\n");
       break;
     }
 
-    fromlen = sizeof(from);
-    cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf), 0, (struct sockaddr *)&from, &fromlen);
+    fromlen = sizeof(struct sockaddr_storage);
+    cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf_aligned), 0, (struct sockaddr *)&from, &fromlen);
 
     if (cc <= 0) {
       if (cc < 0 && errno != EWOULDBLOCK) {
-        OLSR_WARN(LOG_PACKET_PARSING, "error recvfrom: %s", strerror(errno));
+        OLSR_PRINTF(1, "error recvfrom: %s", strerror(errno));
+#ifndef _WIN32
+        olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %m");
+#endif /* _WIN32 */
       }
       break;
     }
-
-    OLSR_DEBUG(LOG_PACKET_PARSING, "Recieved a packet from %s\n", sockaddr_to_string(addrbuf, sizeof(addrbuf), (struct sockaddr *)&from, fromlen));
-
     if (olsr_cnf->ip_version == AF_INET) {
       /* IPv4 sender address */
-      if (fromlen != sizeof(struct sockaddr_in)) {
-        break;
-      }
-      from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
+      void * src = &((struct sockaddr_in *)&from)->sin_addr;
+      memcpy(&from_addr.v4, src, sizeof(from_addr.v4));
     } else {
       /* IPv6 sender address */
-      if (fromlen != sizeof(struct sockaddr_in6)) {
-        break;
-      }
-      from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
+      void * src = &((struct sockaddr_in6 *)&from)->sin6_addr;
+      memcpy(&from_addr.v6, src, sizeof(from_addr.v6));
     }
 
+#ifdef DEBUG
+    OLSR_PRINTF(5, "Received a packet from %s\n",
+        olsr_ip_to_string(&buf, &from_addr));
+#endif /* DEBUG */
+
+    if ((olsr_cnf->ip_version == AF_INET) && (fromlen != sizeof(struct sockaddr_in)))
+      break;
+    else if ((olsr_cnf->ip_version == AF_INET6) && (fromlen != sizeof(struct sockaddr_in6)))
+      break;
+
     /* are we talking to ourselves? */
-    if (if_ifwithaddr(&from_addr) != NULL) {
+    if (if_ifwithaddr(&from_addr) != NULL)
       return;
-    }
-    olsr_in_if = if_ifwithsock(fd);
-    if (olsr_in_if == NULL) {
-      OLSR_WARN(LOG_PACKET_PARSING, "Could not find input interface for message from %s size %d\n",
-                  olsr_ip_to_string(&buf, &from_addr),
+
+    if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
+      OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
+      olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
                   cc);
       return;
     }
-
     // call preprocessors
+    entry = preprocessor_functions;
     packet = &inbuf[0];
-    for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
+
+    while (entry) {
       packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
       // discard package ?
       if (packet == NULL) {
         return;
       }
+      entry = entry->next;
     }
 
     /*
@@ -408,18 +499,21 @@ olsr_input(int fd, void *data __attribute__((unused)), unsigned int flags __attr
      * cc - bytes read
      */
     parse_packet((struct olsr *)packet, cc, olsr_in_if, &from_addr);
+
   }
 }
 
 /**
  *Processing OLSR data from socket. Reading data, setting
- *wich interface recieved the message, Sends IPC(if used)
+ *wich interface received the message, Sends IPC(if used)
  *and passes the packet on to parse_packet().
  *
  *@param fd the filedescriptor that data should be read from.
- *@return nada
+ *@param data unused
+ *@param flags unused
  */
-void olsr_input_hostemu(int fd, void *data __attribute__((unused)), unsigned int flags __attribute__((unused)))
+void
+olsr_input_hostemu(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 {
   /* sockaddr_in6 is bigger than sockaddr !!!! */
   struct sockaddr_storage from;
@@ -429,42 +523,41 @@ void olsr_input_hostemu(int fd, void *data __attribute__((unused)), unsigned int
   uint16_t pcklen;
   struct preprocessor_function_entry *entry;
   char *packet;
-  char inbuf[MAXMESSAGESIZE+1];
-#ifndef REMOVE_LOG_WARN
-  struct ipaddr_str buf;
-#endif
 
   /* Host emulator receives IP address first to emulate
-   direct link */
+     direct link */
 
-  int cc = recv(fd, from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
+  int cc = recv(fd, (void*)from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
   if (cc != (int)olsr_cnf->ipsize) {
     fprintf(stderr, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
     memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
   }
 
   /* are we talking to ourselves? */
-  if (if_ifwithaddr(&from_addr) != NULL) {
+  if (if_ifwithaddr(&from_addr) != NULL)
     return;
-  }
 
   /* Extract size */
-  cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK);/* Win needs a cast */
-  if (cc != 2) {
+  if ((cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK)) != 2) {     /* Win needs a cast */
     if (cc <= 0) {
-      OLSR_ERROR(LOG_NETWORKING, "Lost olsr_switch connection - exit!\n");
-      olsr_exit(EXIT_FAILURE);
+      fprintf(stderr, "Lost olsr_switch connection - exit!\n");
+      olsr_exit(__func__, EXIT_FAILURE);
     }
-    OLSR_WARN(LOG_NETWORKING, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
+    fprintf(stderr, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
     return;
+  } else {
+    pcklen = ntohs(pcklen);
   }
-  pcklen = ntohs(pcklen);
 
-  fromlen = sizeof(from);
+  fromlen = sizeof(struct sockaddr_storage);
+
   cc = olsr_recvfrom(fd, inbuf, pcklen, 0, (struct sockaddr *)&from, &fromlen);
+
   if (cc <= 0) {
     if (cc < 0 && errno != EWOULDBLOCK) {
-      OLSR_WARN(LOG_NETWORKING, "error recvfrom: %s", strerror(errno));
+      const char *const err_msg = strerror(errno);
+      OLSR_PRINTF(1, "error recvfrom: %s", err_msg);
+      olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %s", err_msg);
     }
     return;
   }
@@ -474,22 +567,24 @@ void olsr_input_hostemu(int fd, void *data __attribute__((unused)), unsigned int
     return;
   }
 
-  olsr_in_if = if_ifwithsock(fd);
-  if (olsr_in_if == NULL) {
-    OLSR_WARN(LOG_NETWORKING, "Could not find input interface for message from %s size %d\n",
-                olsr_ip_to_string(&buf, &from_addr),
+  if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
+    struct ipaddr_str buf;
+    OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
+    olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
                 cc);
     return;
   }
-
   // call preprocessors
+  entry = preprocessor_functions;
   packet = &inbuf[0];
-  for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
+
+  while (entry) {
     packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
     // discard package ?
     if (packet == NULL) {
       return;
     }
+    entry = entry->next;
   }
 
   /*
@@ -498,6 +593,7 @@ void olsr_input_hostemu(int fd, void *data __attribute__((unused)), unsigned int
    * cc - bytes read
    */
   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
+
 }
 
 /*