Removed print_package.c, it does not even support ETX. Use tcpdump instead.
[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 "mantissa.h"
47 #include "duplicate_set.h"
48 #include "mid_set.h"
49 #include "olsr.h"
50 #include "net_os.h"
51 #include "log.h"
52 #include "net_olsr.h"
53
54 #include <errno.h>
55 #include <stdlib.h>
56
57 #ifdef WIN32
58 #undef EWOULDBLOCK
59 #define EWOULDBLOCK WSAEWOULDBLOCK
60 #endif
61
62 static void parse_packet(struct olsr *, int, struct interface *, union olsr_ip_addr *);
63
64
65 /* Sven-Ola: On very slow devices used in huge networks
66  * the amount of lq_tc messages is so high, that the
67  * recv() loop never ends. This is a small hack to end
68  * the loop in this cases
69  */
70
71 static struct parse_function_entry *parse_functions;
72 static struct preprocessor_function_entry *preprocessor_functions;
73 static struct packetparser_function_entry *packetparser_functions;
74
75 /**
76  *Initialize the parser.
77  *
78  *@return nada
79  */
80 void
81 olsr_init_parser(void)
82 {
83   OLSR_INFO(LOG_PACKET_PARSING, "Initializing parser...\n");
84
85   /* Initialize the packet functions */
86   olsr_init_package_process();
87 }
88
89 void
90 olsr_deinit_parser(void)
91 {
92   OLSR_INFO(LOG_PACKET_PARSING, "Deinitializing parser...\n");
93   olsr_deinit_package_process();
94 }
95
96 void
97 olsr_parser_add_function(parse_function * function, uint32_t type)
98 {
99   struct parse_function_entry *new_entry;
100
101   new_entry = olsr_malloc(sizeof(*new_entry), "Register parse function");
102
103   new_entry->function = function;
104   new_entry->type = type;
105
106   /* Queue */
107   new_entry->next = parse_functions;
108   parse_functions = new_entry;
109
110   OLSR_INFO(LOG_PACKET_PARSING, "Register parse function: Added function for type %u\n", type);
111 }
112
113 int
114 olsr_parser_remove_function(parse_function * function, uint32_t type)
115 {
116   struct parse_function_entry *entry, *prev;
117
118   for (entry = parse_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
119     if ((entry->function == function) && (entry->type == type)) {
120       if (entry == parse_functions) {
121         parse_functions = entry->next;
122       } else {
123         prev->next = entry->next;
124       }
125       free(entry);
126       return 1;
127     }
128   }
129   return 0;
130 }
131
132 void
133 olsr_preprocessor_add_function(preprocessor_function * function)
134 {
135   struct preprocessor_function_entry *new_entry;
136
137   new_entry = olsr_malloc(sizeof(*new_entry), "Register preprocessor function");
138   new_entry->function = function;
139
140   /* Queue */
141   new_entry->next = preprocessor_functions;
142   preprocessor_functions = new_entry;
143
144   OLSR_INFO(LOG_PACKET_PARSING, "Registered preprocessor function\n");
145 }
146
147 int
148 olsr_preprocessor_remove_function(preprocessor_function * function)
149 {
150   struct preprocessor_function_entry *entry, *prev;
151
152   for (entry = preprocessor_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
153     if (entry->function == function) {
154       if (entry == preprocessor_functions) {
155         preprocessor_functions = entry->next;
156       } else {
157         prev->next = entry->next;
158       }
159       free(entry);
160       return 1;
161     }
162   }
163   return 0;
164 }
165
166 void
167 olsr_packetparser_add_function(packetparser_function * function)
168 {
169   struct packetparser_function_entry *new_entry;
170
171   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
172
173   new_entry->function = function;
174
175   /* Queue */
176   new_entry->next = packetparser_functions;
177   packetparser_functions = new_entry;
178
179   OLSR_INFO(LOG_PACKET_PARSING, "Registered packetparser  function\n");
180 }
181
182 int
183 olsr_packetparser_remove_function(packetparser_function * function)
184 {
185   struct packetparser_function_entry *entry, *prev;
186
187   for (entry = packetparser_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
188     if (entry->function == function) {
189       if (entry == packetparser_functions) {
190         packetparser_functions = entry->next;
191       } else {
192         prev->next = entry->next;
193       }
194       free(entry);
195       return 1;
196     }
197   }
198   return 0;
199 }
200
201 /**
202  * Shared code to parse the message headers and validate the message originator.
203  */
204 const unsigned char *
205 olsr_parse_msg_hdr(const union olsr_message *msg, struct olsrmsg_hdr *msg_hdr)
206 {
207   const unsigned char *curr = (const void *)msg;
208   if (!msg) {
209     return NULL;
210   }
211
212   pkt_get_u8(&curr, &msg_hdr->type);
213   pkt_get_reltime(&curr, &msg_hdr->vtime);
214   pkt_get_u16(&curr, &msg_hdr->size);
215   pkt_get_ipaddress(&curr, &msg_hdr->originator);
216   pkt_get_u8(&curr, &msg_hdr->ttl);
217   pkt_get_u8(&curr, &msg_hdr->hopcnt);
218   pkt_get_u16(&curr, &msg_hdr->seqno);
219
220   if (!olsr_validate_address(&msg_hdr->originator)) {
221     return NULL;
222   }
223   return curr;
224 }
225
226 /**
227  *Process a newly received OLSR packet. Checks the type
228  *and to the neccessary convertions and call the
229  *corresponding functions to handle the information.
230  *@param from the sockaddr struct describing the sender
231  *@param olsr the olsr struct containing the message
232  *@param size the size of the message
233  *@return nada
234  */
235 static void
236 parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
237 {
238   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
239   int msgsize;
240   struct parse_function_entry *entry;
241   struct packetparser_function_entry *packetparser;
242   int count = size - ((char *)m - (char *)olsr);
243 #if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
244   struct ipaddr_str buf;
245 #endif
246
247   if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version)) {
248     return;
249   }
250   if (ntohs(olsr->olsr_packlen) != (size_t) size) {
251     OLSR_WARN(LOG_PACKET_PARSING, "Size error detected in received packet from %s.\nRecieved %d, in packet %d\n",
252               olsr_ip_to_string(&buf, from_addr), size, ntohs(olsr->olsr_packlen));
253     return;
254   }
255   // translate sequence number to host order
256   olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
257
258   // call packetparser
259   for (packetparser = packetparser_functions; packetparser != NULL; packetparser = packetparser->next) {
260     packetparser->function(olsr, in_if, from_addr);
261   }
262
263   msgsize = ntohs(olsr_cnf->ip_version == AF_INET ? m->v4.olsr_msgsize : m->v6.olsr_msgsize);
264
265   for (; count > 0; m = (union olsr_message *)((char *)m + msgsize)) {
266     bool forward = true;
267
268     if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version)) {
269       break;
270     }
271     msgsize = ntohs(olsr_cnf->ip_version == AF_INET ? m->v4.olsr_msgsize : m->v6.olsr_msgsize);
272
273     count -= msgsize;
274
275     /* Check size of message */
276     if (count < 0) {
277       OLSR_WARN(LOG_PACKET_PARSING, "packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
278       break;
279     }
280
281     /*RFC 3626 section 3.4:
282      *  2    If the time to live of the message is less than or equal to
283      *  '0' (zero), or if the message was sent by the receiving node
284      *  (i.e., the Originator Address of the message is the main
285      *  address of the receiving node): the message MUST silently be
286      *  dropped.
287      */
288
289     /* Should be the same for IPv4 and IPv6 */
290     if (olsr_ipcmp((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->router_id) == 0
291         || !olsr_validate_address((union olsr_ip_addr *)&m->v4.originator)) {
292       OLSR_INFO(LOG_PACKET_PARSING, "Not processing message originating from %s!\n",
293                 olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
294       continue;
295     }
296
297     for (entry = parse_functions; entry != NULL; entry = entry->next) {
298       /* Should be the same for IPv4 and IPv6 */
299       /* Promiscuous or exact match */
300       if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
301         if (!entry->function(m, in_if, from_addr))
302           forward = false;
303       }
304     }
305
306     if (forward) {
307       olsr_forward_message(m, in_if, from_addr);
308     }
309   }                             /* for olsr_msg */
310 }
311
312 /**
313  *Processing OLSR data from socket. Reading data, setting
314  *wich interface recieved the message, Sends IPC(if used)
315  *and passes the packet on to parse_packet().
316  *
317  *@param fd the filedescriptor that data should be read from.
318  *@return nada
319  */
320 void
321 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
322 {
323   unsigned int cpu_overload_exit = 0;
324 #ifndef REMOVE_LOG_DEBUG
325   char addrbuf[128];
326 #endif
327 #ifndef REMOVE_LOG_WARN
328   struct ipaddr_str buf;
329 #endif
330
331   for (;;) {
332     struct interface *olsr_in_if;
333     union olsr_ip_addr from_addr;
334     struct preprocessor_function_entry *entry;
335     char *packet;
336     /* sockaddr_in6 is bigger than sockaddr !!!! */
337     struct sockaddr_storage from;
338     socklen_t fromlen;
339     int cc;
340     char inbuf[MAXMESSAGESIZE + 1];
341
342     if (32 < ++cpu_overload_exit) {
343       OLSR_WARN(LOG_PACKET_PARSING, "CPU overload detected, ending olsr_input() loop\n");
344       break;
345     }
346
347     fromlen = sizeof(from);
348     cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf), 0, (struct sockaddr *)&from, &fromlen);
349
350     if (cc <= 0) {
351       if (cc < 0 && errno != EWOULDBLOCK) {
352         OLSR_WARN(LOG_PACKET_PARSING, "error recvfrom: %s", strerror(errno));
353       }
354       break;
355     }
356
357     OLSR_DEBUG(LOG_PACKET_PARSING, "Recieved a packet from %s\n",
358                sockaddr_to_string(addrbuf, sizeof(addrbuf), (struct sockaddr *)&from, fromlen));
359
360     if (olsr_cnf->ip_version == AF_INET) {
361       /* IPv4 sender address */
362       if (fromlen != sizeof(struct sockaddr_in)) {
363         break;
364       }
365       from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
366     } else {
367       /* IPv6 sender address */
368       if (fromlen != sizeof(struct sockaddr_in6)) {
369         break;
370       }
371       from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
372     }
373
374     /* are we talking to ourselves? */
375     if (if_ifwithaddr(&from_addr) != NULL) {
376       return;
377     }
378     olsr_in_if = if_ifwithsock(fd);
379     if (olsr_in_if == NULL) {
380       OLSR_WARN(LOG_PACKET_PARSING, "Could not find input interface for message from %s size %d\n",
381                 olsr_ip_to_string(&buf, &from_addr), cc);
382       return;
383     }
384     // call preprocessors
385     packet = &inbuf[0];
386     for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
387       packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
388       // discard package ?
389       if (packet == NULL) {
390         return;
391       }
392     }
393
394     /*
395      * &from - sender
396      * &inbuf.olsr
397      * cc - bytes read
398      */
399     parse_packet((struct olsr *)packet, cc, olsr_in_if, &from_addr);
400   }
401 }
402
403 /**
404  *Processing OLSR data from socket. Reading data, setting
405  *wich interface recieved the message, Sends IPC(if used)
406  *and passes the packet on to parse_packet().
407  *
408  *@param fd the filedescriptor that data should be read from.
409  *@return nada
410  */
411 void
412 olsr_input_hostemu(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
413 {
414   /* sockaddr_in6 is bigger than sockaddr !!!! */
415   struct sockaddr_storage from;
416   socklen_t fromlen;
417   struct interface *olsr_in_if;
418   union olsr_ip_addr from_addr;
419   uint16_t pcklen;
420   struct preprocessor_function_entry *entry;
421   char *packet;
422   char inbuf[MAXMESSAGESIZE + 1];
423 #ifndef REMOVE_LOG_WARN
424   struct ipaddr_str buf;
425 #endif
426
427   /* Host emulator receives IP address first to emulate
428      direct link */
429
430   int cc = recv(fd, from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
431   if (cc != (int)olsr_cnf->ipsize) {
432     OLSR_WARN(LOG_NETWORKING, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
433     memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
434   }
435
436   /* are we talking to ourselves? */
437   if (if_ifwithaddr(&from_addr) != NULL) {
438     return;
439   }
440
441   /* Extract size */
442   cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK);  /* Win needs a cast */
443   if (cc != 2) {
444     if (cc <= 0) {
445       OLSR_ERROR(LOG_NETWORKING, "Lost olsr_switch connection - exit!\n");
446       olsr_exit(EXIT_FAILURE);
447     }
448     OLSR_WARN(LOG_NETWORKING, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
449     return;
450   }
451   pcklen = ntohs(pcklen);
452
453   fromlen = sizeof(from);
454   cc = olsr_recvfrom(fd, inbuf, pcklen, 0, (struct sockaddr *)&from, &fromlen);
455   if (cc <= 0) {
456     if (cc < 0 && errno != EWOULDBLOCK) {
457       OLSR_WARN(LOG_NETWORKING, "error recvfrom: %s", strerror(errno));
458     }
459     return;
460   }
461
462   if (cc != pcklen) {
463     OLSR_WARN(LOG_NETWORKING, "Could not read whole packet(size %d, read %d)\n", pcklen, cc);
464     return;
465   }
466
467   olsr_in_if = if_ifwithsock(fd);
468   if (olsr_in_if == NULL) {
469     OLSR_WARN(LOG_NETWORKING, "Could not find input interface for message from %s size %d\n",
470               olsr_ip_to_string(&buf, &from_addr), cc);
471     return;
472   }
473   // call preprocessors
474   packet = &inbuf[0];
475   for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
476     packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
477     // discard package ?
478     if (packet == NULL) {
479       return;
480     }
481   }
482
483   /*
484    * &from - sender
485    * &inbuf.olsr
486    * cc - bytes read
487    */
488   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
489 }
490
491 /*
492  * Local Variables:
493  * c-basic-offset: 2
494  * indent-tabs-mode: nil
495  * End:
496  */