6d3a2ab9b36d0ded17aaa37ec02cf7bdeb451284
[olsrd.git] / src / parser.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2004, Andreas Tonnesen(andreto@olsr.org)
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 "hysteresis.h"
48 #include "duplicate_set.h"
49 #include "mid_set.h"
50 #include "olsr.h"
51 #include "rebuild_packet.h"
52 #include "net_os.h"
53 #include "log.h"
54 #include "print_packet.h"
55 #include "net_olsr.h"
56 #include "duplicate_handler.h"
57
58 #ifdef WIN32
59 #undef EWOULDBLOCK
60 #define EWOULDBLOCK WSAEWOULDBLOCK
61 #undef errno
62 #define errno WSAGetLastError()
63 char *StrError(unsigned int ErrNo);
64 #undef strerror
65 #define strerror(x) StrError(x)
66 #endif
67
68     /* Sven-Ola: On very slow devices used in huge networks
69  * the amount of lq_tc messages is so high, that the
70  * recv() loop never ends. This is a small hack to end
71  * the loop in this cases
72  */
73
74 unsigned int cpu_overload_exit = 0;
75
76 struct parse_function_entry *parse_functions;
77 struct preprocessor_function_entry *preprocessor_functions;
78 struct packetparser_function_entry *packetparser_functions;
79
80 static uint32_t inbuf_aligned[MAXMESSAGESIZE/sizeof(uint32_t) + 1];
81 static char *inbuf = (char *)inbuf_aligned;
82
83 static bool disp_pack_in = false;
84
85 void
86 parser_set_disp_pack_in(bool val)
87 {
88   disp_pack_in = val;
89 }
90
91 /**
92  *Initialize the parser.
93  *
94  *@return nada
95  */
96 void
97 olsr_init_parser(void)
98 {
99   OLSR_PRINTF(3, "Initializing parser...\n");
100
101   /* Initialize the packet functions */
102   olsr_init_package_process();
103
104 }
105
106 void
107 olsr_destroy_parser(void) {
108   struct parse_function_entry *pe, *pe_next;
109   struct preprocessor_function_entry *ppe, *ppe_next;
110   struct packetparser_function_entry *pae, *pae_next;
111
112   for (pe = parse_functions; pe; pe = pe_next) {
113     pe_next = pe->next;
114     free (pe);
115   }
116   for (ppe = preprocessor_functions; ppe; ppe = ppe_next) {
117     ppe_next = ppe->next;
118     free (ppe);
119   }
120   for (pae = packetparser_functions; pae; pae = pae_next) {
121     pae_next = pae->next;
122     free(pae);
123   }
124 }
125
126 void
127 olsr_parser_add_function(parse_function * function, uint32_t type)
128 {
129   struct parse_function_entry *new_entry;
130
131   OLSR_PRINTF(3, "Parser: registering event for type %d\n", type);
132
133   new_entry = olsr_malloc(sizeof(struct parse_function_entry), "Register parse function");
134
135   new_entry->function = function;
136   new_entry->type = type;
137
138   /* Queue */
139   new_entry->next = parse_functions;
140   parse_functions = new_entry;
141
142   OLSR_PRINTF(3, "Register parse function: Added function for type %d\n", type);
143
144 }
145
146 int
147 olsr_parser_remove_function(parse_function * function, uint32_t type)
148 {
149   struct parse_function_entry *entry, *prev;
150
151   entry = parse_functions;
152   prev = NULL;
153
154   while (entry) {
155     if ((entry->function == function) && (entry->type == type)) {
156       if (entry == parse_functions) {
157         parse_functions = entry->next;
158       } else {
159         prev->next = entry->next;
160       }
161       free(entry);
162       return 1;
163     }
164
165     prev = entry;
166     entry = entry->next;
167   }
168
169   return 0;
170 }
171
172 void
173 olsr_preprocessor_add_function(preprocessor_function * function)
174 {
175   struct preprocessor_function_entry *new_entry;
176
177   OLSR_PRINTF(3, "Parser: registering preprocessor\n");
178
179   new_entry = olsr_malloc(sizeof(struct preprocessor_function_entry), "Register preprocessor function");
180
181   new_entry->function = function;
182
183   /* Queue */
184   new_entry->next = preprocessor_functions;
185   preprocessor_functions = new_entry;
186
187   OLSR_PRINTF(3, "Registered preprocessor function\n");
188
189 }
190
191 int
192 olsr_preprocessor_remove_function(preprocessor_function * function)
193 {
194   struct preprocessor_function_entry *entry, *prev;
195
196   entry = preprocessor_functions;
197   prev = NULL;
198
199   while (entry) {
200     if (entry->function == function) {
201       if (entry == preprocessor_functions) {
202         preprocessor_functions = entry->next;
203       } else {
204         prev->next = entry->next;
205       }
206       free(entry);
207       return 1;
208     }
209
210     prev = entry;
211     entry = entry->next;
212   }
213
214   return 0;
215 }
216
217 void
218 olsr_packetparser_add_function(packetparser_function * function)
219 {
220   struct packetparser_function_entry *new_entry;
221
222   OLSR_PRINTF(3, "Parser: registering packetparser\n");
223
224   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
225
226   new_entry->function = function;
227
228   /* Queue */
229   new_entry->next = packetparser_functions;
230   packetparser_functions = new_entry;
231
232   OLSR_PRINTF(3, "Registered packetparser  function\n");
233
234 }
235
236 int
237 olsr_packetparser_remove_function(packetparser_function * function)
238 {
239   struct packetparser_function_entry *entry, *prev;
240
241   entry = packetparser_functions;
242   prev = NULL;
243
244   while (entry) {
245     if (entry->function == function) {
246       if (entry == packetparser_functions) {
247         packetparser_functions = entry->next;
248       } else {
249         prev->next = entry->next;
250       }
251       free(entry);
252       return 1;
253     }
254
255     prev = entry;
256     entry = entry->next;
257   }
258
259   return 0;
260 }
261
262 /**
263  *Process a newly received OLSR packet. Checks the type
264  *and to the neccessary convertions and call the
265  *corresponding functions to handle the information.
266  *@param from the sockaddr struct describing the sender
267  *@param olsr the olsr struct containing the message
268  *@param size the size of the message
269  *@return nada
270  */
271
272 void
273 parse_packet(struct olsr *olsr, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
274 {
275   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
276   int count;
277   int msgsize;
278   uint16_t seqno;
279   struct parse_function_entry *entry;
280   struct packetparser_function_entry *packetparser;
281
282   count = size - ((char *)m - (char *)olsr);
283
284   if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version))
285     return;
286
287   if (ntohs(olsr->olsr_packlen) !=(uint16_t) size) {
288     struct ipaddr_str buf;
289     OLSR_PRINTF(1, "Size error detected in received packet.\nRecieved %d, in packet %d\n", size, ntohs(olsr->olsr_packlen));
290
291     olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
292     return;
293   }
294   // translate sequence number to host order
295   olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
296
297   // call packetparser
298   packetparser = packetparser_functions;
299   while (packetparser) {
300     packetparser->function(olsr, in_if, from_addr);
301     packetparser = packetparser->next;
302   }
303
304   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr));
305
306   /* Display packet */
307   if (disp_pack_in)
308     print_olsr_serialized_packet(stdout, (union olsr_packet *)olsr, size, from_addr);
309
310   /*
311    * Hysteresis update - for every OLSR package
312    */
313   if (olsr_cnf->use_hysteresis) {
314     if (olsr_cnf->ip_version == AF_INET) {
315       /* IPv4 */
316       update_hysteresis_incoming(from_addr, in_if, ntohs(olsr->olsr_seqno));
317     } else {
318       /* IPv6 */
319       update_hysteresis_incoming(from_addr, in_if, ntohs(olsr->olsr_seqno));
320     }
321   }
322
323   for (; count > 0; m = (union olsr_message *)((char *)m + (msgsize))) {
324     bool forward = true;
325     bool validated;
326
327     if (count < MIN_PACKET_SIZE(olsr_cnf->ip_version) + 8)
328       break;
329
330     if (olsr_cnf->ip_version == AF_INET) {
331       msgsize = ntohs(m->v4.olsr_msgsize);
332       seqno = ntohs(m->v4.seqno);
333     }
334     else {
335       msgsize = ntohs(m->v6.olsr_msgsize);
336       seqno = ntohs(m->v6.seqno);
337     }
338
339     if (msgsize == 0) {
340       struct ipaddr_str buf;
341       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
342       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) is zero lengthed"
343           ", ignoring all further content of the packet\n",
344           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype);
345       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) is zero"
346           "lengthed, ignoring all further content of the packet\n",
347           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype);
348       break;
349     }
350
351     if ((msgsize % 4) != 0) {
352       struct ipaddr_str buf;
353       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
354       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) must be"
355           " longword aligned, but has a length of %d bytes\n",
356           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
357       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) must be"
358           " longword aligned, but has a length of %d bytes",
359           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
360       break;
361     }
362
363     if (msgsize > count) {
364       struct ipaddr_str buf;
365       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
366       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) says"
367           " length=%d, but only %d bytes left\n",
368           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
369       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) says"
370           " length=%d, but only %d bytes left",
371           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
372       break;
373     }
374
375     count -= msgsize;
376
377     /* Check size of message */
378     if (count < 0) {
379       struct ipaddr_str buf;
380       OLSR_PRINTF(1, "packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
381
382       olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
383       break;
384     }
385
386     /*RFC 3626 section 3.4:
387      *  2    If the time to live of the message is less than or equal to
388      *  '0' (zero), or if the message was sent by the receiving node
389      *  (i.e., the Originator Address of the message is the main
390      *  address of the receiving node): the message MUST silently be
391      *  dropped.
392      */
393
394     /* Should be the same for IPv4 and IPv6 */
395     validated = olsr_validate_address((union olsr_ip_addr *)&m->v4.originator);
396     if (ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->main_addr) || !validated) {
397 #ifdef DEBUG
398       struct ipaddr_str buf;
399       OLSR_PRINTF(3, "Not processing message originating from %s!\n",
400                   olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
401 #endif
402 #ifndef NO_DUPLICATE_DETECTION_HANDLER
403       if (validated) {
404         olsr_test_originator_collision(m->v4.olsr_msgtype, seqno);
405       }
406 #endif
407       continue;
408     }
409
410     entry = parse_functions;
411     while (entry) {
412       /* Should be the same for IPv4 and IPv6 */
413
414       /* Promiscuous or exact match */
415       if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
416         if (!entry->function(m, in_if, from_addr))
417           forward = false;
418       }
419       entry = entry->next;
420     }
421
422     if (forward) {
423       olsr_forward_message(m, in_if, from_addr);
424     }
425   }                             /* for olsr_msg */
426 }
427
428 /**
429  *Processing OLSR data from socket. Reading data, setting
430  *wich interface recieved the message, Sends IPC(if used)
431  *and passes the packet on to parse_packet().
432  *
433  *@param fd the filedescriptor that data should be read from.
434  *@return nada
435  */
436 void
437 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
438 {
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     struct ipaddr_str buf;
448     /* sockaddr_in6 is bigger than sockaddr !!!! */
449     struct sockaddr_storage from;
450     socklen_t fromlen;
451     int cc;
452
453     if (32 < ++cpu_overload_exit) {
454       OLSR_PRINTF(1, "CPU overload detected, ending olsr_input() loop\n");
455       break;
456     }
457
458     fromlen = sizeof(struct sockaddr_storage);
459     cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf_aligned), 0, (struct sockaddr *)&from, &fromlen);
460
461     if (cc <= 0) {
462       if (cc < 0 && errno != EWOULDBLOCK) {
463         OLSR_PRINTF(1, "error recvfrom: %s", strerror(errno));
464 #ifndef WIN32
465         olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %m");
466 #endif
467       }
468       break;
469     }
470     if (olsr_cnf->ip_version == AF_INET) {
471       /* IPv4 sender address */
472       memcpy(&from_addr.v4, &((struct sockaddr_in *)&from)->sin_addr, sizeof(from_addr.v4));
473     } else {
474       /* IPv6 sender address */
475       memcpy(&from_addr.v6, &((struct sockaddr_in6 *)&from)->sin6_addr, sizeof(from_addr.v6));
476     }
477
478 #ifdef DEBUG
479     OLSR_PRINTF(5, "Recieved a packet from %s\n",
480         olsr_ip_to_string(&buf, &from_addr));
481 #endif
482
483     if ((olsr_cnf->ip_version == AF_INET) && (fromlen != sizeof(struct sockaddr_in)))
484       break;
485     else if ((olsr_cnf->ip_version == AF_INET6) && (fromlen != sizeof(struct sockaddr_in6)))
486       break;
487
488     /* are we talking to ourselves? */
489     if (if_ifwithaddr(&from_addr) != NULL)
490       return;
491
492     if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
493       OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
494       olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
495                   cc);
496       return;
497     }
498     // call preprocessors
499     entry = preprocessor_functions;
500     packet = &inbuf[0];
501
502     while (entry) {
503       packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
504       // discard package ?
505       if (packet == NULL) {
506         return;
507       }
508       entry = entry->next;
509     }
510
511     /*
512      * &from - sender
513      * &inbuf.olsr
514      * cc - bytes read
515      */
516     parse_packet((struct olsr *)packet, cc, olsr_in_if, &from_addr);
517
518   }
519 }
520
521 /**
522  *Processing OLSR data from socket. Reading data, setting
523  *wich interface recieved the message, Sends IPC(if used)
524  *and passes the packet on to parse_packet().
525  *
526  *@param fd the filedescriptor that data should be read from.
527  *@return nada
528  */
529 void
530 olsr_input_hostemu(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
531 {
532   /* sockaddr_in6 is bigger than sockaddr !!!! */
533   struct sockaddr_storage from;
534   socklen_t fromlen;
535   struct interface *olsr_in_if;
536   union olsr_ip_addr from_addr;
537   uint16_t pcklen;
538   struct preprocessor_function_entry *entry;
539   char *packet;
540
541   /* Host emulator receives IP address first to emulate
542      direct link */
543
544   int cc = recv(fd, (void*)from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
545   if (cc != (int)olsr_cnf->ipsize) {
546     fprintf(stderr, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
547     memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
548   }
549
550   /* are we talking to ourselves? */
551   if (if_ifwithaddr(&from_addr) != NULL)
552     return;
553
554   /* Extract size */
555   if ((cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK)) != 2) {     /* Win needs a cast */
556     if (cc <= 0) {
557       fprintf(stderr, "Lost olsr_switch connection - exit!\n");
558       olsr_exit(__func__, EXIT_FAILURE);
559     }
560     fprintf(stderr, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
561     return;
562   } else {
563     pcklen = ntohs(pcklen);
564   }
565
566   fromlen = sizeof(struct sockaddr_storage);
567
568   cc = olsr_recvfrom(fd, inbuf, pcklen, 0, (struct sockaddr *)&from, &fromlen);
569
570   if (cc <= 0) {
571     if (cc < 0 && errno != EWOULDBLOCK) {
572       const char *const err_msg = strerror(errno);
573       OLSR_PRINTF(1, "error recvfrom: %s", err_msg);
574       olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %s", err_msg);
575     }
576     return;
577   }
578
579   if (cc != pcklen) {
580     printf("Could not read whole packet(size %d, read %d)\n", pcklen, cc);
581     return;
582   }
583
584   if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
585     struct ipaddr_str buf;
586     OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
587     olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
588                 cc);
589     return;
590   }
591   // call preprocessors
592   entry = preprocessor_functions;
593   packet = &inbuf[0];
594
595   while (entry) {
596     packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
597     // discard package ?
598     if (packet == NULL) {
599       return;
600     }
601     entry = entry->next;
602   }
603
604   /*
605    * &from - sender
606    * &inbuf.olsr
607    * cc - bytes read
608    */
609   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
610
611 }
612
613 /*
614  * Local Variables:
615  * c-basic-offset: 2
616  * indent-tabs-mode: nil
617  * End:
618  */