b3e1254f78f00dcebbecf2f72a15eade5d621dfc
[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
75 static char inbuf[MAXMESSAGESIZE+1];
76
77 static olsr_bool disp_pack_in = OLSR_FALSE;
78
79 void
80 parser_set_disp_pack_in(olsr_bool val)
81 {
82   disp_pack_in = val;
83 }
84
85 /**
86  *Initialize the parser. 
87  *
88  *@return nada
89  */
90 void
91 olsr_init_parser(void)
92 {
93   OLSR_PRINTF(3, "Initializing parser...\n");
94
95   /* Initialize the packet functions */
96   olsr_init_package_process();
97
98 }
99
100 void
101 olsr_parser_add_function(parse_function *function, olsr_u32_t type, int forwarding)
102 {
103   struct parse_function_entry *new_entry;
104
105   OLSR_PRINTF(3, "Parser: registering event for type %d\n", type);
106  
107
108   new_entry = olsr_malloc(sizeof(struct parse_function_entry), "Register parse function");
109
110   new_entry->function = function;
111   new_entry->type = type;
112   new_entry->caller_forwarding = forwarding;
113
114   /* Queue */
115   new_entry->next = parse_functions;
116   parse_functions = new_entry;
117
118   OLSR_PRINTF(3, "Register parse function: Added function for type %d\n", type);
119
120 }
121
122
123
124 int
125 olsr_parser_remove_function(parse_function *function, olsr_u32_t type, int forwarding)
126 {
127   struct parse_function_entry *entry, *prev;
128
129   entry = parse_functions;
130   prev = NULL;
131
132   while(entry)
133     {
134       if((entry->function == function) &&
135          (entry->type == type) &&
136          (entry->caller_forwarding == forwarding))
137         {
138           if(entry == parse_functions)
139             {
140               parse_functions = entry->next;
141             }
142           else
143             {
144               prev->next = entry->next;
145             }
146           free(entry);
147           return 1;
148         }
149
150       prev = entry;
151       entry = entry->next;
152     }
153
154   return 0;
155 }
156
157
158 /**
159  *Process a newly received OLSR packet. Checks the type
160  *and to the neccessary convertions and call the
161  *corresponding functions to handle the information.
162  *@param from the sockaddr struct describing the sender
163  *@param olsr the olsr struct containing the message
164  *@param size the size of the message
165  *@return nada
166  */
167
168 void
169 parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
170 {
171   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
172   struct unknown_message unkpacket;
173   int count;
174   int msgsize;
175   int processed;
176   struct parse_function_entry *entry;
177
178   count = size - ((char *)m - (char *)olsr);
179
180   if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version))
181     return;
182
183   if (ntohs(olsr->olsr_packlen) != size)
184     {
185       struct ipaddr_str buf;
186       OLSR_PRINTF(1, "Size error detected in received packet.\nRecieved %d, in packet %d\n", size, ntohs(olsr->olsr_packlen));
187             
188       olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!",
189              olsr_ip_to_string(&buf, from_addr));
190       return;
191     }
192
193   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr)); 
194       
195   /* Display packet */
196   if(disp_pack_in)
197     print_olsr_serialized_packet(stdout, (union olsr_packet *)olsr, size, from_addr);
198
199   if(olsr_cnf->ip_version == AF_INET)
200     msgsize = ntohs(m->v4.olsr_msgsize);
201   else
202     msgsize = ntohs(m->v6.olsr_msgsize);
203
204
205   /*
206    * Hysteresis update - for every OLSR package
207    */
208   if(olsr_cnf->use_hysteresis)
209     {
210       if(olsr_cnf->ip_version == AF_INET)
211         {
212           /* IPv4 */
213           update_hysteresis_incoming(from_addr, 
214                                      in_if,
215                                      ntohs(olsr->olsr_seqno));
216         }
217       else
218         {
219           /* IPv6 */
220           update_hysteresis_incoming(from_addr, 
221                                      in_if, 
222                                      ntohs(olsr->olsr_seqno));
223         }
224     }
225
226   if (olsr_cnf->lq_level > 0)
227     {
228       olsr_update_packet_loss(from_addr, in_if,
229                               ntohs(olsr->olsr_seqno));
230     }
231   
232   for ( ; count > 0; m = (union olsr_message *)((char *)m + (msgsize)))
233     {
234
235       processed = 0;      
236       if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version))
237         break;
238       
239       if(olsr_cnf->ip_version == AF_INET)
240         msgsize = ntohs(m->v4.olsr_msgsize);
241       else
242         msgsize = ntohs(m->v6.olsr_msgsize);
243       
244       count -= msgsize;
245
246       /* Check size of message */
247       if(count < 0)
248         {
249           struct ipaddr_str buf;
250           OLSR_PRINTF(1, "packet length error in  packet received from %s!",
251                       olsr_ip_to_string(&buf, from_addr));
252
253           olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!",
254                  olsr_ip_to_string(&buf, from_addr));
255           break;
256         }
257
258
259 #if 0
260       /*
261        * Sven-Ola: This code leads to flooding our meshes with invalid /
262        * overdue messages if lq_fish is enabled (which is true since 2005)
263        * because there was no "do not forward"-check in olsr.c. If a message
264        * (yes: ttl=0 is invalid) is received, we should say: Welcome message,
265        * let us evaluate! But: if TTL < 2 or TTL + hopcount is higher than
266        * plausible, we should not forward. See olsr.c:olsr_forward_message()
267        */
268        
269       /* Treat TTL hopcnt */
270       if(olsr_cnf->ip_version == AF_INET)
271         {
272           /* IPv4 */
273           if (m->v4.ttl <= 0 && olsr_cnf->lq_fish == 0)
274             {
275 #ifndef NODEBUG
276               struct ipaddr_str buf;
277 #endif
278               OLSR_PRINTF(2, "Dropping packet type %d from neigh %s with TTL 0\n", 
279                           m->v4.olsr_msgtype,
280                           olsr_ip_to_string(&buf, from_addr));
281               continue;
282             }
283         }
284       else
285         {
286           /* IPv6 */
287           if (m->v6.ttl <= 0 && olsr_cnf->lq_fish == 0) 
288             {
289 #ifndef NODEBUG
290               struct ipaddr_str buf;
291 #endif
292               OLSR_PRINTF(2, "Dropping packet type %d from %s with TTL 0\n", 
293                           m->v4.olsr_msgtype,
294                           olsr_ip_to_string(&buf, from_addr));
295               continue;
296             }
297         }
298 #endif
299
300       /*RFC 3626 section 3.4:
301        *  2    If the time to live of the message is less than or equal to
302        *  '0' (zero), or if the message was sent by the receiving node
303        *  (i.e., the Originator Address of the message is the main
304        *  address of the receiving node): the message MUST silently be
305        *  dropped.
306        */
307
308       /* Should be the same for IPv4 and IPv6 */
309       if(ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->main_addr) || !olsr_validate_address((union olsr_ip_addr *)&m->v4.originator))
310         {
311 #if !defined(NODEBUG) && defined(DEBUG)
312           struct ipaddr_str buf;
313 #endif
314 #ifdef DEBUG
315           OLSR_PRINTF(3, "Not processing message originating from %s!\n",
316             olsr_ip_to_string(&buf,(union olsr_ip_addr *)&m->v4.originator));
317 #endif
318           continue;
319         }
320
321
322       //printf("MESSAGETYPE: %d\n", m->v4.olsr_msgtype);
323
324       entry = parse_functions;
325
326       while(entry)
327         {
328           /* Should be the same for IPv4 and IPv6 */
329
330           /* Promiscuous or exact match */
331           if((entry->type == PROMISCUOUS) || 
332              (entry->type == m->v4.olsr_msgtype))
333             {
334               entry->function(m, in_if, from_addr);
335               if(entry->caller_forwarding)
336                 processed = 1;
337             }
338           entry = entry->next;
339         }
340
341
342       /* UNKNOWN PACKETTYPE */
343       if(processed == 0)
344         {
345 #ifndef NODEBUG
346           struct ipaddr_str buf;
347 #endif
348           unk_chgestruct(&unkpacket, m);
349           
350           OLSR_PRINTF(3, "Unknown type: %d, size %d, from %s\n",
351                       m->v4.olsr_msgtype,
352                       size,
353                       olsr_ip_to_string(&buf, &unkpacket.originator));
354
355           /* Forward message */
356           if(!ipequal(&unkpacket.originator, &olsr_cnf->main_addr))
357             {         
358               /* Forward */
359               olsr_forward_message(m, 
360                                    &unkpacket.originator, 
361                                    unkpacket.seqno, 
362                                    in_if,
363                                    from_addr);
364             }
365
366           /* Cancel loop here, otherwise olsrd just hangs forever at this point */
367           break;
368         }
369
370     } /* for olsr_msg */ 
371
372
373 }
374
375
376
377
378 /**
379  *Processing OLSR data from socket. Reading data, setting 
380  *wich interface recieved the message, Sends IPC(if used) 
381  *and passes the packet on to parse_packet().
382  *
383  *@param fd the filedescriptor that data should be read from.
384  *@return nada
385  */
386 void
387 olsr_input(int fd)
388 {
389   struct interface *olsr_in_if;
390   union olsr_ip_addr from_addr;
391   cpu_overload_exit = 0;
392   
393   for (;;) 
394     {
395 #if !defined(NODEBUG) && defined(DEBUG)
396       struct ipaddr_str buf;
397 #endif
398       /* sockaddr_in6 is bigger than sockaddr !!!! */
399       struct sockaddr_storage from;
400       socklen_t fromlen;
401       int cc;
402
403       if (32 < ++cpu_overload_exit)
404       {
405         OLSR_PRINTF(1, "CPU overload detected, ending olsr_input() loop\n");
406         break;
407       }
408       
409       fromlen = sizeof(struct sockaddr_storage);
410       cc = olsr_recvfrom(fd, 
411                          inbuf, 
412                          sizeof (inbuf), 
413                          0, 
414                          (struct sockaddr *)&from, 
415                          &fromlen);
416
417       if (cc <= 0) 
418         {
419           if (cc < 0 && errno != EWOULDBLOCK)
420             {
421               OLSR_PRINTF(1, "error recvfrom: %s", strerror(errno));
422               olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %m");
423             }
424           break;
425         }
426       if(olsr_cnf->ip_version == AF_INET)
427         {
428           /* IPv4 sender address */
429           from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
430         }
431       else
432         {
433           /* IPv6 sender address */
434           from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
435         }
436       
437       
438 #ifdef DEBUG
439       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));
440 #endif
441         
442         if ((olsr_cnf->ip_version == AF_INET) && (fromlen != sizeof (struct sockaddr_in)))
443           break;
444         else if ((olsr_cnf->ip_version == AF_INET6) && (fromlen != sizeof (struct sockaddr_in6)))
445           break;
446       
447       /* are we talking to ourselves? */
448       if(if_ifwithaddr(&from_addr) != NULL)
449         return;
450       
451       if((olsr_in_if = if_ifwithsock(fd)) == NULL)
452         {
453           struct ipaddr_str buf;
454           OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n",
455                       olsr_ip_to_string(&buf, &from_addr),
456                       cc);
457           olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n",
458                  olsr_ip_to_string(&buf, &from_addr),
459                  cc);
460           return ;
461         }
462
463       /*
464        * &from - sender
465        * &inbuf.olsr 
466        * cc - bytes read
467        */
468       parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
469     
470     }
471 }
472
473
474
475
476 /**
477  *Processing OLSR data from socket. Reading data, setting 
478  *wich interface recieved the message, Sends IPC(if used) 
479  *and passes the packet on to parse_packet().
480  *
481  *@param fd the filedescriptor that data should be read from.
482  *@return nada
483  */
484 void
485 olsr_input_hostemu(int fd)
486 {
487   /* sockaddr_in6 is bigger than sockaddr !!!! */
488   struct sockaddr_storage from;
489   socklen_t fromlen;
490   struct interface *olsr_in_if;
491   union olsr_ip_addr from_addr;
492   olsr_u16_t pcklen;
493
494   /* Host emulator receives IP address first to emulate
495      direct link */
496
497   int cc = recv(fd, from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
498   if(cc != (int)olsr_cnf->ipsize)
499     {
500       fprintf(stderr, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
501       memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
502     }
503
504   /* are we talking to ourselves? */
505   if(if_ifwithaddr(&from_addr) != NULL)
506     return;
507       
508   /* Extract size */
509   if((cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK)) != 2) /* Win needs a cast */
510     {
511       if(cc <= 0)
512         {
513           fprintf(stderr, "Lost olsr_switch connection - exit!\n");
514           olsr_exit(__func__, EXIT_FAILURE);
515         }
516       fprintf(stderr, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
517       return;
518     }
519   else
520     {
521       pcklen = ntohs(pcklen);
522     }
523
524   fromlen = sizeof(struct sockaddr_storage);
525   
526   cc = olsr_recvfrom(fd, 
527                      inbuf, 
528                      pcklen, 
529                      0, 
530                      (struct sockaddr *)&from, 
531                      &fromlen);
532
533   if (cc <= 0) 
534     {
535       if (cc < 0 && errno != EWOULDBLOCK)
536         {
537           const char * const err_msg = strerror(errno);
538           OLSR_PRINTF(1, "error recvfrom: %s", err_msg);
539           olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %s", err_msg);
540         }
541       return;
542     }
543   
544   if(cc != pcklen)
545     {
546       printf("Could not read whole packet(size %d, read %d)\n", pcklen, cc);
547       return;
548     }
549
550   if((olsr_in_if = if_ifwithsock(fd)) == NULL)
551     {
552       struct ipaddr_str buf;
553       OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n",
554                   olsr_ip_to_string(&buf, &from_addr),
555                   cc);
556       olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n",
557                   olsr_ip_to_string(&buf, &from_addr),
558                   cc);
559       return;
560     }
561   
562   /*
563    * &from - sender
564    * &inbuf.olsr 
565    * cc - bytes read
566    */
567   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
568   
569 }
570
571