8c12ce49ed35a13bb0d3b096c8ca4b602eb3fdc6
[olsrd.git] / src / parser.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2004-2009, the olsr.org team - see HISTORY file
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright
14  *   notice, this list of conditions and the following disclaimer in
15  *   the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of olsr.org, olsrd nor the names of its
18  *   contributors may be used to endorse or promote products derived
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Visit http://www.olsr.org for more information.
35  *
36  * If you find this software useful feel free to make a donation
37  * to the project. For more information see the website or contact
38  * the copyright holders.
39  *
40  */
41
42 #include "parser.h"
43 #include "ipcalc.h"
44 #include "defs.h"
45 #include "process_package.h"
46 #include "olsr_time.h"
47 #include "duplicate_set.h"
48 #include "mid_set.h"
49 #include "olsr.h"
50 #include "os_net.h"
51 #include "olsr_logging.h"
52 #include "net_olsr.h"
53
54 #include <assert.h>
55 #include <errno.h>
56 #include <stdlib.h>
57
58 #ifdef WIN32
59 #undef EWOULDBLOCK
60 #define EWOULDBLOCK WSAEWOULDBLOCK
61 #endif
62
63 static void parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr);
64
65 static struct parse_function_entry *parse_functions = NULL;
66 static struct preprocessor_function_entry *preprocessor_functions = NULL;
67 static struct packetparser_function_entry *packetparser_functions = NULL;
68
69 static int olsr_forward_message(struct olsr_message *msg,
70     uint8_t *binary, struct interface *in_if, union olsr_ip_addr *from_addr);
71
72 /**
73  *Initialize the parser.
74  *
75  *@return nada
76  */
77 void
78 olsr_init_parser(void)
79 {
80   OLSR_INFO(LOG_PACKET_PARSING, "Initializing parser...\n");
81
82   /* Initialize the packet functions */
83   olsr_init_package_process();
84 }
85
86 void
87 olsr_deinit_parser(void)
88 {
89   OLSR_INFO(LOG_PACKET_PARSING, "Deinitializing parser...\n");
90   olsr_deinit_package_process();
91 }
92
93 void
94 olsr_parser_add_function(parse_function * function, uint32_t type)
95 {
96   struct parse_function_entry *new_entry;
97
98   new_entry = olsr_malloc(sizeof(*new_entry), "Register parse function");
99
100   new_entry->function = function;
101   new_entry->type = type;
102
103   /* Queue */
104   new_entry->next = parse_functions;
105   parse_functions = new_entry;
106
107   OLSR_INFO(LOG_PACKET_PARSING, "Register parse function: Added function for type %u\n", type);
108 }
109
110 int
111 olsr_parser_remove_function(parse_function * function)
112 {
113   struct parse_function_entry *entry, *prev;
114
115   for (entry = parse_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
116     if ((entry->function == function)) {
117       if (entry == parse_functions) {
118         parse_functions = entry->next;
119       } else {
120         prev->next = entry->next;
121       }
122       free(entry);
123       return 1;
124     }
125   }
126   return 0;
127 }
128
129 void
130 olsr_preprocessor_add_function(preprocessor_function * function)
131 {
132   struct preprocessor_function_entry *new_entry;
133
134   new_entry = olsr_malloc(sizeof(*new_entry), "Register preprocessor function");
135   new_entry->function = function;
136
137   /* Queue */
138   new_entry->next = preprocessor_functions;
139   preprocessor_functions = new_entry;
140
141   OLSR_INFO(LOG_PACKET_PARSING, "Registered preprocessor function\n");
142 }
143
144 int
145 olsr_preprocessor_remove_function(preprocessor_function * function)
146 {
147   struct preprocessor_function_entry *entry, *prev;
148
149   for (entry = preprocessor_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
150     if (entry->function == function) {
151       if (entry == preprocessor_functions) {
152         preprocessor_functions = entry->next;
153       } else {
154         prev->next = entry->next;
155       }
156       free(entry);
157       return 1;
158     }
159   }
160   return 0;
161 }
162
163 void
164 olsr_packetparser_add_function(packetparser_function * function)
165 {
166   struct packetparser_function_entry *new_entry;
167
168   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
169
170   new_entry->function = function;
171
172   /* Queue */
173   new_entry->next = packetparser_functions;
174   packetparser_functions = new_entry;
175
176   OLSR_INFO(LOG_PACKET_PARSING, "Registered packetparser  function\n");
177 }
178
179 int
180 olsr_packetparser_remove_function(packetparser_function * function)
181 {
182   struct packetparser_function_entry *entry, *prev;
183
184   for (entry = packetparser_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
185     if (entry->function == function) {
186       if (entry == packetparser_functions) {
187         packetparser_functions = entry->next;
188       } else {
189         prev->next = entry->next;
190       }
191       free(entry);
192       return 1;
193     }
194   }
195   return 0;
196 }
197
198 static void
199 olsr_parse_msg_hdr(const uint8_t **curr, struct olsr_message *msg)
200 {
201   assert(curr);
202   assert(msg);
203
204   msg->header = *curr;
205
206   pkt_get_u8(curr, &msg->type);
207   pkt_get_reltime(curr, &msg->vtime);
208   pkt_get_u16(curr, &msg->size);
209   pkt_get_ipaddress(curr, &msg->originator);
210   pkt_get_u8(curr, &msg->ttl);
211   pkt_get_u8(curr, &msg->hopcnt);
212   pkt_get_u16(curr, &msg->seqno);
213
214   msg->payload = *curr;
215   msg->end = msg->header + msg->size;
216 }
217
218 /**
219  *Process a newly received OLSR packet. Checks the type
220  *and to the neccessary convertions and call the
221  *corresponding functions to handle the information.
222  *@param from the sockaddr struct describing the sender
223  *@param olsr the olsr struct containing the message
224  *@param size the size of the message
225  *@return nada
226  */
227 static void
228 parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
229 {
230   struct olsr_packet pkt;
231   struct olsr_message msg;
232   struct parse_function_entry *entry;
233   struct packetparser_function_entry *packetparser;
234   enum duplicate_status dup_status = 0;
235   uint8_t *curr, *end;
236   const uint8_t *packet;
237
238 #if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
239   struct ipaddr_str buf;
240 #endif
241
242   curr = binary;
243   packet = binary;
244   end = binary + size;
245
246   /* packet smaller than minimal olsr packet ? */
247   if (size < 4) {
248     OLSR_WARN(LOG_PACKET_PARSING, "Received too small packet (%u bytes) from %s\n",
249         size, olsr_ip_to_string(&buf, from_addr));
250     return;
251   }
252
253   pkt_get_u16(&packet, &pkt.size);
254   pkt_get_u16(&packet, &pkt.seqno);
255
256   if (pkt.size != (size_t) size) {
257     OLSR_WARN(LOG_PACKET_PARSING, "Received packet from %s (%u bytes) has bad size field: %u bytes\n",
258               olsr_ip_to_string(&buf, from_addr), size, pkt.size);
259     return;
260   }
261
262   // call packetparser
263   for (packetparser = packetparser_functions; packetparser != NULL; packetparser = packetparser->next) {
264     packetparser->function(&pkt, binary, in_if, from_addr);
265   }
266
267   /* advance pointer to messages */
268   curr += 4;
269
270   for (;curr <= end - MIN_MESSAGE_SIZE(); curr += msg.size) {
271     const uint8_t *msg_payload = curr;
272     olsr_parse_msg_hdr(&msg_payload, &msg);
273
274     /* Check size of message */
275     if (curr + msg.size > end) {
276       OLSR_WARN(LOG_PACKET_PARSING, "Packet received from %s is too short (%u bytes) for message %u (%u bytes)!",
277           olsr_ip_to_string(&buf, from_addr), size, msg.type, msg.size);
278       break;
279     }
280     else if (msg.size == 0) {
281       OLSR_WARN(LOG_PACKET_PARSING, "Received a zero lengthed message from %s (typde %d), ignoring all further content of the packet!",
282           olsr_ip_to_string(&buf, from_addr), msg.type);
283       return;
284     }
285
286     /*RFC 3626 section 3.4:
287      *  2    If the time to live of the message is less than or equal to
288      *  '0' (zero), or if the message was sent by the receiving node
289      *  (i.e., the Originator Address of the message is the main
290      *  address of the receiving node): the message MUST silently be
291      *  dropped.
292      */
293
294     /* Should be the same for IPv4 and IPv6 */
295     if (olsr_ipcmp(&msg.originator, &olsr_cnf->router_id) == 0
296         || !olsr_validate_address(&msg.originator)) {
297       OLSR_INFO(LOG_PACKET_PARSING, "Skip processing our own message coming from %s!\n",
298                 olsr_ip_to_string(&buf, from_addr));
299       continue;
300     }
301
302     if (msg.ttl == 0 || (int)msg.ttl + (int)msg.hopcnt > 255) {
303 #if !defined(REMOVE_LOG_WARN)
304       struct ipaddr_str buf2;
305 #endif
306       OLSR_WARN(LOG_PACKET_PARSING, "Malformed incoming message type %u from %s with originator %s: ttl=%u and hopcount=%u\n",
307           msg.type, olsr_ip_to_string(&buf, from_addr), olsr_ip_to_string(&buf2, &msg.originator), msg.ttl, msg.hopcnt);
308       continue;
309     }
310     if (olsr_is_duplicate_message(&msg, false, &dup_status)) {
311       OLSR_INFO(LOG_PACKET_PARSING, "Not processing message duplicate from %s (seqnr %u)!\n",
312           olsr_ip_to_string(&buf, &msg.originator), msg.seqno);
313     }
314     else {
315       OLSR_DEBUG(LOG_PACKET_PARSING, "Processing message type %u (seqno %u) from %s\n",
316           msg.type, msg.seqno, olsr_ip_to_string(&buf, &msg.originator));
317       for (entry = parse_functions; entry != NULL; entry = entry->next) {
318         /* Should be the same for IPv4 and IPv6 */
319         /* Promiscuous or exact match */
320         if ((entry->type == PROMISCUOUS) || (entry->type == msg.type)) {
321           entry->function(&msg, in_if, from_addr, dup_status);
322         }
323       }
324     }
325     olsr_forward_message(&msg, curr, in_if, from_addr);
326   }                             /* for olsr_msg */
327 }
328
329 /**
330  *Processing OLSR data from socket. Reading data, setting
331  *wich interface recieved the message, Sends IPC(if used)
332  *and passes the packet on to parse_packet().
333  *
334  *@param fd the filedescriptor that data should be read from.
335  *@return nada
336  */
337 void
338 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
339 {
340   unsigned int cpu_overload_exit = 0;
341 #ifndef REMOVE_LOG_DEBUG
342   char addrbuf[128];
343 #endif
344 #if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
345   struct ipaddr_str buf;
346 #endif
347
348   for (;;) {
349     struct interface *olsr_in_if;
350     union olsr_ip_addr from_addr;
351     struct preprocessor_function_entry *entry;
352     uint8_t *packet;
353     /* sockaddr_in6 is bigger than sockaddr !!!! */
354     union olsr_sockaddr from;
355     socklen_t fromlen;
356     int size;
357     uint8_t inbuf[MAXMESSAGESIZE] __attribute__ ((aligned));
358
359     if (32 < ++cpu_overload_exit) {
360       OLSR_WARN(LOG_PACKET_PARSING, "CPU overload detected, ending olsr_input() loop\n");
361       break;
362     }
363
364     fromlen = sizeof(from);
365     size = os_recvfrom(fd, inbuf, sizeof(inbuf), 0, &from, &fromlen);
366
367     if (size <= 0) {
368       if (size < 0 && errno != EWOULDBLOCK) {
369         OLSR_WARN(LOG_PACKET_PARSING, "error recvfrom: %s", strerror(errno));
370       }
371       break;
372     }
373
374     OLSR_DEBUG(LOG_PACKET_PARSING, "Recieved a packet from %s (fd=%d)\n",
375                sockaddr_to_string(addrbuf, sizeof(addrbuf), (struct sockaddr *)&from, fromlen),
376                fd);
377
378     if (olsr_cnf->ip_version == AF_INET) {
379       /* IPv4 sender address */
380       if (fromlen != sizeof(struct sockaddr_in)) {
381         OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
382         break;
383       }
384       from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
385     } else {
386       /* IPv6 sender address */
387       if (fromlen != sizeof(struct sockaddr_in6)) {
388         OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
389         break;
390       }
391       from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
392     }
393
394     /* are we talking to ourselves? */
395     if (if_ifwithaddr(&from_addr) != NULL) {
396       OLSR_INFO(LOG_PACKET_PARSING, "Ignore packet from ourself (%s).\n",
397           olsr_ip_to_string(&buf, &from_addr));
398       return;
399     }
400     olsr_in_if = if_ifwithsock(fd);
401     if (olsr_in_if == NULL) {
402       OLSR_WARN(LOG_PACKET_PARSING, "Could not find input interface for message from %s size %d\n",
403                 olsr_ip_to_string(&buf, &from_addr), size);
404       return;
405     }
406     // call preprocessors
407     packet = &inbuf[0];
408     for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
409       packet = entry->function(packet, olsr_in_if, &from_addr, &size);
410       // discard package ?
411       if (packet == NULL) {
412         OLSR_INFO(LOG_PACKET_PARSING, "Discard package because of preprocessor\n");
413         return;
414       }
415     }
416
417     /*
418      * &from - sender
419      * &inbuf.olsr
420      * size - bytes read
421      */
422     parse_packet(packet, size, olsr_in_if, &from_addr);
423   }
424 }
425
426 /**
427  *Check if a message is to be forwarded and forward
428  *it if necessary.
429  *
430  *@param m the OLSR message recieved
431  *
432  *@returns positive if forwarded
433  */
434 static int
435 olsr_forward_message(struct olsr_message *msg, uint8_t *binary, struct interface *in_if, union olsr_ip_addr *from_addr)
436 {
437   union olsr_ip_addr *src;
438   struct nbr_entry *neighbor;
439   struct interface *ifn, *iterator;
440   uint8_t *tmp;
441 #if !defined REMOVE_LOG_DEBUG
442   struct ipaddr_str buf;
443 #endif
444
445   /* Lookup sender address */
446   src = olsr_lookup_main_addr_by_alias(from_addr);
447   if (!src)
448     src = from_addr;
449
450   neighbor = olsr_lookup_nbr_entry(src, true);
451   if (!neighbor) {
452     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because no nbr entry found for %s\n",
453         msg->type, olsr_ip_to_string(&buf, src));
454     return 0;
455   }
456   if (!neighbor->is_sym) {
457     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because received by non-symmetric neighbor %s\n",
458         msg->type, olsr_ip_to_string(&buf, src));
459     return 0;
460   }
461
462   /* Check MPR */
463   if (neighbor->mprs_count == 0) {
464     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d because we are no MPR for %s\n",
465         msg->type, olsr_ip_to_string(&buf, src));
466     /* don't forward packages if not a MPR */
467     return 0;
468   }
469
470   /* check if we already forwarded this message */
471   if (olsr_is_duplicate_message(msg, true, NULL)) {
472     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d from %s because we already forwarded it.\n",
473         msg->type, olsr_ip_to_string(&buf, src));
474     return 0;                   /* it's a duplicate, forget about it */
475   }
476
477   /* Treat TTL hopcnt */
478   msg->hopcnt++;
479   msg->ttl--;
480   tmp = binary;
481   olsr_put_msg_hdr(&tmp, msg);
482
483   if (msg->ttl == 0) {
484     OLSR_DEBUG(LOG_PACKET_PARSING, "Not forwarding message type %d from %s because TTL is 0.\n",
485         msg->type, olsr_ip_to_string(&buf, src));
486     return 0;                   /* TTL 0, forget about it */
487   }
488   OLSR_DEBUG(LOG_PACKET_PARSING, "Forwarding message type %d from %s.\n",
489       msg->type, olsr_ip_to_string(&buf, src));
490
491   /* looping trough interfaces */
492   OLSR_FOR_ALL_INTERFACES(ifn, iterator) {
493     if (net_output_pending(ifn)) {
494       /* dont forward to incoming interface if interface is mode ether */
495       if (in_if->mode == IF_MODE_ETHER && ifn == in_if)
496         continue;
497
498       /*
499        * Check if message is to big to be piggybacked
500        */
501       if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
502         /* Send */
503         net_output(ifn);
504         /* Buffer message */
505         set_buffer_timer(ifn);
506
507         if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
508           OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msg->size);
509         }
510       }
511     } else {
512       /* No forwarding pending */
513       set_buffer_timer(ifn);
514
515       if (net_outbuffer_push(ifn, binary, msg->size) != msg->size) {
516         OLSR_WARN(LOG_NETWORKING, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msg->size);
517       }
518     }
519   }
520
521   return 1;
522 }
523
524 /*
525  * Local Variables:
526  * c-basic-offset: 2
527  * indent-tabs-mode: nil
528  * End:
529  */