Lots of work, no result
authorHenning Rogge <hrogge@googlemail.com>
Sat, 28 Nov 2009 14:12:29 +0000 (15:12 +0100)
committerHenning Rogge <hrogge@googlemail.com>
Sat, 28 Nov 2009 14:12:29 +0000 (15:12 +0100)
28 files changed:
lib/debuginfo/src/olsrd_debuginfo.c
lib/lq_etx_ff/src/lq_plugin_etx_ff.c
lib/mdns/src/mdns.c
lib/mdns/src/mdns.h
lib/nameservice/src/nameservice.c
lib/nameservice/src/nameservice.h
lib/obamp/src/obamp.c
lib/obamp/src/obamp.h
lib/secure/src/olsrd_secure.c
src/defs.h
src/duplicate_set.c
src/duplicate_set.h
src/hna_set.c
src/hna_set.h
src/link_set.c
src/lq_packet.h
src/mid_set.c
src/mid_set.h
src/net_olsr.c
src/olsr.c
src/olsr.h
src/olsr_protocol.h
src/parser.c
src/parser.h
src/process_package.c
src/process_package.h
src/tc_set.c
src/tc_set.h

index 287388d..b576cc8 100644 (file)
@@ -83,8 +83,11 @@ static enum olsr_txtcommand_result debuginfo_cookies(struct comport_connection *
     const char *cmd, const char *param);
 
 static void update_statistics_ptr(void *);
