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