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