-static void olsr_msg_statistics(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
-static char *olsr_packet_statistics(char *packet, struct interface *interface, union olsr_ip_addr *, int *length);
+static void olsr_msg_statistics(struct olsr_message *, const uint8_t *, const uint8_t *,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
+static uint8_t *olsr_packet_statistics(uint8_t *binary,
+    struct interface *interface, union olsr_ip_addr *ip, int *length);
+
 static void update_statistics_ptr(void *data __attribute__ ((unused)));
 
 /* plugin configuration */
@@ -308,29 +311,18 @@ update_statistics_ptr(void *data __attribute__ ((unused)))
 
 /* update message statistics */
 static void
-olsr_msg_statistics(union olsr_message *msg, struct interface *input_if __attribute__ ((unused)),
+olsr_msg_statistics(struct olsr_message *msg,
+    const uint8_t *payload  __attribute__ ((unused)), const uint8_t *end  __attribute__ ((unused)),
+    struct interface *input_if __attribute__ ((unused)),
     union olsr_ip_addr *from_addr __attribute__ ((unused)), enum duplicate_status status  __attribute__ ((unused)))
 {
-  int msgtype, msgsize;
-  union olsr_ip_addr origaddr;
   enum debug_msgtraffic_type type;
   struct debug_msgtraffic *tr;
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
 
-  memset(&origaddr, 0, sizeof(origaddr));
-  if (olsr_cnf->ip_version == AF_INET) {
-    msgtype = msg->v4.olsr_msgtype;
-    msgsize = ntohs(msg->v4.olsr_msgsize);
-    origaddr.v4.s_addr = msg->v4.originator;
-  } else {
-    msgtype = msg->v6.olsr_msgtype;
-    msgsize = ntohs(msg->v6.olsr_msgsize);
-    origaddr.v6 = msg->v6.originator;
-  }
-
-  switch (msgtype) {
+  switch (msg->type) {
   case HELLO_MESSAGE:
     type = DTR_HELLO;
     break;
@@ -355,10 +347,10 @@ olsr_msg_statistics(union olsr_message *msg, struct interface *input_if __attrib
   }
 
   /* input data for specific node */
-  tr = get_msgtraffic_entry(&origaddr);
+  tr = get_msgtraffic_entry(&msg->originator);
   tr->current.data[type]++;
   tr->current.data[DTR_MESSAGES]++;
-  tr->current.data[DTR_MSG_TRAFFIC] += msgsize;
+  tr->current.data[DTR_MSG_TRAFFIC] += msg->size;
 
   OLSR_DEBUG(LOG_PLUGINS, "Added message type %d to statistics of %s: %d\n",
       type, olsr_ip_to_string(&buf, &tr->ip), tr->current.data[type]);
@@ -367,14 +359,12 @@ olsr_msg_statistics(union olsr_message *msg, struct interface *input_if __attrib
   tr = get_msgtraffic_entry(&total_ip_addr);
   tr->current.data[type]++;
   tr->current.data[DTR_MESSAGES]++;
-  tr->current.data[DTR_MSG_TRAFFIC] += msgsize;
+  tr->current.data[DTR_MSG_TRAFFIC] += msg->size;
 }
 
 /* update traffic statistics */
-static char *
-olsr_packet_statistics(char *packet __attribute__ ((unused)),
-                       struct interface *interface,
-                       union olsr_ip_addr *ip, int *length)
+static uint8_t *
+olsr_packet_statistics(uint8_t *binary, struct interface *interface, union olsr_ip_addr *ip, int *length)
 {
   struct debug_pkttraffic *tr;
   tr = get_pkttraffic_entry(ip, interface);
@@ -384,7 +374,7 @@ olsr_packet_statistics(char *packet __attribute__ ((unused)),
   tr = get_pkttraffic_entry(&total_ip_addr, NULL);
   tr->current.data[DTR_PACK_TRAFFIC] += *length;
   tr->current.data[DTR_PACKETS] ++;
-  return packet;
+  return binary;
 }
 
 static const char *debuginfo_print_trafficip(struct ipaddr_str *buf, union olsr_ip_addr *ip) {
index 415141b..6100d9f 100644 (file)
@@ -152,7 +152,8 @@ static bool lq_etxff_post_init(void) {
 }
 
 static void
-lq_etxff_packet_parser(struct olsr *olsr, struct interface *in_if, union olsr_ip_addr *from_addr)
+lq_etxff_packet_parser(struct olsr_packet *pkt, uint8_t *binary __attribute__ ((unused)),
+    struct interface *in_if, union olsr_ip_addr *from_addr)
 {
   const union olsr_ip_addr *main_addr;
   struct lq_etxff_link_entry *lnk;
@@ -167,17 +168,17 @@ lq_etxff_packet_parser(struct olsr *olsr, struct interface *in_if, union olsr_ip
     return;
   }
 
-  if (lnk->last_seq_nr == olsr->olsr_seqno) {
+  if (lnk->last_seq_nr == pkt->seqno) {
 #ifndef REMOVE_LOG_WARN
     struct ipaddr_str buf;
 #endif
     OLSR_WARN(LOG_LQ_PLUGINS, "Got package with same sequence number from %s\n", olsr_ip_to_string(&buf, from_addr));
     return;
   }
-  if (lnk->last_seq_nr > olsr->olsr_seqno) {
-    seq_diff = (uint32_t) olsr->olsr_seqno + 65536 - lnk->last_seq_nr;
+  if (lnk->last_seq_nr > pkt->seqno) {
+    seq_diff = (uint32_t) pkt->seqno + 65536 - lnk->last_seq_nr;
   } else {
-    seq_diff = olsr->olsr_seqno - lnk->last_seq_nr;
+    seq_diff = pkt->seqno - lnk->last_seq_nr;
   }
 
   /* Jump in sequence numbers ? */
@@ -188,7 +189,7 @@ lq_etxff_packet_parser(struct olsr *olsr, struct interface *in_if, union olsr_ip
   lnk->received[lnk->activePtr]++;
   lnk->lost[lnk->activePtr] += (seq_diff - 1);
 
-  lnk->last_seq_nr = olsr->olsr_seqno;
+  lnk->last_seq_nr = pkt->seqno;
   lnk->missed_seconds = 0;
 }
 
index 88c288a..0316d87 100644 (file)
@@ -85,16 +85,16 @@ int my_DNS_TTL=0;
  * Data Used  : BmfInterfaces
  * ------------------------------------------------------------------------- */
 static void
-PacketReceivedFromOLSR(unsigned char *encapsulationUdpData, int len)
+PacketReceivedFromOLSR(const uint8_t *encapsulationUdpData, int len)
 {
-  struct ip *ipHeader;                 /* IP header inside the encapsulated IP packet */
-  struct ip6_hdr *ip6Header;                 /* IP header inside the encapsulated IP packet */
+  const struct ip *ipHeader;                 /* IP header inside the encapsulated IP packet */
+  const struct ip6_hdr *ip6Header;                 /* IP header inside the encapsulated IP packet */
   //union olsr_ip_addr mcSrc;            /* Original source of the encapsulated multicast packet */
   //union olsr_ip_addr mcDst;            /* Multicast destination of the encapsulated packet */
   struct TBmfInterface *walker;
   int stripped_len = 0;
-  ipHeader = (struct ip *)(ARM_NOWARN_ALIGN)encapsulationUdpData;
-  ip6Header = (struct ip6_hdr *)(ARM_NOWARN_ALIGN)encapsulationUdpData;
+  ipHeader = (const struct ip *)(ARM_CONST_NOWARN_ALIGN)encapsulationUdpData;
+  ip6Header = (const struct ip6_hdr *)(ARM_CONST_NOWARN_ALIGN)encapsulationUdpData;
   //mcSrc.v4 = ipHeader->ip_src;
   //mcDst.v4 = ipHeader->ip_dst;
   OLSR_DEBUG(LOG_PLUGINS, "MDNS PLUGIN got packet from OLSR message\n");
@@ -153,28 +153,16 @@ PacketReceivedFromOLSR(unsigned char *encapsulationUdpData, int len)
 
 
 void
-olsr_parser(union olsr_message *m, struct interface *in_if __attribute__ ((unused)),
+olsr_parser(struct olsr_message *msg,
+    const uint8_t *payload, const uint8_t *end,
+    struct interface *in_if __attribute__ ((unused)),
     union olsr_ip_addr *ipaddr, enum duplicate_status status __attribute__ ((unused)))
 {
-  union olsr_ip_addr originator;
-  int size;
-  uint32_t vtime;
   OLSR_DEBUG(LOG_PLUGINS, "MDNS PLUGIN: Received msg in parser\n");
-  /* Fetch the originator of the messsage */
-  if (olsr_cnf->ip_version == AF_INET) {
-    memcpy(&originator, &m->v4.originator, olsr_cnf->ipsize);
-    vtime = me_to_reltime(m->v4.olsr_vtime);
-    size = ntohs(m->v4.olsr_msgsize);
-  } else {
-    memcpy(&originator, &m->v6.originator, olsr_cnf->ipsize);
-    vtime = me_to_reltime(m->v6.olsr_vtime);
-    size = ntohs(m->v6.olsr_msgsize);
-  }
 
-  /* Check if message originated from this node.
-   *         If so - back off */
-  if (olsr_ipcmp(&originator, &olsr_cnf->router_id) == 0)
+  if (msg->type != MESSAGE_TYPE) {
     return;
+  }
 
   /* Check that the neighbor this message was received from is symmetric.
    *         If not - back off*/
@@ -184,11 +172,7 @@ olsr_parser(union olsr_message *m, struct interface *in_if __attribute__ ((unuse
     return;
   }
 
-  if (olsr_cnf->ip_version == AF_INET) {
-    PacketReceivedFromOLSR((unsigned char *)&m->v4.message, size - 12);
-  } else {
-    PacketReceivedFromOLSR((unsigned char *)&m->v6.message, size - 12 - 96);
-  }
+  PacketReceivedFromOLSR(payload, end - payload);
 }
 
 //Sends a packet in the OLSR network
@@ -196,59 +180,51 @@ void
 olsr_mdns_gen(unsigned char *packet, int len)
 {
   /* send buffer: huge */
-  char buffer[10240];
+  uint8_t buffer[10240];
   int aligned_size;
-  union olsr_message *message = (union olsr_message *)buffer;
+  struct olsr_message msg;
   struct interface *ifn;
+  uint8_t *sizeptr, *curr;
   
   aligned_size=len;
 
-if ((aligned_size % 4) != 0) {
+  if ((aligned_size % 4) != 0) {
     aligned_size = (aligned_size - (aligned_size % 4)) + 4;
   }
 
   /* fill message */
-  if (olsr_cnf->ip_version == AF_INET) {
-    /* IPv4 */
-    message->v4.olsr_msgtype = MESSAGE_TYPE;
-    message->v4.olsr_vtime = reltime_to_me(MDNS_VALID_TIME * MSEC_PER_SEC);
-    memcpy(&message->v4.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    //message->v4.ttl = MAX_TTL;
-    if (my_MDNS_TTL) message->v4.ttl = my_MDNS_TTL;
-    else message->v4.ttl = MAX_TTL;
-    message->v4.hopcnt = 0;
-    message->v4.seqno = htons(get_msg_seqno());
-
-    message->v4.olsr_msgsize = htons(aligned_size + 12);
-
-    memset(&message->v4.message, 0, aligned_size);
-    memcpy(&message->v4.message, packet, len);
-    aligned_size = aligned_size + 12;
-  } else {
-    /* IPv6 */
-    message->v6.olsr_msgtype = MESSAGE_TYPE;
-    message->v6.olsr_vtime = reltime_to_me(MDNS_VALID_TIME * MSEC_PER_SEC);
-    memcpy(&message->v6.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    //message->v6.ttl = MAX_TTL;
-    if (my_MDNS_TTL) message->v6.ttl = my_MDNS_TTL;
-    else message->v6.ttl = MAX_TTL;
-    message->v6.hopcnt = 0;
-    message->v6.seqno = htons(get_msg_seqno());
-
-    message->v6.olsr_msgsize = htons(aligned_size + 12 + 96);
-    memset(&message->v6.message, 0, aligned_size);
-    memcpy(&message->v6.message, packet, len);
-    aligned_size = aligned_size + 12 + 96;
+  msg.type = MESSAGE_TYPE;
+  msg.vtime = MDNS_VALID_TIME * MSEC_PER_SEC;
+  msg.originator = olsr_cnf->router_id;
+  if (my_MDNS_TTL) {
+    msg.ttl = my_MDNS_TTL;
+  }
+  else {
+    msg.ttl = MAX_TTL;
+  }
+  msg.hopcnt = 0;
+  msg.seqno = get_msg_seqno();
+  msg.size = 0; /* put in later ! */
+
+  curr = buffer;
+  sizeptr = olsr_put_msg_hdr(&curr, &msg);
+
+  /* put in real size of message */
+  pkt_put_u16(&sizeptr, curr - buffer + aligned_size);
+
+  memcpy(curr, packet, len);
+  if (len != aligned_size) {
+    memset(curr + len, 0, aligned_size - len);
   }
 
   /* looping trough interfaces */
   OLSR_FOR_ALL_INTERFACES(ifn) {
     //OLSR_PRINTF(1, "MDNS PLUGIN: Generating packet - [%s]\n", ifn->int_name);
 
-    if (net_outbuffer_push(ifn, message, aligned_size) != aligned_size) {
+    if (net_outbuffer_push(ifn, buffer, aligned_size) != aligned_size) {
       /* send data and try again */
       net_output(ifn);
-      if (net_outbuffer_push(ifn, message, aligned_size) != aligned_size) {
+      if (net_outbuffer_push(ifn, buffer, aligned_size) != aligned_size) {
         //OLSR_PRINTF(1, "MDNS PLUGIN: could not send on interface: %s\n", ifn->int_name);
       }
     }
index ca66754..0547440 100644 (file)
@@ -84,7 +84,8 @@ void CloseMDNS(void);
 void olsr_mdns_gen(unsigned char *packet, int len);
 
 /* Parser function to register with the scheduler */
-void olsr_parser(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_parser(struct olsr_message *, const uint8_t *, const uint8_t *,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 #endif /* _MDNS_MDNS_H */
 
index a9ebec6..6123bc5 100644 (file)
@@ -616,48 +616,36 @@ void
 olsr_namesvc_gen(void *foo __attribute__ ((unused)))
 {
   /* send buffer: huge */
-  char buffer[10240];
-  union olsr_message *message = (union olsr_message *)buffer;
+  uint8_t buffer[10240];
+  struct olsr_message msg;
   struct interface *ifn;
   int namesize;
+  uint8_t *curr, *sizeptr;
 
   /* fill message */
-  if (olsr_cnf->ip_version == AF_INET) {
-    /* IPv4 */
-    message->v4.olsr_msgtype = MESSAGE_TYPE;
-    message->v4.olsr_vtime = reltime_to_me(my_timeout * MSEC_PER_SEC);
-    memcpy(&message->v4.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    message->v4.ttl = MAX_TTL;
-    message->v4.hopcnt = 0;
-    message->v4.seqno = htons(get_msg_seqno());
-
-    namesize = encap_namemsg((struct namemsg *)(ARM_NOWARN_ALIGN)&message->v4.message);
-    namesize = namesize + sizeof(struct olsrmsg);
-
-    message->v4.olsr_msgsize = htons(namesize);
-  } else {
-    /* IPv6 */
-    message->v6.olsr_msgtype = MESSAGE_TYPE;
-    message->v6.olsr_vtime = reltime_to_me(my_timeout * MSEC_PER_SEC);
-    memcpy(&message->v6.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    message->v6.ttl = MAX_TTL;
-    message->v6.hopcnt = 0;
-    message->v6.seqno = htons(get_msg_seqno());
-
-    namesize = encap_namemsg((struct namemsg *)(ARM_NOWARN_ALIGN)&message->v6.message);
-    namesize = namesize + sizeof(struct olsrmsg6);
-
-    message->v6.olsr_msgsize = htons(namesize);
-  }
+  msg.type = MESSAGE_TYPE;
+  msg.vtime = my_timeout * MSEC_PER_SEC;
+  msg.originator = olsr_cnf->router_id;
+  msg.ttl = MAX_TTL;
+  msg.hopcnt = 0;
+  msg.seqno = get_msg_seqno();
+  msg.size = 0; /* fill in later */
+
+  curr = buffer;
+  sizeptr = olsr_put_msg_hdr(&curr, &msg);
+
+  namesize = encap_namemsg((struct namemsg *)(ARM_NOWARN_ALIGN)curr);
+  namesize += (curr-buffer);
+  pkt_put_u16(&sizeptr, namesize);
 
   /* looping trough interfaces */
   OLSR_FOR_ALL_INTERFACES(ifn) {
     OLSR_DEBUG(LOG_PLUGINS, "NAME PLUGIN: Generating packet - [%s]\n", ifn->int_name);
 
-    if (net_outbuffer_push(ifn, message, namesize) != namesize) {
+    if (net_outbuffer_push(ifn, buffer, namesize) != namesize) {
       /* send data and try again */
       net_output(ifn);
-      if (net_outbuffer_push(ifn, message, namesize) != namesize) {
+      if (net_outbuffer_push(ifn, buffer, namesize) != namesize) {
         OLSR_WARN(LOG_PLUGINS, "NAME PLUGIN: could not send on interface: %s\n", ifn->int_name);
       }
     }
@@ -670,37 +658,15 @@ olsr_namesvc_gen(void *foo __attribute__ ((unused)))
  * Parse name olsr message of NAME type
  */
 void
-olsr_parser(union olsr_message *m, struct interface *in_if __attribute__ ((unused)),
+olsr_parser(struct olsr_message *msg, const uint8_t *payload, const uint8_t *end,
+    struct interface *in_if __attribute__ ((unused)),
     union olsr_ip_addr *ipaddr, enum duplicate_status status __attribute__ ((unused)))
 {
-  struct namemsg *namemessage;
-  union olsr_ip_addr originator;
-  uint32_t vtime;
-  int size;
+  const struct namemsg *namemessage;
 
-  /* Fetch the originator of the messsage */
-  if (olsr_cnf->ip_version == AF_INET) {
-    memcpy(&originator, &m->v4.originator, olsr_cnf->ipsize);
-  } else {
-    memcpy(&originator, &m->v6.originator, olsr_cnf->ipsize);
-  }
-
-  /* Fetch the message based on IP version */
-  if (olsr_cnf->ip_version == AF_INET) {
-    vtime = me_to_reltime(m->v4.olsr_vtime);
-    size = ntohs(m->v4.olsr_msgsize);
-    namemessage = (struct namemsg *)(ARM_NOWARN_ALIGN)&m->v4.message;
-  } else {
-    vtime = me_to_reltime(m->v6.olsr_vtime);
-    size = ntohs(m->v6.olsr_msgsize);
-    namemessage = (struct namemsg *)(ARM_NOWARN_ALIGN)&m->v6.message;
-  }
-
-  /* Check if message originated from this node.
-     If so - back off */
-  if (olsr_ipcmp(&originator, &olsr_cnf->router_id) == 0)
+  if (msg->type != MESSAGE_TYPE) {
     return;
-
+  }
   /* Check that the neighbor this message was received from is symmetric.
      If not - back off */
   if (check_neighbor_link(ipaddr) != SYM_LINK) {
@@ -711,7 +677,8 @@ olsr_parser(union olsr_message *m, struct interface *in_if __attribute__ ((unuse
     return;
   }
 
-  update_name_entry(&originator, namemessage, size, vtime);
+  namemessage = (const struct namemsg *)(ARM_CONST_NOWARN_ALIGN)payload;
+  update_name_entry(&msg->originator, namemessage, end, msg->vtime);
 }
 
 /**
@@ -812,14 +779,14 @@ create_packet(struct name *to, struct name_entry *from)
  * decapsulate a received name, service or forwarder and update the corresponding hash table if necessary
  */
 void
-decap_namemsg(struct name *from_packet, struct name_entry **to, bool * this_table_changed)
+decap_namemsg(const struct name *from_packet, struct name_entry **to, bool * this_table_changed)
 {
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str strbuf;
 #endif
   struct name_entry *tmp;
   struct name_entry *already_saved_name_entries;
-  char *name = (char *)from_packet + sizeof(struct name);
+  const char *name = (const char *)from_packet + sizeof(struct name);
   int type_of_from_packet = ntohs(from_packet->type);
   unsigned int len_of_name = ntohs(from_packet->len);
   OLSR_DEBUG(LOG_PLUGINS, "NAME PLUGIN: decap type=%d, len=%u, name=%s\n", type_of_from_packet, len_of_name, name);
@@ -909,13 +876,13 @@ decap_namemsg(struct name *from_packet, struct name_entry **to, bool * this_tabl
  * name/service/forwarder entry in the message
  */
 void
-update_name_entry(union olsr_ip_addr *originator, struct namemsg *msg, int msg_size, uint32_t vtime)
+update_name_entry(union olsr_ip_addr *originator, const struct namemsg *msg, const uint8_t *end, uint32_t vtime)
 {
 #if !defined REMOVE_LOG_WARN
   struct ipaddr_str strbuf;
 #endif
-  char *pos, *end_pos;
-  struct name *from_packet;
+  const uint8_t *pos;
+  const struct name *from_packet;
   int i;
 
   OLSR_DEBUG(LOG_PLUGINS, "NAME PLUGIN: Received Message from %s\n", olsr_ip_to_string(&strbuf, originator));
@@ -926,11 +893,10 @@ update_name_entry(union olsr_ip_addr *originator, struct namemsg *msg, int msg_s
   }
 
   /* now add the names from the message */
-  pos = (char *)msg + sizeof(struct namemsg);
-  end_pos = pos + msg_size - sizeof(struct name *);     // at least one struct name has to be left
+  pos = (const uint8_t *)msg + sizeof(struct namemsg);
 
-  for (i = ntohs(msg->nr_names); i > 0 && pos < end_pos; i--) {
-    from_packet = (struct name *)(ARM_NOWARN_ALIGN)pos;
+  for (i = ntohs(msg->nr_names); i > 0 && pos < end; i--) {
+    from_packet = (const struct name *)(ARM_CONST_NOWARN_ALIGN)pos;
 
     switch (ntohs(from_packet->type)) {
     case NAME_HOST:
@@ -969,7 +935,7 @@ update_name_entry(union olsr_ip_addr *originator, struct namemsg *msg, int msg_s
  */
 void
 insert_new_name_in_list(union olsr_ip_addr *originator,
-                        struct list_node *this_list, struct name *from_packet, bool * this_table_changed, uint32_t vtime)
+                        struct list_node *this_list, const struct name *from_packet, bool * this_table_changed, uint32_t vtime)
 {
   int hash;
   struct db_entry *entry;
index 2445a9e..680efa8 100644 (file)
@@ -129,7 +129,8 @@ void olsr_expire_write_file_timer(void *);
 void olsr_namesvc_delete_db_entry(struct db_entry *);
 
 /* Parser function to register with the sceduler */
-void olsr_parser(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_parser(struct olsr_message *, const uint8_t *, const uint8_t *,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 /* callback for periodic timer */
 void olsr_namesvc_gen(void *);
@@ -145,15 +146,15 @@ void
   free_all_list_entries(struct list_node *);
 
 void
-  decap_namemsg(struct name *from_packet, struct name_entry **to, bool * this_table_changed);
+  decap_namemsg(const struct name *from_packet, struct name_entry **to, bool * this_table_changed);
 
 void
-  insert_new_name_in_list(union olsr_ip_addr *, struct list_node *, struct name *, bool *, uint32_t);
+  insert_new_name_in_list(union olsr_ip_addr *, struct list_node *, const struct name *, bool *, uint32_t);
 
 bool allowed_hostname_or_ip_in_service(const char *service_line, const regmatch_t * hostname_or_ip);
 
 void
-  update_name_entry(union olsr_ip_addr *, struct namemsg *, int, uint32_t);
+  update_name_entry(union olsr_ip_addr *, const struct namemsg *, const uint8_t *, uint32_t);
 
 void
   write_hosts_file(void);
index de271d6..c6a6461 100644 (file)
@@ -1101,10 +1101,10 @@ addObampNode4(struct in_addr *ipv4, u_int8_t status)
  * Return     : none
  * ------------------------------------------------------------------------- */
 static void
-PacketReceivedFromOLSR(void *originator, unsigned char *obamp_message, int len)
+PacketReceivedFromOLSR(union olsr_ip_addr *originator, const uint8_t *obamp_message, int len)
 {
   u_int8_t MessageID = obamp_message[0];
-  struct OBAMP_alive *alive;
+  const struct OBAMP_alive *alive;
 #if !defined(REMOVE_LOG_DEBUG)
   struct ipaddr_str buf;
 #endif
@@ -1119,7 +1119,7 @@ PacketReceivedFromOLSR(void *originator, unsigned char *obamp_message, int len)
 
   case OBAMP_ALIVE:
     OLSR_DEBUG(LOG_PLUGINS, "OBAMP Received OBAMP_ALIVE from %s\n", ip4_to_string(&buf, *myOriginator));
-    alive = (struct OBAMP_alive *)obamp_message;
+    alive = (const struct OBAMP_alive *)obamp_message;
     addObampNode4(myOriginator, alive->status);
     printObampNodesList();
 
@@ -1132,28 +1132,18 @@ PacketReceivedFromOLSR(void *originator, unsigned char *obamp_message, int len)
 
 //OLSR parser, received OBAMP messages
 void
-olsr_parser(union olsr_message *m, struct interface *in_if
+olsr_parser(struct olsr_message *msg, const uint8_t *payload, const uint8_t*end, struct interface *in_if
             __attribute__ ((unused)), union olsr_ip_addr *ipaddr, enum duplicate_status status __attribute__ ((unused)))
 {
-  union olsr_ip_addr originator;
-  int size;
-  uint32_t vtime;
   //OLSR_DEBUG(LOG_PLUGINS, "OBAMP PLUGIN: Received msg in parser\n");
 
-  /* Fetch the originator of the messsage */
-  if (olsr_cnf->ip_version == AF_INET) {
-    memcpy(&originator, &m->v4.originator, olsr_cnf->ipsize);
-    vtime = me_to_reltime(m->v4.olsr_vtime);
-    size = ntohs(m->v4.olsr_msgsize);
-  } else {
-    memcpy(&originator, &m->v6.originator, olsr_cnf->ipsize);
-    vtime = me_to_reltime(m->v6.olsr_vtime);
-    size = ntohs(m->v6.olsr_msgsize);
+  if (msg->type != MESSAGE_TYPE) {
+    return;
   }
 
   /* Check if message originated from this node.
    *         If so - back off */
-  if (olsr_ipcmp(&originator, &olsr_cnf->router_id) == 0)
+  if (olsr_ipcmp(&msg->originator, &olsr_cnf->router_id) == 0)
     return;
 
   /* Check that the neighbor this message was received from is symmetric.
@@ -1163,15 +1153,7 @@ olsr_parser(union olsr_message *m, struct interface *in_if
     return;
   }
 
-  if (olsr_cnf->ip_version == AF_INET) {
-
-    //IPv4 Case, process your OBAMP packet here:
-    PacketReceivedFromOLSR(&m->v4.originator, (unsigned char *)&m->v4.message, size - 12);
-  } else {
-    //IPv6 Case, process your OBAMP packet here:
-    PacketReceivedFromOLSR(&m->v6.originator, (unsigned char *)&m->v6.message, size - 12 - 96);
-  }
-
+  PacketReceivedFromOLSR(&msg->originator, payload, end - payload);
 }
 
 //Sends a packet in the OLSR network
@@ -1179,44 +1161,31 @@ void
 olsr_obamp_gen(unsigned char *packet, int len)
 {
   /* send buffer: huge */
-  char buffer[10240];
-  union olsr_message *message = (union olsr_message *)buffer;
+  uint8_t buffer[10240];
+  struct olsr_message msg;
   struct interface *ifn;
+  uint8_t *curr, *sizeptr;
 
   /* fill message */
-  if (olsr_cnf->ip_version == AF_INET) {
-    /* IPv4 */
-    message->v4.olsr_msgtype = MESSAGE_TYPE;
-    message->v4.olsr_vtime = reltime_to_me(OBAMP_VALID_TIME * MSEC_PER_SEC);
-    memcpy(&message->v4.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    message->v4.ttl = MAX_TTL;
-    message->v4.hopcnt = 0;
-    message->v4.seqno = htons(get_msg_seqno());
-
-    message->v4.olsr_msgsize = htons(len + 12);
-
-    memcpy(&message->v4.message, packet, len);
-    len = len + 12;
-  } else {
-    /* IPv6 */
-    message->v6.olsr_msgtype = MESSAGE_TYPE;
-    message->v6.olsr_vtime = reltime_to_me(OBAMP_VALID_TIME * MSEC_PER_SEC);
-    memcpy(&message->v6.originator, &olsr_cnf->router_id, olsr_cnf->ipsize);
-    message->v6.ttl = MAX_TTL;
-    message->v6.hopcnt = 0;
-    message->v6.seqno = htons(get_msg_seqno());
-
-    message->v6.olsr_msgsize = htons(len + 12 + 96);
-    memcpy(&message->v6.message, packet, len);
-    len = len + 12 + 96;
-  }
+  msg.type = MESSAGE_TYPE;
+  msg.vtime = OBAMP_VALID_TIME * MSEC_PER_SEC;
+  msg.originator = olsr_cnf->router_id;
+  msg.ttl = MAX_TTL;
+  msg.hopcnt = 0;
+  msg.seqno = get_msg_seqno();
+  msg.size = 0; /* put in later */
+
+  curr = buffer;
+  sizeptr = olsr_put_msg_hdr(&curr, &msg);
+  memcpy(curr, packet, len);
+  pkt_put_u16(&sizeptr, curr - buffer + len);
 
   /* looping trough interfaces */
   OLSR_FOR_ALL_INTERFACES(ifn) {
-    if (net_outbuffer_push(ifn, message, len) != len) {
+    if (net_outbuffer_push(ifn, buffer, len) != len) {
       /* send data and try again */
       net_output(ifn);
-      if (net_outbuffer_push(ifn, message, len) != len) {
+      if (net_outbuffer_push(ifn, buffer, len) != len) {
         OLSR_DEBUG(LOG_PLUGINS, "OBAMP PLUGIN: could not send on interface: %s\n", ifn->int_name);
       }
     }
@@ -1658,6 +1627,10 @@ InitOBAMP(void)
   struct olsr_cookie_info *tree_create_timer_cookie = NULL;
   struct olsr_cookie_info *outer_tree_create_timer_cookie = NULL;
 
+  if (olsr_cnf->ip_version == AF_INET6) {
+    OLSR_ERROR(LOG_PLUGINS, "OBAMP does not support IPv6 at the moment.");
+    return 1;
+  }
 
 //Setting OBAMP node state
   myState = malloc(sizeof(struct ObampNodeState));
index 172ecb4..34a545d 100644 (file)
@@ -124,7 +124,7 @@ int addObampNode4(struct in_addr *ipv4, u_int8_t status);
 
 
 /* Parser function to register with the scheduler */
-void olsr_parser(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_parser(struct olsr_message *, const uint8_t *, const uint8_t *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 //Struct to describe the other OBAMP nodes in the mesh network
 struct ObampNode {
index bed559a..6664e4f 100644 (file)
@@ -147,16 +147,16 @@ static void olsr_event(void);
 static int send_challenge(struct interface *olsr_if_config, const union olsr_ip_addr *);
 static int send_cres(struct interface *olsr_if_config, union olsr_ip_addr *, union olsr_ip_addr *, uint32_t, struct stamp *);
 static int send_rres(struct interface *olsr_if_config, union olsr_ip_addr *, union olsr_ip_addr *, uint32_t);
-static int parse_challenge(struct interface *olsr_if_config, char *);
-static int parse_cres(struct interface *olsr_if_config, char *);
-static int parse_rres(char *);
-static int check_auth(struct interface *olsr_if_config, char *, int *);
+static int parse_challenge(struct interface *olsr_if_config, uint8_t *);
+static int parse_cres(struct interface *olsr_if_config, uint8_t *);
+static int parse_rres(uint8_t *);
+static int check_auth(struct interface *olsr_if_config, uint8_t *, int *);
 #if 0
 static int ipc_send(char *, int);
 #endif
 static int add_signature(uint8_t *, int *);
-static int validate_packet(struct interface *olsr_if_config, const char *, int *);
-static char *secure_preprocessor(char *packet, struct interface *olsr_if_config, union olsr_ip_addr *from_addr, int *length);
+static int validate_packet(struct interface *olsr_if_config, const uint8_t *, int *);
+static uint8_t *secure_preprocessor(uint8_t *packet, struct interface *olsr_if_config, union olsr_ip_addr *from_addr, int *length);
 static void timeout_timestamps(void *);
 static int check_timestamp(struct interface *olsr_if_config, const union olsr_ip_addr *, time_t);
 static struct stamp *lookup_timestamp_entry(const union olsr_ip_addr *);
@@ -247,11 +247,11 @@ ipc_send(char *data __attribute__ ((unused)), int size __attribute__ ((unused)))
 }
 #endif
 
-static char *
-secure_preprocessor(char *packet, struct interface *olsr_if_config, union olsr_ip_addr *from_addr
+static uint8_t *
+secure_preprocessor(uint8_t *packet, struct interface *olsr_if_config, union olsr_ip_addr *from_addr
                     __attribute__ ((unused)), int *length)
 {
-  struct olsr *olsr = (struct olsr *)packet;
+  struct olsr_packet *olsr = (struct olsr_packet *)packet;
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
@@ -272,7 +272,7 @@ secure_preprocessor(char *packet, struct interface *olsr_if_config, union olsr_i
   OLSR_DEBUG(LOG_PLUGINS, "[ENC]Packet from %s OK size %d\n", olsr_ip_to_string(&buf, from_addr), *length);
 
   /* Fix OLSR packet header */
-  olsr->olsr_packlen = htons(*length);
+  olsr->size = htons(*length);
   return packet;
 }
 
@@ -286,7 +286,7 @@ secure_preprocessor(char *packet, struct interface *olsr_if_config, union olsr_i
  *
  */
 static int
-check_auth(struct interface *olsr_if_config, char *pck, int *size __attribute__ ((unused)))
+check_auth(struct interface *olsr_if_config, uint8_t *pck, int *size __attribute__ ((unused)))
 {
 
   OLSR_DEBUG(LOG_PLUGINS, "[ENC]Checking packet for challenge response message...\n");
@@ -332,7 +332,7 @@ add_signature(uint8_t * pck, int *size)
 
   msg = (struct s_olsrmsg *)(ARM_NOWARN_ALIGN)&pck[*size];
   /* Update size */
-  ((struct olsr *)pck)->olsr_packlen = htons(*size + sizeof(struct s_olsrmsg));
+  ((struct olsr_packet *)pck)->size = htons(*size + sizeof(struct s_olsrmsg));
 
   /* Fill packet header */
   msg->olsr_msgtype = MESSAGE_TYPE;
@@ -396,7 +396,7 @@ add_signature(uint8_t * pck, int *size)
 
 
 static int
-validate_packet(struct interface *olsr_if_config, const char *pck, int *size)
+validate_packet(struct interface *olsr_if_config, const uint8_t *pck, int *size)
 {
   int packetsize;
   uint8_t sha1_hash[SIGNATURE_SIZE];
@@ -647,7 +647,7 @@ send_challenge(struct interface *olsr_if_config, const union olsr_ip_addr *new_h
 }
 
 int
-parse_cres(struct interface *olsr_if_config, char *in_msg)
+parse_cres(struct interface *olsr_if_config, uint8_t *in_msg)
 {
   struct c_respmsg *msg;
   uint8_t sha1_hash[SIGNATURE_SIZE];
@@ -741,7 +741,7 @@ parse_cres(struct interface *olsr_if_config, char *in_msg)
 
 
 int
-parse_rres(char *in_msg)
+parse_rres(uint8_t *in_msg)
 {
   struct r_respmsg *msg;
   uint8_t sha1_hash[SIGNATURE_SIZE];
@@ -830,7 +830,7 @@ parse_rres(char *in_msg)
 
 
 int
-parse_challenge(struct interface *olsr_if_config, char *in_msg)
+parse_challenge(struct interface *olsr_if_config, uint8_t *in_msg)
 {
   struct challengemsg *msg;
   uint8_t sha1_hash[SIGNATURE_SIZE];
index f407eb1..4c404b1 100644 (file)
@@ -93,6 +93,7 @@ extern FILE *EXPORT(debug_handle);
  * we add an additional cast to (void *) to prevent the warning.
  */
 #define ARM_NOWARN_ALIGN void *
+#define ARM_CONST_NOWARN_ALIGN const void *
 
 #define ROUND_UP_TO_POWER_OF_2(val, pow2) (((val) + (pow2) - 1) & ~((pow2) - 1))
 
index 4980836..9a1c320 100644 (file)
@@ -141,15 +141,12 @@ olsr_flush_duplicate_entries(void)
 }
 
 bool
-olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate_status *status)
+olsr_is_duplicate_message(struct olsr_message *m, bool forwarding, enum duplicate_status *status)
 {
   struct avl_tree *tree;
   struct dup_entry *entry;
   int diff;
-  union olsr_ip_addr *mainIp;
   uint32_t valid_until;
-  uint16_t seqnr;
-  union olsr_ip_addr *ip;
   enum duplicate_status dummy = 0;
 
 #if !defined(REMOVE_LOG_DEBUG)
@@ -161,26 +158,13 @@ olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate
   }
 
   tree = forwarding ? &forward_set : &processing_set;
-  if (olsr_cnf->ip_version == AF_INET) {
-    seqnr = ntohs(m->v4.seqno);
-    ip = (union olsr_ip_addr *)&m->v4.originator;
-  } else {
-    seqnr = ntohs(m->v6.seqno);
-    ip = (union olsr_ip_addr *)&m->v6.originator;
-  }
-
-  // get main address
-  mainIp = olsr_lookup_main_addr_by_alias(ip);
-  if (mainIp == NULL) {
-    mainIp = ip;
-  }
 
   valid_until = GET_TIMESTAMP(DUPLICATE_VTIME);
 
   /* Check if entry exists */
-  entry = (struct dup_entry *)avl_find(tree, ip);
+  entry = (struct dup_entry *)avl_find(tree, &m->originator);
   if (entry == NULL) {
-    entry = olsr_create_duplicate_entry(ip, seqnr);
+    entry = olsr_create_duplicate_entry(&m->originator, m->seqno);
     if (entry != NULL) {
       avl_insert(tree, &entry->avl, 0);
       entry->tree = tree;
@@ -198,7 +182,7 @@ olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate
     olsr_change_timer(entry->validity_timer, DUPLICATE_CLEANUP_INTERVAL, DUPLICATE_CLEANUP_JITTER, OLSR_TIMER_ONESHOT);
   }
 
-  diff = olsr_seqno_diff(seqnr, entry->seqnr);
+  diff = olsr_seqno_diff(m->seqno, entry->seqnr);
 
   if (diff < -31) {
     entry->too_low_counter++;
@@ -206,14 +190,14 @@ olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate
     // client did restart with a lower number ?
     if (entry->too_low_counter > 16) {
       entry->too_low_counter = 0;
-      entry->seqnr = seqnr;
+      entry->seqnr = m->seqno;
       entry->array = 1;
 
       /* start with a new sequence number, so NO duplicate */
       *status = RESET_SEQNO_OLSR_MESSAGE;
       return false;
     }
-    OLSR_DEBUG(LOG_DUPLICATE_SET, "blocked %x from %s\n", seqnr, olsr_ip_to_string(&buf, mainIp));
+    OLSR_DEBUG(LOG_DUPLICATE_SET, "blocked %x from %s\n", m->seqno, olsr_ip_to_string(&buf, &m->originator));
 
     /* much too old */
     *status = TOO_OLD_OLSR_MESSAGE;
@@ -225,15 +209,15 @@ olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate
     uint32_t bitmask = 1 << ((uint32_t) (-diff));
 
     if ((entry->array & bitmask) != 0) {
-      OLSR_DEBUG(LOG_DUPLICATE_SET, "blocked %x (diff=%d,mask=%08x) from %s\n", seqnr, diff,
-                 entry->array, olsr_ip_to_string(&buf, mainIp));
+      OLSR_DEBUG(LOG_DUPLICATE_SET, "blocked %x (diff=%d,mask=%08x) from %s\n", m->seqno, diff,
+                 entry->array, olsr_ip_to_string(&buf, &m->originator));
 
       /* duplicate ! */
       *status = DUPLICATE_OLSR_MESSAGE;
       return true;
     }
     entry->array |= bitmask;
-    OLSR_DEBUG(LOG_DUPLICATE_SET, "processed %x from %s\n", seqnr, olsr_ip_to_string(&buf, mainIp));
+    OLSR_DEBUG(LOG_DUPLICATE_SET, "processed %x from %s\n", m->seqno, olsr_ip_to_string(&buf, &m->originator));
 
     /* no duplicate */
     *status = OLD_OLSR_MESSAGE;
@@ -244,8 +228,8 @@ olsr_is_duplicate_message(union olsr_message *m, bool forwarding, enum duplicate
     entry->array = 0;
   }
   entry->array |= 1;
-  entry->seqnr = seqnr;
-  OLSR_DEBUG(LOG_DUPLICATE_SET, "processed %x from %s\n", seqnr, olsr_ip_to_string(&buf, mainIp));
+  entry->seqnr = m->seqno;
+  OLSR_DEBUG(LOG_DUPLICATE_SET, "processed %x from %s\n", m->seqno, olsr_ip_to_string(&buf, &m->originator));
 
   /* no duplicate */
   *status = NEW_OLSR_MESSAGE;
index e1bbd38..97b6949 100644 (file)
@@ -72,7 +72,7 @@ enum duplicate_status {
 
 int EXPORT(olsr_seqno_diff) (uint16_t reference, uint16_t other);
 void olsr_init_duplicate_set(void);
-bool olsr_is_duplicate_message(union olsr_message *m, bool forward_set, enum duplicate_status *status);
+bool olsr_is_duplicate_message(struct olsr_message *m, bool forward_set, enum duplicate_status *status);
 void olsr_print_duplicate_table(void);
 void olsr_flush_duplicate_entries(void);
 
index e36e806..6dd6f7e 100644 (file)
@@ -267,39 +267,20 @@ olsr_prune_hna_entries(struct tc_entry *tc)
  * Forwards the message if that is to be done.
  */
 void
-olsr_input_hna(union olsr_message *msg, struct interface *in_if __attribute__ ((unused)),
+olsr_input_hna(struct olsr_message *msg, const uint8_t *payload, const uint8_t *end,
+    struct interface *in_if __attribute__ ((unused)),
     union olsr_ip_addr *from_addr, enum duplicate_status status)
 {
-  uint16_t msg_size, msg_seq;
-  uint8_t type, ttl, msg_hops;
-  uint32_t vtime;
-  union olsr_ip_addr originator;
   struct tc_entry *tc;
   struct olsr_ip_prefix prefix;
-  const uint8_t *curr, *curr_end;
+  const uint8_t *curr;
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
 
-  curr = (void *)msg;
 
   /* We are only interested in MID message types. */
-  pkt_get_u8(&curr, &type);
-  if (type != HNA_MESSAGE) {
-    return;
-  }
-
-  pkt_get_reltime(&curr, &vtime);
-  pkt_get_u16(&curr, &msg_size);
-
-  pkt_get_ipaddress(&curr, &originator);
-
-  /* Copy header values */
-  pkt_get_u8(&curr, &ttl);
-  pkt_get_u8(&curr, &msg_hops);
-  pkt_get_u16(&curr, &msg_seq);
-
-  if (!olsr_validate_address(&originator)) {
+  if (msg->type != HNA_MESSAGE) {
     return;
   }
 
@@ -313,22 +294,20 @@ olsr_input_hna(union olsr_message *msg, struct interface *in_if __attribute__ ((
     return;
   }
 
-  tc = olsr_locate_tc_entry(&originator);
-  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->hna_seq != -1 && olsr_seqno_diff(msg_seq, tc->hna_seq) <= 0) {
+  tc = olsr_locate_tc_entry(&msg->originator);
+  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->hna_seq != -1 && olsr_seqno_diff(msg->seqno, tc->hna_seq) <= 0) {
     /* this HNA is too old, discard it */
     return;
   }
-  tc->hna_seq = msg_seq;
+  tc->hna_seq = msg->seqno;
 
-  OLSR_DEBUG(LOG_HNA, "Processing HNA from %s, seq 0x%04x\n", olsr_ip_to_string(&buf, &originator), msg_seq);
+  OLSR_DEBUG(LOG_HNA, "Processing HNA from %s, seq 0x%04x\n", olsr_ip_to_string(&buf, &msg->originator), msg->seqno);
 
   /*
    * Now walk the list of HNA advertisements.
    */
-  curr_end = (uint8_t *)msg + msg_size;
-
-  while (curr + 2*olsr_cnf->ipsize <= curr_end) {
-
+  curr = payload;
+  while (curr + 2*olsr_cnf->ipsize <= end) {
     pkt_get_ipaddress(&curr, &prefix.prefix);
     pkt_get_prefixlen(&curr, &prefix.prefix_len);
 
@@ -336,7 +315,7 @@ olsr_input_hna(union olsr_message *msg, struct interface *in_if __attribute__ ((
       /*
        * Only update if it's not from us.
        */
-      olsr_update_hna_entry(&originator, &prefix, vtime, msg_seq);
+      olsr_update_hna_entry(&msg->originator, &prefix, msg->vtime, msg->seqno);
     }
   }
 
index 3da20b5..159e5bf 100644 (file)
@@ -63,7 +63,8 @@ AVLNODE2STRUCT(hna_tc_tree2hna, hna_net, hna_tc_node)
 #define OLSR_FOR_ALL_TC_HNA_ENTRIES_END() OLSR_FOR_ALL_AVL_ENTRIES_END()
 
 /* HNA msg input parser */
-void olsr_input_hna(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_input_hna(struct olsr_message *, const uint8_t *, const uint8_t *,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 void olsr_init_hna_set(void);
 void olsr_flush_hna_nets(struct tc_entry *tc);
index dd36f8e..8302b05 100644 (file)
@@ -610,11 +610,11 @@ update_link_entry(const union olsr_ip_addr *local,
   struct link_entry *entry;
 
   /* Add if not registered */
-  entry = add_link_entry(local, remote, &message->comm.orig, message->comm.vtime, message->htime, in_if);
+  entry = add_link_entry(local, remote, &message->comm->originator, message->comm->vtime, message->htime, in_if);
 
   /* Update ASYM_time */
-  entry->vtime = message->comm.vtime;
-  entry->ASYM_time = GET_TIMESTAMP(message->comm.vtime);
+  entry->vtime = message->comm->vtime;
+  entry->ASYM_time = GET_TIMESTAMP(message->comm->vtime);
 
   entry->status = check_link_status(message, in_if);
 
@@ -627,11 +627,11 @@ update_link_entry(const union olsr_ip_addr *local,
   case (ASYM_LINK):
 
     /* L_SYM_time = current time + validity time */
-    olsr_set_timer(&entry->link_sym_timer, message->comm.vtime,
+    olsr_set_timer(&entry->link_sym_timer, message->comm->vtime,
                    OLSR_LINK_SYM_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_link_sym_timer, entry, link_sym_timer_cookie);
 
     /* L_time = L_SYM_time + NEIGHB_HOLD_TIME */
-    olsr_set_link_timer(entry, message->comm.vtime + NEIGHB_HOLD_TIME * MSEC_PER_SEC);
+    olsr_set_link_timer(entry, message->comm->vtime + NEIGHB_HOLD_TIME * MSEC_PER_SEC);
     break;
   default:;
   }
@@ -817,23 +817,22 @@ void
 generate_hello(void *p) {
   struct interface *ifp = p;
   uint8_t msg_buffer[MAXMESSAGESIZE - OLSR_HEADERSIZE] __attribute__ ((aligned));
+  struct olsr_message msg;
   uint8_t *curr = msg_buffer;
   uint8_t *length_field, *last;
   struct link_entry *link;
   uint8_t writeLinkType, writeNeighType;
   OLSR_INFO(LOG_PACKET_CREATION, "Building Hello for %s\n-------------------\n", ifp->int_name);
 
-  pkt_put_u8(&curr, olsr_get_Hello_MessageId());
-  pkt_put_reltime(&curr, ifp->hello_validity);
+  msg.type = olsr_get_Hello_MessageId();
+  msg.vtime = ifp->hello_validity;
+  msg.size = 0; /* fill in later */
+  msg.originator = olsr_cnf->router_id;
+  msg.ttl = 1;
+  msg.hopcnt = 0;
+  msg.seqno = get_msg_seqno();
 
-  length_field = curr;
-  pkt_put_u16(&curr, 0); /* put in real messagesize later */
-
-  pkt_put_ipaddress(&curr, &olsr_cnf->router_id);
-
-  pkt_put_u8(&curr, 1);
-  pkt_put_u8(&curr, 0);
-  pkt_put_u16(&curr, get_msg_seqno());
+  length_field = olsr_put_msg_hdr(&curr, &msg);
 
   pkt_put_u16(&curr, 0);
   pkt_put_reltime(&curr, ifp->hello_interval);
@@ -888,7 +887,8 @@ generate_hello(void *p) {
 
       /* fix length field of hello block */
       if (linkstart != NULL) {
-        pkt_put_u16(&linkstart, curr + 2 - linkstart);
+        fprintf(stderr, "curr: %zu   linkstart: %zu    size: %u\n", (size_t)curr, (size_t)linkstart, (uint16_t)(curr + 2 - linkstart));
+        pkt_put_u16(&linkstart, (uint16_t)(curr + 2 - linkstart));
       }
     }
   }
index dd05c5f..26fcf0c 100644 (file)
 #include "olsr_types.h"
 #include "olsr_time.h"
 #include "ipcalc.h"
+#include "olsr_protocol.h"
 
 #define LQ_HELLO_MESSAGE      201
 #define LQ_TC_MESSAGE         202
 
 
-/* deserialized OLSR header */
-
-struct olsr_common {
-  uint8_t type;
-  uint16_t size;
-  uint32_t vtime;
-  union olsr_ip_addr orig;
-  uint8_t ttl;
-  uint8_t hops;
-  uint16_t seqno;
-};
-
 /* deserialized LQ_HELLO */
 
 struct lq_hello_neighbor {
@@ -73,20 +62,12 @@ struct lq_hello_neighbor {
 };
 
 struct lq_hello_message {
-  struct olsr_common comm;
+  struct olsr_message *comm;
   uint32_t htime;
   uint8_t will;
   struct lq_hello_neighbor *neigh;
 };
 
-/* serialized LQ_HELLO */
-
-struct lq_hello_info_header {
-  uint8_t link_code;
-  uint8_t reserved;
-  uint16_t size;
-};
-
 static INLINE void
 pkt_get_u8(const uint8_t ** p, uint8_t * var)
 {
index 320f176..4f5b7d5 100644 (file)
@@ -52,6 +52,7 @@
 #include "olsr_logging.h"
 #include "olsr_protocol.h"
 
+#include <assert.h>
 #include <stdlib.h>
 
 static struct mid_entry *olsr_lookup_mid_entry(const union olsr_ip_addr *);
@@ -248,6 +249,7 @@ olsr_insert_mid_entry(const union olsr_ip_addr *main_addr,
    * Locate first the hookup point
    */
   tc = olsr_locate_tc_entry(main_addr);
+  assert(tc);
 
   alias = olsr_cookie_malloc(mid_address_mem_cookie);
   alias->mid_alias_addr = *alias_addr;
@@ -469,38 +471,19 @@ olsr_print_mid_set(void)
  * Process an incoming MID message.
  */
 void
-olsr_input_mid(union olsr_message *msg, struct interface *input_if __attribute__ ((unused)),
+olsr_input_mid(struct olsr_message *msg, const uint8_t *payload, const uint8_t *end,
+    struct interface *input_if __attribute__ ((unused)),
     union olsr_ip_addr *from_addr, enum duplicate_status status)
 {
-  uint16_t msg_size, msg_seq;
-  uint8_t type, ttl, msg_hops;
-  const unsigned char *curr, *end;
-  uint32_t vtime;
-  union olsr_ip_addr originator, alias;
+  const uint8_t *curr;
+  union olsr_ip_addr alias;
   struct tc_entry *tc;
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
 
-  curr = (void *)msg;
-
   /* We are only interested in MID message types. */
-  pkt_get_u8(&curr, &type);
-  if (type != MID_MESSAGE) {
-    return;
-  }
-
-  pkt_get_reltime(&curr, &vtime);
-  pkt_get_u16(&curr, &msg_size);
-
-  pkt_get_ipaddress(&curr, &originator);
-
-  /* Copy header values */
-  pkt_get_u8(&curr, &ttl);
-  pkt_get_u8(&curr, &msg_hops);
-  pkt_get_u16(&curr, &msg_seq);
-
-  if (!olsr_validate_address(&originator)) {
+  if (msg->type != MID_MESSAGE) {
     return;
   }
 
@@ -514,29 +497,29 @@ olsr_input_mid(union olsr_message *msg, struct interface *input_if __attribute__
     return;
   }
 
-  tc = olsr_locate_tc_entry(&originator);
+  tc = olsr_locate_tc_entry(&msg->originator);
 
-  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->mid_seq != -1 && olsr_seqno_diff(msg_seq, tc->mid_seq) <= 0) {
+  if (status != RESET_SEQNO_OLSR_MESSAGE && tc->mid_seq != -1 && olsr_seqno_diff(msg->seqno, tc->mid_seq) <= 0) {
     /* this MID is too old, discard it */
     OLSR_DEBUG(LOG_MID, "Received too old mid from %s: %d < %d\n",
-        olsr_ip_to_string(&buf, from_addr), msg_seq, tc->mid_seq);
+        olsr_ip_to_string(&buf, from_addr), msg->seqno, tc->mid_seq);
     return;
   }
-  tc->mid_seq = msg_seq;
+  tc->mid_seq = msg->seqno;
 
   OLSR_DEBUG(LOG_MID, "Processing MID from %s with %d aliases, seq 0x%04x\n",
-             olsr_ip_to_string(&buf, &originator), (int)((msg_size-12)/olsr_cnf->ipsize), msg_seq);
+             olsr_ip_to_string(&buf, &msg->originator), (int)((end - payload)/olsr_cnf->ipsize), msg->seqno);
 
 
-  /* calculate end of message */
-  end = (uint8_t *)msg + msg_size;
+  curr = payload;
+
 
   /*
    * Now walk the list of alias advertisements one by one.
    */
   while (curr + olsr_cnf->ipsize <= end) {
     pkt_get_ipaddress(&curr, &alias);
-    olsr_update_mid_entry(&originator, &alias, vtime, msg_seq);
+    olsr_update_mid_entry(&msg->originator, &alias, msg->vtime, msg->seqno);
   }
 
   /*
@@ -548,6 +531,7 @@ olsr_input_mid(union olsr_message *msg, struct interface *input_if __attribute__
 void
 generate_mid(void *p  __attribute__ ((unused))) {
   struct interface *ifp, *allif;
+  struct olsr_message msg;
   uint8_t msg_buffer[MAXMESSAGESIZE - OLSR_HEADERSIZE] __attribute__ ((aligned));
   uint8_t *curr = msg_buffer;
   uint8_t *length_field, *last;
@@ -555,17 +539,17 @@ generate_mid(void *p  __attribute__ ((unused))) {
 
   OLSR_INFO(LOG_PACKET_CREATION, "Building MID\n-------------------\n");
 
-  pkt_put_u8(&curr, MID_MESSAGE);
-  pkt_put_reltime(&curr, olsr_cnf->mid_params.validity_time);
-
-  length_field = curr;
-  pkt_put_u16(&curr, 0); /* put in real messagesize later */
+  msg.type = MID_MESSAGE;
+  msg.vtime = olsr_cnf->mid_params.validity_time;
+  msg.size = 0; // fill in later
+  msg.originator = olsr_cnf->router_id;
+  msg.ttl = MAX_TTL;
+  msg.hopcnt = 0;
+  msg.seqno = get_msg_seqno();
 
-  pkt_put_ipaddress(&curr, &olsr_cnf->router_id);
+  curr = msg_buffer;
 
-  pkt_put_u8(&curr, 255);
-  pkt_put_u8(&curr, 0);
-  pkt_put_u16(&curr, get_msg_seqno());
+  length_field = olsr_put_msg_hdr(&curr, &msg);
 
   last = msg_buffer + sizeof(msg_buffer) - olsr_cnf->ipsize;
   OLSR_FOR_ALL_INTERFACES(allif) {
index 28bf4be..6ab0d15 100644 (file)
@@ -69,7 +69,8 @@ AVLNODE2STRUCT(alias_tree2mid, mid_entry, mid_tc_node);
 extern struct avl_tree mid_tree;
 
 /* MID msg input parser */
-void olsr_input_mid(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_input_mid(struct olsr_message *, const uint8_t *payload, const uint8_t *end,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 void olsr_init_mid_set(void);
 void olsr_delete_mid_entry(struct mid_entry *);
index f53023f..ad297cc 100644 (file)
@@ -320,7 +320,7 @@ net_output(struct interface *ifp)
   } dstaddr;
   int dstaddr_size;
   struct ptf *tmp_ptf;
-  union olsr_packet *outmsg;
+  struct olsr_packet *outmsg;
   int retval;
 
   if (ifp->netbuf.pending == 0) {
@@ -331,11 +331,11 @@ net_output(struct interface *ifp)
 
   retval = ifp->netbuf.pending;
 
-  outmsg = (union olsr_packet *)ifp->netbuf.buff;
+  outmsg = (struct olsr_packet *)ifp->netbuf.buff;
   /* Add the Packet seqno */
-  outmsg->v4.olsr_seqno = htons(ifp->olsr_seqnum++);
+  outmsg->seqno = htons(ifp->olsr_seqnum++);
   /* Set the packetlength */
-  outmsg->v4.olsr_packlen = htons(ifp->netbuf.pending);
+  outmsg->size = htons(ifp->netbuf.pending);
 
   if (olsr_cnf->ip_version == AF_INET) {
     /* IP version 4 */
index 4cae4ae..09f62e7 100644 (file)
@@ -62,6 +62,7 @@
 #include "lq_plugin.h"
 #include "olsr_logging.h"
 
+#include <assert.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <stdlib.h>
@@ -241,6 +242,28 @@ olsr_init_tables(void)
 }
 
 /**
+ * Shared code to write the message header
+ */
+uint8_t *olsr_put_msg_hdr(uint8_t **curr, struct olsr_message *msg)
+{
+  uint8_t *sizeptr;
+
+  assert(msg);
+  assert(curr);
+
+  pkt_put_u8(curr, msg->type);
+  pkt_put_reltime(curr, msg->vtime);
+  sizeptr = *curr;
+  pkt_put_u16(curr, msg->size);
+  pkt_put_ipaddress(curr, &msg->originator);
+  pkt_put_u8(curr, msg->ttl);
+  pkt_put_u8(curr, msg->hopcnt);
+  pkt_put_u16(curr, msg->seqno);
+
+  return sizeptr;
+}
+
+/**
  *Check if a message is to be forwarded and forward
  *it if necessary.
  *
@@ -249,29 +272,16 @@ olsr_init_tables(void)
  *@returns positive if forwarded
  */
 int
-olsr_forward_message(union olsr_message *m, struct interface *in_if, union olsr_ip_addr *from_addr)
+olsr_forward_message(struct olsr_message *msg, uint8_t *binary, struct interface *in_if, union olsr_ip_addr *from_addr)
 {
   union olsr_ip_addr *src;
   struct nbr_entry *neighbor;
-  int msgsize;
   struct interface *ifn;
+  uint8_t *tmp;
 #if !defined REMOVE_LOG_DEBUG
   struct ipaddr_str buf;
 #endif
 
-  /*
-   * Sven-Ola: We should not flood the mesh with overdue messages. Because
-   * of a bug in parser.c:parse_packet, we have a lot of messages because
-   * all older olsrd's have lq_fish enabled.
-   */
-  if (AF_INET == olsr_cnf->ip_version) {
-    if (m->v4.ttl < 2 || 255 < (int)m->v4.hopcnt + (int)m->v4.ttl)
-      return 0;
-  } else {
-    if (m->v6.ttl < 2 || 255 < (int)m->v6.hopcnt + (int)m->v6.ttl)
-      return 0;
-  }
-
   /* Lookup sender address */
   src = olsr_lookup_main_addr_by_alias(from_addr);
   if (!src)
@@ -280,46 +290,43 @@ olsr_forward_message(union olsr_message *m, struct interface *in_if, union olsr_
   neighbor = olsr_lookup_nbr_entry(src, true);
   if (!neighbor) {
     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because no nbr entry found for %s\n",
-        m->v4.olsr_msgtype, olsr_ip_to_string(&buf, src));
+        msg->type, olsr_ip_to_string(&buf, src));
     return 0;
   }
   if (!neighbor->is_sym) {
     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because received by non-symmetric neighbor %s\n",
-        m->v4.olsr_msgtype, olsr_ip_to_string(&buf, src));
+        msg->type, olsr_ip_to_string(&buf, src));
     return 0;
   }
 
   /* Check MPR */
   if (neighbor->mprs_count == 0) {
     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because we are no MPR for %s\n",
-        m->v4.olsr_msgtype, olsr_ip_to_string(&buf, src));
+        msg->type, olsr_ip_to_string(&buf, src));
     /* don't forward packages if not a MPR */
     return 0;
   }
 
   /* check if we already forwarded this message */
-  if (olsr_is_duplicate_message(m, true, NULL)) {
+  if (olsr_is_duplicate_message(msg, true, NULL)) {
     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d from %s because we already forwarded it.\n",
-        m->v4.olsr_msgtype, olsr_ip_to_string(&buf, src));
+        msg->type, olsr_ip_to_string(&buf, src));
     return 0;                   /* it's a duplicate, forget about it */
   }
 
   /* Treat TTL hopcnt */
-  if (olsr_cnf->ip_version == AF_INET) {
-    /* IPv4 */
-    m->v4.hopcnt++;
-    m->v4.ttl--;
-  } else {
-    /* IPv6 */
-    m->v6.hopcnt++;
-    m->v6.ttl--;
+  msg->hopcnt++;
+  msg->ttl--;
+  tmp = binary;
+  olsr_put_msg_hdr(&tmp, msg);
+
+  if (msg->ttl == 0) {
+    OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d from %s because TTL is 0.\n",
+        msg->type, olsr_ip_to_string(&buf, src));
+    return 0;                   /* TTL 0, forget about it */
   }
-
-  /* Update packet data */
-  msgsize = ntohs(m->v4.olsr_msgsize);
-
   OLSR_DEBUG(LOG_PACKET_PARSING, "Forwarding message type %d from %s.\n",
-      m->v4.olsr_msgtype, olsr_ip_to_string(&buf, src));
+      msg->type, olsr_ip_to_string(&buf, src));
 
   /* looping trough interfaces */
   OLSR_FOR_ALL_INTERFACES(ifn) {
@@ -331,22 +338,22 @@ olsr_forward_message(union olsr_message *m, struct interface *in_if, union olsr_
       /*
        * Check if message is to big to be piggybacked
        */
-      if (net_outbuffer_push(ifn, m, msgsize) != msgsize) {
+      if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
         /* Send */
         net_output(ifn);
         /* Buffer message */
         set_buffer_timer(ifn);
 
-        if (net_outbuffer_push(ifn, m, msgsize) != msgsize) {
-          OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
+        if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
+          OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msg->size);
         }
       }
     } else {
       /* No forwarding pending */
       set_buffer_timer(ifn);
 
-      if (net_outbuffer_push(ifn, m, msgsize) != msgsize) {
-        OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
+      if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
+        OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msg->size);
       }
     }
   }
index c7a7f47..0136760 100644 (file)
@@ -62,8 +62,10 @@ void
 
 uint16_t EXPORT(get_msg_seqno) (void);
 
+uint8_t *olsr_put_msg_hdr(uint8_t **curr, struct olsr_message *msg);
+
 int
-  olsr_forward_message(union olsr_message *, struct interface *, union olsr_ip_addr *);
+  olsr_forward_message(struct olsr_message *, uint8_t *binary, struct interface *, union olsr_ip_addr *);
 
 void
   set_buffer_timer(struct interface *);
index f21ca0a..b13f427 100644 (file)
@@ -326,29 +326,7 @@ struct hnamsg6 {
  * OLSR message (several can exist in one OLSR packet)
  */
 
-struct olsrmsg {
-  uint8_t olsr_msgtype;
-  uint8_t olsr_vtime;
-  uint16_t olsr_msgsize;
-  uint32_t originator;
-  uint8_t ttl;
-  uint8_t hopcnt;
-  uint16_t seqno;
-
-  union {
-    struct hellomsg hello;
-    struct olsr_tcmsg tc;
-    struct hnamsg hna;
-    struct midmsg mid;
-  } message;
-
-} __attribute__ ((packed));
-
-/*
- * Internal representation of the header.
- * Used for some code sharing between message parsers.
- */
-struct olsrmsg_hdr {
+struct olsr_message {
   uint8_t type;
   uint32_t vtime;
   uint16_t size;
@@ -356,63 +334,16 @@ struct olsrmsg_hdr {
   uint8_t ttl;
   uint8_t hopcnt;
   uint16_t seqno;
-} __attribute__ ((packed));
-
-/*
- *IPv6
- */
-
-struct olsrmsg6 {
-  uint8_t olsr_msgtype;
-  uint8_t olsr_vtime;
-  uint16_t olsr_msgsize;
-  struct in6_addr originator;
-  uint8_t ttl;
-  uint8_t hopcnt;
-  uint16_t seqno;
-
-  union {
-    struct hellomsg6 hello;
-    struct olsr_tcmsg6 tc;
-    struct hnamsg6 hna;
-    struct midmsg6 mid;
-  } message;
-
-} __attribute__ ((packed));
-
-
+};
 
 /*
  * Generic OLSR packet
  */
 
-struct olsr {
-  uint16_t olsr_packlen;               /* packet length */
-  uint16_t olsr_seqno;
-  struct olsrmsg olsr_msg[1];          /* variable messages */
-} __attribute__ ((packed));
-
-
-struct olsr6 {
-  uint16_t olsr_packlen;               /* packet length */
-  uint16_t olsr_seqno;
-  struct olsrmsg6 olsr_msg[1];         /* variable messages */
-} __attribute__ ((packed));
-
-
-/* IPv4 <-> IPv6 compability */
-
-union olsr_message {
-  struct olsrmsg v4;
-  struct olsrmsg6 v6;
-} __attribute__ ((packed));
-
-union olsr_packet {
-  struct olsr v4;
-  struct olsr6 v6;
-} __attribute__ ((packed));
-
-
+struct olsr_packet {
+  uint16_t size;               /* packet length */
+  uint16_t seqno;
+}  __attribute__ ((packed));
 #endif
 
 /*
index 37cd509..7ef6a7e 100644 (file)
@@ -51,6 +51,7 @@
 #include "log.h"
 #include "net_olsr.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <stdlib.h>
 
@@ -59,7 +60,7 @@
 #define EWOULDBLOCK WSAEWOULDBLOCK
 #endif
 
-static void parse_packet(struct olsr *, int, struct interface *, union olsr_ip_addr *);
+static void parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr);
 
 static struct parse_function_entry *parse_functions = NULL;
 static struct preprocessor_function_entry *preprocessor_functions = NULL;
@@ -191,29 +192,19 @@ olsr_packetparser_remove_function(packetparser_function * function)
   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)
+static void
+olsr_parse_msg_hdr(const uint8_t **curr, struct olsr_message *msg)
 {
-  const unsigned char *curr = (const void *)msg;
-  if (!msg) {
-    return NULL;
-  }
-
-  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;
+  assert(curr);
+  assert(msg);
+
+  pkt_get_u8(curr, &msg->type);
+  pkt_get_reltime(curr, &msg->vtime);
+  pkt_get_u16(curr, &msg->size);
+  pkt_get_ipaddress(curr, &msg->originator);
+  pkt_get_u8(curr, &msg->ttl);
+  pkt_get_u8(curr, &msg->hopcnt);
+  pkt_get_u16(curr, &msg->seqno);
 }
 
 /**
@@ -226,48 +217,51 @@ olsr_parse_msg_hdr(const union olsr_message *msg, struct olsrmsg_hdr *msg_hdr)
  *@return nada
  */
 static void
-parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
+parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
 {
-  union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
-  int msgsize;
+  struct olsr_packet pkt;
+  struct olsr_message msg;
   struct parse_function_entry *entry;
   struct packetparser_function_entry *packetparser;
   enum duplicate_status dup_status = 0;
-  int count = size - ((char *)m - (char *)olsr);
+  uint8_t *curr, *end;
+
 #if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
   struct ipaddr_str buf;
 #endif
 
+  curr = binary;
+  end = binary + size;
+
   /* packet smaller than minimal olsr packet ? */
-  if (count < 4) {
+  if (size < 4) {
+    OLSR_WARN(LOG_PACKET_PARSING, "Received too small packet (%u bytes) from %s\n",
+        size, olsr_ip_to_string(&buf, from_addr));
     return;
   }
-  if (ntohs(olsr->olsr_packlen) != (size_t) 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));
+
+  pkt_get_u16((const uint8_t **)&curr, &pkt.size);
+  pkt_get_u16((const uint8_t **)&curr, &pkt.seqno);
+
+  if (pkt.size != (size_t) size) {
+    OLSR_WARN(LOG_PACKET_PARSING, "Received packet from %s (%u bytes) has bad size field: %u bytes\n",
+              olsr_ip_to_string(&buf, from_addr), size, pkt.size);
     return;
   }
-  // translate sequence number to host order
-  olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
 
   // call packetparser
   for (packetparser = packetparser_functions; packetparser != NULL; packetparser = packetparser->next) {
-    packetparser->function(olsr, in_if, from_addr);
+    packetparser->function(&pkt, binary, in_if, from_addr);
   }
 
-  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)) {
-    if (count < MIN_MESSAGE_SIZE()) {
-      break;
-    }
-    msgsize = ntohs(olsr_cnf->ip_version == AF_INET ? m->v4.olsr_msgsize : m->v6.olsr_msgsize);
-
-    count -= msgsize;
+  for (;curr <= end - MIN_MESSAGE_SIZE(); curr += msg.size) {
+    const uint8_t *msg_payload = curr;
+    olsr_parse_msg_hdr(&msg_payload, &msg);
 
     /* 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 (curr + msg.size > end) {
+      OLSR_WARN(LOG_PACKET_PARSING, "Packet received from %s is too short (%u bytes) for message %u (%u bytes)!",
+          olsr_ip_to_string(&buf, from_addr), size, msg.type, msg.size);
       break;
     }
 
@@ -280,27 +274,35 @@ parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip
      */
 
     /* Should be the same for IPv4 and IPv6 */
-    if (olsr_ipcmp((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->router_id) == 0
-        || !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));
+    if (olsr_ipcmp(&msg.originator, &olsr_cnf->router_id) == 0
+        || !olsr_validate_address(&msg.originator)) {
+      OLSR_INFO(LOG_PACKET_PARSING, "Skip processing our own message coming from %s!\n",
+                olsr_ip_to_string(&buf, from_addr));
       continue;
     }
 
-    if (olsr_is_duplicate_message(m, false, &dup_status)) {
-      OLSR_INFO(LOG_PACKET_PARSING, "Not processing message duplicate from %s!\n",
-          olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
+    if (msg.ttl == 0 || (int)msg.ttl + (int)msg.hopcnt > 255) {
+      struct ipaddr_str buf2;
+      OLSR_WARN(LOG_PACKET_PARSING, "Malformed incoming message type %u from %s with originator %s: ttl=%u and hopcount=%u\n",
+          msg.type, olsr_ip_to_string(&buf, from_addr), olsr_ip_to_string(&buf2, &msg.originator), msg.ttl, msg.hopcnt);
+      continue;
+    }
+    if (olsr_is_duplicate_message(&msg, false, &dup_status)) {
+      OLSR_INFO(LOG_PACKET_PARSING, "Not processing message duplicate from %s (seqnr %u)!\n",
+          olsr_ip_to_string(&buf, &msg.originator), msg.seqno);
     }
     else {
+      OLSR_DEBUG(LOG_PACKET_PARSING, "Processing message type %u (seqno %u) from %s\n",
+          msg.type, msg.seqno, olsr_ip_to_string(&buf, &msg.originator));
       for (entry = parse_functions; entry != NULL; entry = entry->next) {
         /* Should be the same for IPv4 and IPv6 */
         /* Promiscuous or exact match */
-        if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
-          entry->function(m, in_if, from_addr, dup_status);
+        if ((entry->type == PROMISCUOUS) || (entry->type == msg.type)) {
+          entry->function(&msg, curr, end, in_if, from_addr, dup_status);
         }
       }
     }
-    olsr_forward_message(m, in_if, from_addr);
+    olsr_forward_message(&msg, curr, in_if, from_addr);
   }                             /* for olsr_msg */
 }
 
@@ -327,12 +329,12 @@ olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __att
     struct interface *olsr_in_if;
     union olsr_ip_addr from_addr;
     struct preprocessor_function_entry *entry;
-    char *packet;
+    uint8_t *packet;
     /* sockaddr_in6 is bigger than sockaddr !!!! */
     struct sockaddr_storage from;
     socklen_t fromlen;
-    int cc;
-    char inbuf[MAXMESSAGESIZE] __attribute__ ((aligned));
+    int size;
+    uint8_t inbuf[MAXMESSAGESIZE] __attribute__ ((aligned));
 
     if (32 < ++cpu_overload_exit) {
       OLSR_WARN(LOG_PACKET_PARSING, "CPU overload detected, ending olsr_input() loop\n");
@@ -340,10 +342,10 @@ olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __att
     }
 
     fromlen = sizeof(from);
-    cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf), 0, (struct sockaddr *)&from, &fromlen);
+    size = olsr_recvfrom(fd, inbuf, sizeof(inbuf), 0, (struct sockaddr *)&from, &fromlen);
 
-    if (cc <= 0) {
-      if (cc < 0 && errno != EWOULDBLOCK) {
+    if (size <= 0) {
+      if (size < 0 && errno != EWOULDBLOCK) {
         OLSR_WARN(LOG_PACKET_PARSING, "error recvfrom: %s", strerror(errno));
       }
       break;
@@ -355,12 +357,14 @@ olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __att
     if (olsr_cnf->ip_version == AF_INET) {
       /* IPv4 sender address */
       if (fromlen != sizeof(struct sockaddr_in)) {
+        OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
         break;
       }
       from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
     } else {
       /* IPv6 sender address */
       if (fromlen != sizeof(struct sockaddr_in6)) {
+        OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
         break;
       }
       from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
@@ -368,20 +372,23 @@ olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __att
 
     /* are we talking to ourselves? */
     if (if_ifwithaddr(&from_addr) != NULL) {
+      OLSR_INFO(LOG_PACKET_PARSING, "Ignore packet from ourself (%s).\n",
+          olsr_ip_to_string(&buf, &from_addr));
       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), cc);
+                olsr_ip_to_string(&buf, &from_addr), size);
       return;
     }
     // call preprocessors
     packet = &inbuf[0];
     for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
-      packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
+      packet = entry->function(packet, olsr_in_if, &from_addr, &size);
       // discard package ?
       if (packet == NULL) {
+        OLSR_INFO(LOG_PACKET_PARSING, "Discard package because of preprocessor\n");
         return;
       }
     }
@@ -389,98 +396,10 @@ olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __att
     /*
      * &from - sender
      * &inbuf.olsr
-     * cc - bytes read
+     * size - 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)
- *and passes the packet on to parse_packet().
- *
- *@param fd the filedescriptor that data should be read from.
- *@return nada
- */
-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;
-  socklen_t fromlen;
-  struct interface *olsr_in_if;
-  union olsr_ip_addr from_addr;
-  uint16_t pcklen;
-  struct preprocessor_function_entry *entry;
-  char *packet;
-  char inbuf[MAXMESSAGESIZE] __attribute__ ((aligned));
-#ifndef REMOVE_LOG_WARN
-  struct ipaddr_str buf;
-#endif
-
-  /* Host emulator receives IP address first to emulate
-     direct link */
-
-  int cc = recv(fd, (void *)from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
-  if (cc != (int)olsr_cnf->ipsize) {
-    OLSR_WARN(LOG_NETWORKING, "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) {
-    return;
-  }
-
-  /* Extract size */
-  cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK);  /* Win needs a cast */
-  if (cc != 2) {
-    if (cc <= 0) {
-      OLSR_ERROR(LOG_NETWORKING, "Lost olsr_switch connection - exit!\n");
-      olsr_exit(EXIT_FAILURE);
-    }
-    OLSR_WARN(LOG_NETWORKING, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
-    return;
+    parse_packet(packet, size, olsr_in_if, &from_addr);
   }
-  pcklen = ntohs(pcklen);
-
-  fromlen = sizeof(from);
-  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));
-    }
-    return;
-  }
-
-  if (cc != pcklen) {
-    OLSR_WARN(LOG_NETWORKING, "Could not read whole packet(size %d, read %d)\n", pcklen, cc);
-    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), cc);
-    return;
-  }
-  // call preprocessors
-  packet = &inbuf[0];
-  for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
-    packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
-    // discard package ?
-    if (packet == NULL) {
-      return;
-    }
-  }
-
-  /*
-   * &from - sender
-   * &inbuf.olsr
-   * cc - bytes read
-   */
-  parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
 }
 
 /*
index e9403b4..b66f89f 100644 (file)
@@ -52,7 +52,8 @@
 #define MIN_MESSAGE_SIZE()     ((int)(8 + olsr_cnf->ipsize))
 
 /* Function returns false if the message should not be forwarded */
-typedef void parse_function(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+typedef void parse_function(struct olsr_message *, const uint8_t *payload, const uint8_t *end,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 struct parse_function_entry {
   uint32_t type;                       /* If set to PROMISCUOUS all messages will be received */
@@ -60,14 +61,14 @@ struct parse_function_entry {
   struct parse_function_entry *next;
 };
 
-typedef char *preprocessor_function(char *packet, struct interface *, union olsr_ip_addr *, int *length);
+typedef uint8_t *preprocessor_function(uint8_t *packet, struct interface *, union olsr_ip_addr *, int *length);
 
 struct preprocessor_function_entry {
   preprocessor_function *function;
   struct preprocessor_function_entry *next;
 };
 
-typedef void packetparser_function(struct olsr *olsr, struct interface *in_if, union olsr_ip_addr *from_addr);
+typedef void packetparser_function(struct olsr_packet *pkt, uint8_t *binary, struct interface *in_if, union olsr_ip_addr *from_addr);
 
 struct packetparser_function_entry {
   packetparser_function *function;
@@ -75,37 +76,31 @@ struct packetparser_function_entry {
 };
 
 void
-  olsr_init_parser(void);
+olsr_init_parser(void);
 
 void
-  olsr_deinit_parser(void);
+olsr_deinit_parser(void);
 
 void
-  olsr_input(int, void *, unsigned int);
+olsr_input(int, void *, unsigned int);
 
 void
-  olsr_input_hostemu(int, void *, unsigned int);
-
-void
-  EXPORT(olsr_parser_add_function) (parse_function, uint32_t);
+EXPORT(olsr_parser_add_function) (parse_function, uint32_t);
 
 int
-  EXPORT(olsr_parser_remove_function) (parse_function);
+EXPORT(olsr_parser_remove_function) (parse_function);
 
 void
-  EXPORT(olsr_preprocessor_add_function) (preprocessor_function);
+EXPORT(olsr_preprocessor_add_function) (preprocessor_function);
 
 int
-  EXPORT(olsr_preprocessor_remove_function) (preprocessor_function);
+EXPORT(olsr_preprocessor_remove_function) (preprocessor_function);
 
 void
-  EXPORT(olsr_packetparser_add_function) (packetparser_function * function);
+EXPORT(olsr_packetparser_add_function) (packetparser_function * function);
 
 int
-  EXPORT(olsr_packetparser_remove_function) (packetparser_function * function);
-
-const unsigned char *olsr_parse_msg_hdr(const union olsr_message *, struct olsrmsg_hdr *);
-
+EXPORT(olsr_packetparser_remove_function) (packetparser_function * function);
 #endif
 
 /*
index c35ab19..85be1ec 100644 (file)
@@ -48,8 +48,8 @@
 #include "parser.h"
 #include "olsr_logging.h"
 
-static void olsr_input_hello(union olsr_message *, struct interface *, union olsr_ip_addr *,
-    enum duplicate_status);
+static void olsr_input_hello(struct olsr_message *msg, const uint8_t *payload, const uint8_t *end,
+    struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 static void process_message_neighbors(struct nbr_entry *, const struct lq_hello_message *);
 
@@ -99,7 +99,7 @@ process_message_neighbors(struct nbr_entry *neighbor, const struct lq_hello_mess
       continue;
     }
 
-    olsr_link_nbr_nbr2(neighbor, &message_neighbors->addr, message->comm.vtime);
+    olsr_link_nbr_nbr2(neighbor, &message_neighbors->addr, message->comm->vtime);
   }
 
   /* Second pass */
@@ -205,38 +205,29 @@ olsr_deinit_package_process(void)
 }
 
 static bool
-deserialize_hello(struct lq_hello_message *hello, const void *ser)
+deserialize_hello(struct lq_hello_message *hello, struct olsr_message *msg, const uint8_t *payload, const uint8_t *end)
 {
-  const unsigned char *limit;
-  uint8_t type;
-  uint16_t size;
-
-  const unsigned char *curr = ser;
-  pkt_get_u8(&curr, &type);
-  if (type != olsr_get_Hello_MessageId()) {
-    /* No need to do anything more */
-    return true;
-  }
-  pkt_get_reltime(&curr, &hello->comm.vtime);
-  pkt_get_u16(&curr, &size);
-  pkt_get_ipaddress(&curr, &hello->comm.orig);
+  const uint8_t *curr = payload;
+  hello->comm = msg;
 
-  pkt_get_u8(&curr, &hello->comm.ttl);
-  pkt_get_u8(&curr, &hello->comm.hops);
-  pkt_get_u16(&curr, &hello->comm.seqno);
+  /* parse HELLO specific header */
   pkt_ignore_u16(&curr);
-
   pkt_get_reltime(&curr, &hello->htime);
   pkt_get_u8(&curr, &hello->will);
 
   hello->neigh = NULL;
-  limit = ((const unsigned char *)ser) + size;
-  while (curr < limit) {
-    const struct lq_hello_info_header *info_head = (const struct lq_hello_info_header *)(const ARM_NOWARN_ALIGN)curr;
-    const unsigned char *limit2 = curr + ntohs(info_head->size);
-
-    curr = (const unsigned char *)(info_head + 1);
-    while (curr < limit2) {
+  while (curr < end) {
+    const uint8_t *ptr, *limit2;
+    uint8_t link_code;
+    uint16_t size;
+
+    ptr = curr;
+    pkt_get_u8(&curr, &link_code);
+    pkt_ignore_u8(&curr);
+    pkt_get_u16(&curr, &size);
+
+    limit2 = ptr + size;
+    while (curr + olsr_cnf->ipsize + olsr_sizeof_HelloLQ() <= limit2) {
       struct lq_hello_neighbor *neigh = olsr_malloc_lq_hello_neighbor();
       pkt_get_ipaddress(&curr, &neigh->addr);
 
@@ -247,8 +238,8 @@ deserialize_hello(struct lq_hello_message *hello, const void *ser)
         continue;
       }
 
-      neigh->link_type = EXTRACT_LINK(info_head->link_code);
-      neigh->neigh_type = EXTRACT_STATUS(info_head->link_code);
+      neigh->link_type = EXTRACT_LINK(link_code);
+      neigh->neigh_type = EXTRACT_STATUS(link_code);
 
       neigh->next = hello->neigh;
       hello->neigh = neigh;
@@ -332,11 +323,12 @@ hello_tap(struct lq_hello_message *message, struct interface *in_if, const union
 }
 
 static void
-olsr_input_hello(union olsr_message *msg, struct interface *inif, union olsr_ip_addr *from,
+olsr_input_hello(struct olsr_message *msg, const uint8_t *payload, const uint8_t *end,
+    struct interface *inif, union olsr_ip_addr *from,
     enum duplicate_status status __attribute__ ((unused)))
 {
   struct lq_hello_message hello;
-  if (!deserialize_hello(&hello, msg)) {
+  if (!deserialize_hello(&hello, msg, payload, end)) {
     hello_tap(&hello, inif, from);
   }
 }
index 50f5793..4503028 100644 (file)
@@ -52,7 +52,7 @@ void
   olsr_deinit_package_process(void);
 
 void
-  olsr_process_received_hello(union olsr_message *, struct interface *, union olsr_ip_addr *);
+  olsr_process_received_hello(struct olsr_message *, struct interface *, union olsr_ip_addr *);
 
 #endif
 
index ca6176d..1d3aa20 100644 (file)
@@ -704,6 +704,7 @@ olsr_print_tc_table(void)
  * @param pointer to upper border ip
  * @result 1 if lower/upper border ip have been set
  */
+#if 0
 static int
 olsr_calculate_tc_border(uint8_t lower_border,
                          union olsr_ip_addr *lower_border_ip, uint8_t upper_border, union olsr_ip_addr *upper_border_ip)
@@ -712,7 +713,7 @@ olsr_calculate_tc_border(uint8_t lower_border,
     return 0;
   }
   if (lower_border == 0xff) {
-    memset(lower_border_ip, 0, sizeof(lower_border_ip));
+    memset(lower_border_ip, 0, sizeof(*lower_border_ip));
   } else {
     int i;
 
@@ -725,7 +726,7 @@ olsr_calculate_tc_border(uint8_t lower_border,
   }
 
   if (upper_border == 0xff) {
-    memset(upper_border_ip, 0xff, sizeof(upper_border_ip));
+    memset(upper_border_ip, 0xff, sizeof(*upper_border_ip));
   } else {
     int i;
 
@@ -739,7 +740,7 @@ olsr_calculate_tc_border(uint8_t lower_border,
   }
   return 1;
 }
-
+#endif
 /*
  * Process an incoming TC or TC_LQ message.
  *
@@ -750,15 +751,15 @@ olsr_calculate_tc_border(uint8_t lower_border,
  * as every call to pkt_get increases the packet offset and
  * hence the spot we are looking at.
  */
+
 void
-olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute__ ((unused)),
+olsr_input_tc(struct olsr_message * msg, const uint8_t *payload, const uint8_t *end,
+    struct interface * input_if __attribute__ ((unused)),
     union olsr_ip_addr * from_addr, enum duplicate_status status)
 {
-  uint16_t size, msg_seq, ansn;
-  uint8_t type, ttl, msg_hops, lower_border, upper_border;
-  uint32_t vtime;
-  union olsr_ip_addr originator;
-  const unsigned char *limit, *curr;
+  uint16_t ansn;
+  uint8_t lower_border, upper_border;
+  const uint8_t *curr;
   struct tc_entry *tc;
   bool relevantTc;
 #if !defined REMOVE_LOG_DEBUG
@@ -767,11 +768,8 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
   union olsr_ip_addr lower_border_ip, upper_border_ip;
   int borderSet = 0;
 
-  curr = (void *)msg;
-
   /* We are only interested in TC message types. */
-  pkt_get_u8(&curr, &type);
-  if (type != olsr_get_TC_MessageId()) {
+  if (msg->type != olsr_get_TC_MessageId()) {
     return;
   }
 
@@ -785,22 +783,14 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
     return;
   }
 
-  pkt_get_reltime(&curr, &vtime);
-  pkt_get_u16(&curr, &size);
-
-  pkt_get_ipaddress(&curr, &originator);
-
-  /* Copy header values */
-  pkt_get_u8(&curr, &ttl);
-  pkt_get_u8(&curr, &msg_hops);
-  pkt_get_u16(&curr, &msg_seq);
+  curr = payload;
   pkt_get_u16(&curr, &ansn);
 
   /* Get borders */
   pkt_get_u8(&curr, &lower_border);
   pkt_get_u8(&curr, &upper_border);
 
-  tc = olsr_lookup_tc_entry(&originator);
+  tc = olsr_lookup_tc_entry(&msg->originator);
 
   /* TCs can be splitted, so we are looking for ANSNs equal or higher */
   if (tc && status != RESET_SEQNO_OLSR_MESSAGE && tc->tc_seq != -1 && olsr_seqno_diff(ansn, tc->ansn) < 0) {
@@ -812,29 +802,28 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
    * Generate a new tc_entry in the lsdb and store the sequence number.
    */
   if (!tc) {
-    tc = olsr_add_tc_entry(&originator);
+    tc = olsr_add_tc_entry(&msg->originator);
   }
 
   /*
    * Update the tc entry.
    */
-  tc->msg_hops = msg_hops;
-  tc->tc_seq = msg_seq;
+  tc->msg_hops = msg->hopcnt;
+  tc->tc_seq = msg->seqno;
   tc->ansn = ansn;
   tc->ignored = 0;
   tc->err_seq_valid = false;
   tc->is_virtual = false;
 
-  OLSR_DEBUG(LOG_TC, "Processing TC from %s, seq 0x%04x\n", olsr_ip_to_string(&buf, &originator), tc->tc_seq);
+  OLSR_DEBUG(LOG_TC, "Processing TC from %s, seq 0x%04x\n", olsr_ip_to_string(&buf, &msg->originator), tc->tc_seq);
 
   /*
    * Now walk the edge advertisements contained in the packet.
    */
 
-  limit = (unsigned char *)msg + size;
   borderSet = 0;
   relevantTc = false;
-  while (curr + olsr_cnf->ipsize + olsr_sizeof_TCLQ() <= limit) {
+  while (curr + olsr_cnf->ipsize + olsr_sizeof_TCLQ() <= end) {
     if (olsr_tc_update_edge(tc, ansn, &curr, &upper_border_ip)) {
       relevantTc = true;
     }
@@ -853,14 +842,16 @@ olsr_input_tc(union olsr_message * msg, struct interface * input_if __attribute_
   /*
    * Calculate real border IPs.
    */
+  assert(msg);
   if (borderSet) {
-    borderSet = olsr_calculate_tc_border(lower_border, &lower_border_ip, upper_border, &upper_border_ip);
+    // borderSet = olsr_calculate_tc_border(lower_border, &lower_border_ip, upper_border, &upper_border_ip);
   }
 
   /*
    * Set or change the expiration timer accordingly.
    */
-  olsr_set_timer(&tc->validity_timer, vtime,
+  assert(msg);
+  olsr_set_timer(&tc->validity_timer, msg->vtime,
                  OLSR_TC_VTIME_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_tc_entry, tc, tc_validity_timer_cookie);
 
   if (borderSet) {
index 9ad0fe4..4551d4c 100644 (file)
@@ -139,7 +139,8 @@ void olsr_print_tc_table(void);
 void olsr_time_out_tc_set(void);
 
 /* tc msg input parser */
-void olsr_input_tc(union olsr_message *, struct interface *, union olsr_ip_addr *, enum duplicate_status);
+void olsr_input_tc(struct olsr_message *, const uint8_t *payload,
+    const uint8_t *end, struct interface *, union olsr_ip_addr *, enum duplicate_status);
 
 /* tc_entry manipulation */
 struct tc_entry *EXPORT(olsr_lookup_tc_entry) (const union olsr_ip_addr *);