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