More cleanup of OS-specific interface, this times with win32
[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 "os_net.h"
51 #include "olsr_logging.h"
52 #include "net_olsr.h"
53
54 #include <assert.h>
55 #include <errno.h>
56 #include <stdlib.h>
57
58 #ifdef WIN32
59 #undef EWOULDBLOCK
60 #define EWOULDBLOCK WSAEWOULDBLOCK
61 #endif
62
63 static void parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr);
64
65 static struct parse_function_entry *parse_functions = NULL;
66 static struct preprocessor_function_entry *preprocessor_functions = NULL;
67 static struct packetparser_function_entry *packetparser_functions = NULL;
68
69 /**
70  *Initialize the parser.
71  *
72  *@return nada
73  */
74 void
75 olsr_init_parser(void)
76 {
77   OLSR_INFO(LOG_PACKET_PARSING, "Initializing parser...\n");
78
79   /* Initialize the packet functions */
80   olsr_init_package_process();
81 }
82
83 void
84 olsr_deinit_parser(void)
85 {
86   OLSR_INFO(LOG_PACKET_PARSING, "Deinitializing parser...\n");
87   olsr_deinit_package_process();
88 }
89
90 void
91 olsr_parser_add_function(parse_function * function, uint32_t type)
92 {
93   struct parse_function_entry *new_entry;
94
95   new_entry = olsr_malloc(sizeof(*new_entry), "Register parse function");
96
97   new_entry->function = function;
98   new_entry->type = type;
99
100   /* Queue */
101   new_entry->next = parse_functions;
102   parse_functions = new_entry;
103
104   OLSR_INFO(LOG_PACKET_PARSING, "Register parse function: Added function for type %u\n", type);
105 }
106
107 int
108 olsr_parser_remove_function(parse_function * function)
109 {
110   struct parse_function_entry *entry, *prev;
111
112   for (entry = parse_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
113     if ((entry->function == function)) {
114       if (entry == parse_functions) {
115         parse_functions = entry->next;
116       } else {
117         prev->next = entry->next;
118       }
119       free(entry);
120       return 1;
121     }
122   }
123   return 0;
124 }
125
126 void
127 olsr_preprocessor_add_function(preprocessor_function * function)
128 {
129   struct preprocessor_function_entry *new_entry;
130
131   new_entry = olsr_malloc(sizeof(*new_entry), "Register preprocessor function");
132   new_entry->function = function;
133
134   /* Queue */
135   new_entry->next = preprocessor_functions;
136   preprocessor_functions = new_entry;
137
138   OLSR_INFO(LOG_PACKET_PARSING, "Registered preprocessor function\n");
139 }
140
141 int
142 olsr_preprocessor_remove_function(preprocessor_function * function)
143 {
144   struct preprocessor_function_entry *entry, *prev;
145
146   for (entry = preprocessor_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
147     if (entry->function == function) {
148       if (entry == preprocessor_functions) {
149         preprocessor_functions = entry->next;
150       } else {
151         prev->next = entry->next;
152       }
153       free(entry);
154       return 1;
155     }
156   }
157   return 0;
158 }
159
160 void
161 olsr_packetparser_add_function(packetparser_function * function)
162 {
163   struct packetparser_function_entry *new_entry;
164
165   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
166
167   new_entry->function = function;
168
169   /* Queue */
170   new_entry->next = packetparser_functions;
171   packetparser_functions = new_entry;
172
173   OLSR_INFO(LOG_PACKET_PARSING, "Registered packetparser  function\n");
174 }
175
176 int
177 olsr_packetparser_remove_function(packetparser_function * function)
178 {
179   struct packetparser_function_entry *entry, *prev;
180
181   for (entry = packetparser_functions, prev = NULL; entry != NULL; prev = entry, entry = entry->next) {
182     if (entry->function == function) {
183       if (entry == packetparser_functions) {
184         packetparser_functions = entry->next;
185       } else {
186         prev->next = entry->next;
187       }
188       free(entry);
189       return 1;
190     }
191   }
192   return 0;
193 }
194
195 static void
196 olsr_parse_msg_hdr(const uint8_t **curr, struct olsr_message *msg)
197 {
198   assert(curr);
199   assert(msg);
200
201   msg->header = *curr;
202
203   pkt_get_u8(curr, &msg->type);
204   pkt_get_reltime(curr, &msg->vtime);
205   pkt_get_u16(curr, &msg->size);
206   pkt_get_ipaddress(curr, &msg->originator);
207   pkt_get_u8(curr, &msg->ttl);
208   pkt_get_u8(curr, &msg->hopcnt);
209   pkt_get_u16(curr, &msg->seqno);
210
211   msg->payload = *curr;
212   msg->end = msg->header + msg->size;
213 }
214
215 /**
216  *Process a newly received OLSR packet. Checks the type
217  *and to the neccessary convertions and call the
218  *corresponding functions to handle the information.
219  *@param from the sockaddr struct describing the sender
220  *@param olsr the olsr struct containing the message
221  *@param size the size of the message
222  *@return nada
223  */
224 static void
225 parse_packet(uint8_t *binary, int size, struct interface *in_if, union olsr_ip_addr *from_addr)
226 {
227   struct olsr_packet pkt;
228   struct olsr_message msg;
229   struct parse_function_entry *entry;
230   struct packetparser_function_entry *packetparser;
231   enum duplicate_status dup_status = 0;
232   uint8_t *curr, *end;
233
234 #if !defined(REMOVE_LOG_INFO) || !defined(REMOVE_LOG_WARN)
235   struct ipaddr_str buf;
236 #endif
237
238   curr = binary;
239   end = binary + size;
240
241   /* packet smaller than minimal olsr packet ? */
242   if (size < 4) {
243     OLSR_WARN(LOG_PACKET_PARSING, "Received too small packet (%u bytes) from %s\n",
244         size, olsr_ip_to_string(&buf, from_addr));
245     return;
246   }
247
248   pkt_get_u16((const uint8_t **)&curr, &pkt.size);
249   pkt_get_u16((const uint8_t **)&curr, &pkt.seqno);
250
251   if (pkt.size != (size_t) size) {
252     OLSR_WARN(LOG_PACKET_PARSING, "Received packet from %s (%u bytes) has bad size field: %u bytes\n",
253               olsr_ip_to_string(&buf, from_addr), size, pkt.size);
254     return;
255   }
256
257   // call packetparser
258   for (packetparser = packetparser_functions; packetparser != NULL; packetparser = packetparser->next) {
259     packetparser->function(&pkt, binary, in_if, from_addr);
260   }
261
262   for (;curr <= end - MIN_MESSAGE_SIZE(); curr += msg.size) {
263     const uint8_t *msg_payload = curr;
264     olsr_parse_msg_hdr(&msg_payload, &msg);
265
266     /* Check size of message */
267     if (curr + msg.size > end) {
268       OLSR_WARN(LOG_PACKET_PARSING, "Packet received from %s is too short (%u bytes) for message %u (%u bytes)!",
269           olsr_ip_to_string(&buf, from_addr), size, msg.type, msg.size);
270       break;
271     }
272     else if (msg.size == 0) {
273       OLSR_WARN(LOG_PACKET_PARSING, "Received a zero lengthed message from %s (typde %d), ignoring all further content of the packet!",
274           olsr_ip_to_string(&buf, from_addr), msg.type);
275       return;
276     }
277
278     /*RFC 3626 section 3.4:
279      *  2    If the time to live of the message is less than or equal to
280      *  '0' (zero), or if the message was sent by the receiving node
281      *  (i.e., the Originator Address of the message is the main
282      *  address of the receiving node): the message MUST silently be
283      *  dropped.
284      */
285
286     /* Should be the same for IPv4 and IPv6 */
287     if (olsr_ipcmp(&msg.originator, &olsr_cnf->router_id) == 0
288         || !olsr_validate_address(&msg.originator)) {
289       OLSR_INFO(LOG_PACKET_PARSING, "Skip processing our own message coming from %s!\n",
290                 olsr_ip_to_string(&buf, from_addr));
291       continue;
292     }
293
294     if (msg.ttl == 0 || (int)msg.ttl + (int)msg.hopcnt > 255) {
295       struct ipaddr_str buf2;
296       OLSR_WARN(LOG_PACKET_PARSING, "Malformed incoming message type %u from %s with originator %s: ttl=%u and hopcount=%u\n",
297           msg.type, olsr_ip_to_string(&buf, from_addr), olsr_ip_to_string(&buf2, &msg.originator), msg.ttl, msg.hopcnt);
298       continue;
299     }
300     if (olsr_is_duplicate_message(&msg, false, &dup_status)) {
301       OLSR_INFO(LOG_PACKET_PARSING, "Not processing message duplicate from %s (seqnr %u)!\n",
302           olsr_ip_to_string(&buf, &msg.originator), msg.seqno);
303     }
304     else {
305       OLSR_DEBUG(LOG_PACKET_PARSING, "Processing message type %u (seqno %u) from %s\n",
306           msg.type, msg.seqno, olsr_ip_to_string(&buf, &msg.originator));
307       for (entry = parse_functions; entry != NULL; entry = entry->next) {
308         /* Should be the same for IPv4 and IPv6 */
309         /* Promiscuous or exact match */
310         if ((entry->type == PROMISCUOUS) || (entry->type == msg.type)) {
311           entry->function(&msg, in_if, from_addr, dup_status);
312         }
313       }
314     }
315     olsr_forward_message(&msg, curr, in_if, from_addr);
316   }                             /* for olsr_msg */
317 }
318
319 /**
320  *Processing OLSR data from socket. Reading data, setting
321  *wich interface recieved the message, Sends IPC(if used)
322  *and passes the packet on to parse_packet().
323  *
324  *@param fd the filedescriptor that data should be read from.
325  *@return nada
326  */
327 void
328 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
329 {
330   unsigned int cpu_overload_exit = 0;
331 #ifndef REMOVE_LOG_DEBUG
332   char addrbuf[128];
333 #endif
334 #ifndef REMOVE_LOG_WARN
335   struct ipaddr_str buf;
336 #endif
337
338   for (;;) {
339     struct interface *olsr_in_if;
340     union olsr_ip_addr from_addr;
341     struct preprocessor_function_entry *entry;
342     uint8_t *packet;
343     /* sockaddr_in6 is bigger than sockaddr !!!! */
344     union olsr_sockaddr from;
345     socklen_t fromlen;
346     int size;
347     uint8_t inbuf[MAXMESSAGESIZE] __attribute__ ((aligned));
348
349     if (32 < ++cpu_overload_exit) {
350       OLSR_WARN(LOG_PACKET_PARSING, "CPU overload detected, ending olsr_input() loop\n");
351       break;
352     }
353
354     fromlen = sizeof(from);
355     size = os_recvfrom(fd, inbuf, sizeof(inbuf), 0, &from, &fromlen);
356
357     if (size <= 0) {
358       if (size < 0 && errno != EWOULDBLOCK) {
359         OLSR_WARN(LOG_PACKET_PARSING, "error recvfrom: %s", strerror(errno));
360       }
361       break;
362     }
363
364     OLSR_DEBUG(LOG_PACKET_PARSING, "Recieved a packet from %s\n",
365                sockaddr_to_string(addrbuf, sizeof(addrbuf), (struct sockaddr *)&from, fromlen));
366
367     if (olsr_cnf->ip_version == AF_INET) {
368       /* IPv4 sender address */
369       if (fromlen != sizeof(struct sockaddr_in)) {
370         OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
371         break;
372       }
373       from_addr.v4 = ((struct sockaddr_in *)&from)->sin_addr;
374     } else {
375       /* IPv6 sender address */
376       if (fromlen != sizeof(struct sockaddr_in6)) {
377         OLSR_WARN(LOG_PACKET_PARSING, "Got wrong ip size from recv()\n");
378         break;
379       }
380       from_addr.v6 = ((struct sockaddr_in6 *)&from)->sin6_addr;
381     }
382
383     /* are we talking to ourselves? */
384     if (if_ifwithaddr(&from_addr) != NULL) {
385       OLSR_INFO(LOG_PACKET_PARSING, "Ignore packet from ourself (%s).\n",
386           olsr_ip_to_string(&buf, &from_addr));
387       return;
388     }
389     olsr_in_if = if_ifwithsock(fd);
390     if (olsr_in_if == NULL) {
391       OLSR_WARN(LOG_PACKET_PARSING, "Could not find input interface for message from %s size %d\n",
392                 olsr_ip_to_string(&buf, &from_addr), size);
393       return;
394     }
395     // call preprocessors
396     packet = &inbuf[0];
397     for (entry = preprocessor_functions; entry != NULL; entry = entry->next) {
398       packet = entry->function(packet, olsr_in_if, &from_addr, &size);
399       // discard package ?
400       if (packet == NULL) {
401         OLSR_INFO(LOG_PACKET_PARSING, "Discard package because of preprocessor\n");
402         return;
403       }
404     }
405
406     /*
407      * &from - sender
408      * &inbuf.olsr
409      * size - bytes read
410      */
411     parse_packet(packet, size, olsr_in_if, &from_addr);
412   }
413 }
414
415 /*
416  * Local Variables:
417  * c-basic-offset: 2
418  * indent-tabs-mode: nil
419  * End:
420  */