info: java: update workspace
[olsrd.git] / src / parser.c
1 /*
2  * The olsr.org Optimized Link-State Routing daemon (olsrd)
3  *
4  * (c) by the OLSR project
5  *
6  * See our Git repository to find out who worked on this file
7  * and thus is a copyright holder on it.
8  *
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  *
15  * * Redistributions of source code must retain the above copyright
16  *   notice, this list of conditions and the following disclaimer.
17  * * Redistributions in binary form must reproduce the above copyright
18  *   notice, this list of conditions and the following disclaimer in
19  *   the documentation and/or other materials provided with the
20  *   distribution.
21  * * Neither the name of olsr.org, olsrd nor the names of its
22  *   contributors may be used to endorse or promote products derived
23  *   from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
28  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
29  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
31  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
32  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
33  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36  * POSSIBILITY OF SUCH DAMAGE.
37  *
38  * Visit http://www.olsr.org for more information.
39  *
40  * If you find this software useful feel free to make a donation
41  * to the project. For more information see the website or contact
42  * the copyright holders.
43  *
44  */
45
46 #include "parser.h"
47 #include "ipcalc.h"
48 #include "defs.h"
49 #include "process_package.h"
50 #include "mantissa.h"
51 #include "hysteresis.h"
52 #include "duplicate_set.h"
53 #include "mid_set.h"
54 #include "olsr.h"
55 #include "rebuild_packet.h"
56 #include "net_os.h"
57 #include "log.h"
58 #include "net_olsr.h"
59 #include "duplicate_handler.h"
60
61 #ifdef _WIN32
62 #undef EWOULDBLOCK
63 #define EWOULDBLOCK WSAEWOULDBLOCK
64 #undef errno
65 #define errno WSAGetLastError()
66 char *StrError(unsigned int ErrNo);
67 #undef strerror
68 #define strerror(x) StrError(x)
69 #endif /* _WIN32 */
70
71     /* Sven-Ola: On very slow devices used in huge networks
72  * the amount of lq_tc messages is so high, that the
73  * recv() loop never ends. This is a small hack to end
74  * the loop in this cases
75  */
76
77 unsigned int cpu_overload_exit = 0;
78
79 struct parse_function_entry *parse_functions;
80 struct preprocessor_function_entry *preprocessor_functions;
81 struct packetparser_function_entry *packetparser_functions;
82
83 static uint32_t inbuf_aligned[MAXMESSAGESIZE/sizeof(uint32_t) + 1];
84 static char *inbuf = (char *)inbuf_aligned;
85
86 /**
87  *Initialize the parser.
88  *
89  *@return nada
90  */
91 void
92 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
101 void
102 olsr_destroy_parser(void) {
103   struct parse_function_entry *pe, *pe_next;
104   struct preprocessor_function_entry *ppe, *ppe_next;
105   struct packetparser_function_entry *pae, *pae_next;
106
107   for (pe = parse_functions; pe; pe = pe_next) {
108     pe_next = pe->next;
109     free (pe);
110   }
111   for (ppe = preprocessor_functions; ppe; ppe = ppe_next) {
112     ppe_next = ppe->next;
113     free (ppe);
114   }
115   for (pae = packetparser_functions; pae; pae = pae_next) {
116     pae_next = pae->next;
117     free(pae);
118   }
119 }
120
121 void
122 olsr_parser_add_function(parse_function * function, uint32_t type)
123 {
124   struct parse_function_entry *new_entry;
125
126   OLSR_PRINTF(3, "Parser: registering event for type %d\n", type);
127
128   new_entry = olsr_malloc(sizeof(struct parse_function_entry), "Register parse function");
129
130   new_entry->function = function;
131   new_entry->type = type;
132
133   /* Queue */
134   new_entry->next = parse_functions;
135   parse_functions = new_entry;
136
137   OLSR_PRINTF(3, "Register parse function: Added function for type %d\n", type);
138
139 }
140
141 int
142 olsr_parser_remove_function(parse_function * function, uint32_t type)
143 {
144   struct parse_function_entry *entry, *prev;
145
146   entry = parse_functions;
147   prev = NULL;
148
149   while (entry) {
150     if ((entry->function == function) && (entry->type == type)) {
151       if (entry == parse_functions) {
152         parse_functions = entry->next;
153       } else {
154         prev->next = entry->next;
155       }
156       free(entry);
157       return 1;
158     }
159
160     prev = entry;
161     entry = entry->next;
162   }
163
164   return 0;
165 }
166
167 void
168 olsr_preprocessor_add_function(preprocessor_function * function)
169 {
170   struct preprocessor_function_entry *new_entry;
171
172   OLSR_PRINTF(3, "Parser: registering preprocessor\n");
173
174   new_entry = olsr_malloc(sizeof(struct preprocessor_function_entry), "Register preprocessor function");
175
176   new_entry->function = function;
177
178   /* Queue */
179   new_entry->next = preprocessor_functions;
180   preprocessor_functions = new_entry;
181
182   OLSR_PRINTF(3, "Registered preprocessor function\n");
183
184 }
185
186 int
187 olsr_preprocessor_remove_function(preprocessor_function * function)
188 {
189   struct preprocessor_function_entry *entry, *prev;
190
191   entry = preprocessor_functions;
192   prev = NULL;
193
194   while (entry) {
195     if (entry->function == function) {
196       if (entry == preprocessor_functions) {
197         preprocessor_functions = entry->next;
198       } else {
199         prev->next = entry->next;
200       }
201       free(entry);
202       return 1;
203     }
204
205     prev = entry;
206     entry = entry->next;
207   }
208
209   return 0;
210 }
211
212 void
213 olsr_packetparser_add_function(packetparser_function * function)
214 {
215   struct packetparser_function_entry *new_entry;
216
217   OLSR_PRINTF(3, "Parser: registering packetparser\n");
218
219   new_entry = olsr_malloc(sizeof(struct packetparser_function_entry), "Register packetparser function");
220
221   new_entry->function = function;
222
223   /* Queue */
224   new_entry->next = packetparser_functions;
225   packetparser_functions = new_entry;
226
227   OLSR_PRINTF(3, "Registered packetparser  function\n");
228
229 }
230
231 int
232 olsr_packetparser_remove_function(packetparser_function * function)
233 {
234   struct packetparser_function_entry *entry, *prev;
235
236   entry = packetparser_functions;
237   prev = NULL;
238
239   while (entry) {
240     if (entry->function == function) {
241       if (entry == packetparser_functions) {
242         packetparser_functions = entry->next;
243       } else {
244         prev->next = entry->next;
245       }
246       free(entry);
247       return 1;
248     }
249
250     prev = entry;
251     entry = entry->next;
252   }
253
254   return 0;
255 }
256
257 /**
258  *Process a newly received OLSR packet. Checks the type
259  *and to the neccessary convertions and call the
260  *corresponding functions to handle the information.
261  *@param olsr the olsr struct containing the message
262  *@param size the size of the message
263  *@param in_if the incoming interface
264  *@param from_addr the sockaddr struct describing the sender
265  */
266
267 void
268 parse_packet(struct olsr *olsr, int size, struct interface_olsr *in_if, union olsr_ip_addr *from_addr)
269 {
270   union olsr_message *m = (union olsr_message *)olsr->olsr_msg;
271   uint32_t count;
272   uint32_t msgsize;
273   uint16_t seqno;
274   struct parse_function_entry *entry;
275   struct packetparser_function_entry *packetparser;
276
277   count = size - ((char *)m - (char *)olsr);
278
279   /* minimum packet size is 4 */
280   if (count < 4)
281     return;
282
283   if (ntohs(olsr->olsr_packlen) !=(uint16_t) size) {
284     struct ipaddr_str buf;
285     OLSR_PRINTF(1, "Size error detected in received packet.\nReceived %d, in packet %d\n", size, ntohs(olsr->olsr_packlen));
286
287     olsr_syslog(OLSR_LOG_ERR, " packet length error in  packet received from %s!", olsr_ip_to_string(&buf, from_addr));
288     return;
289   }
290
291   // translate sequence number to host order
292   olsr->olsr_seqno = ntohs(olsr->olsr_seqno);
293
294   // call packetparser
295   packetparser = packetparser_functions;
296   while (packetparser) {
297     packetparser->function(olsr, in_if, from_addr);
298     packetparser = packetparser->next;
299   }
300
301   //printf("Message from %s\n\n", olsr_ip_to_string(&buf, from_addr));
302
303   /*
304    * Hysteresis update - for every OLSR package
305    */
306   if (olsr_cnf->use_hysteresis) {
307     /* IPv4 & IPv6 */
308     update_hysteresis_incoming(from_addr, in_if, olsr->olsr_seqno);
309   }
310
311   for (; count > 0; m = (union olsr_message *)((char *)m + (msgsize))) {
312     bool forward = true;
313     bool validated;
314
315     /* minimum message size is 8 + ipsize */
316     if (count < 8 + olsr_cnf->ipsize)
317       break;
318
319     if (olsr_cnf->ip_version == AF_INET) {
320       msgsize = ntohs(m->v4.olsr_msgsize);
321       seqno = ntohs(m->v4.seqno);
322     }
323     else {
324       msgsize = ntohs(m->v6.olsr_msgsize);
325       seqno = ntohs(m->v6.seqno);
326     }
327
328     /* sanity check for msgsize */
329     if (msgsize < 8 + olsr_cnf->ipsize) {
330       struct ipaddr_str buf;
331       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
332       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) is to small (%d bytes)"
333           ", ignoring all further content of the packet\n",
334           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
335       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) is too small (%d bytes)"
336           ", ignoring all further content of the packet\n",
337           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
338       break;
339     }
340
341     if ((msgsize % 4) != 0) {
342       struct ipaddr_str buf;
343       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
344       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) must be"
345           " longword aligned, but has a length of %d bytes\n",
346           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
347       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) must be"
348           " longword aligned, but has a length of %d bytes",
349           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize);
350       break;
351     }
352
353     if (msgsize > count) {
354       struct ipaddr_str buf;
355       union olsr_ip_addr *msgorig = (union olsr_ip_addr *) &m->v4.originator;
356       OLSR_PRINTF(1, "Error, OLSR message from %s (type %d) says"
357           " length=%d, but only %d bytes left\n",
358           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
359       olsr_syslog(OLSR_LOG_ERR, "Error, OLSR message from %s (type %d) says"
360           " length=%d, but only %d bytes left",
361           olsr_ip_to_string(&buf, msgorig), m->v4.olsr_msgtype, msgsize, count);
362       break;
363     }
364
365     count -= msgsize;
366
367     /*RFC 3626 section 3.4:
368      *  2    If the time to live of the message is less than or equal to
369      *  '0' (zero), or if the message was sent by the receiving node
370      *  (i.e., the Originator Address of the message is the main
371      *  address of the receiving node): the message MUST silently be
372      *  dropped.
373      */
374
375     /* Should be the same for IPv4 and IPv6 */
376     validated = olsr_validate_address((union olsr_ip_addr *)&m->v4.originator);
377     if (ipequal((union olsr_ip_addr *)&m->v4.originator, &olsr_cnf->main_addr) || !validated) {
378 #ifdef DEBUG
379       struct ipaddr_str buf;
380       OLSR_PRINTF(3, "Not processing message originating from %s!\n",
381                   olsr_ip_to_string(&buf, (union olsr_ip_addr *)&m->v4.originator));
382 #endif /* DEBUG */
383 #ifndef NO_DUPLICATE_DETECTION_HANDLER
384       if (validated) {
385         olsr_test_originator_collision(m->v4.olsr_msgtype, seqno);
386       }
387 #endif /* NO_DUPLICATE_DETECTION_HANDLER */
388       continue;
389     }
390
391     entry = parse_functions;
392     while (entry) {
393       /* Should be the same for IPv4 and IPv6 */
394
395       /* Promiscuous or exact match */
396       if ((entry->type == PROMISCUOUS) || (entry->type == m->v4.olsr_msgtype)) {
397         if (!entry->function(m, in_if, from_addr))
398           forward = false;
399       }
400       entry = entry->next;
401     }
402
403     if (forward) {
404       olsr_forward_message(m, in_if, from_addr);
405     }
406   }                             /* for olsr_msg */
407 }
408
409 /**
410  *Processing OLSR data from socket. Reading data, setting
411  *wich interface received the message, Sends IPC(if used)
412  *and passes the packet on to parse_packet().
413  *
414  *@param fd the filedescriptor that data should be read from.
415  *@param data unused
416  *@param flags unused
417  */
418 void
419 olsr_input(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
420 {
421   struct interface_olsr *olsr_in_if;
422   union olsr_ip_addr from_addr;
423   struct preprocessor_function_entry *entry;
424   char *packet;
425
426   cpu_overload_exit = 0;
427
428   for (;;) {
429     struct ipaddr_str buf;
430     /* sockaddr_in6 is bigger than sockaddr !!!! */
431     struct sockaddr_storage from;
432     socklen_t fromlen;
433     int cc;
434
435     if (32 < ++cpu_overload_exit) {
436       OLSR_PRINTF(1, "CPU overload detected, ending olsr_input() loop\n");
437       break;
438     }
439
440     fromlen = sizeof(struct sockaddr_storage);
441     cc = olsr_recvfrom(fd, inbuf, sizeof(inbuf_aligned), 0, (struct sockaddr *)&from, &fromlen);
442
443     if (cc <= 0) {
444       if (cc < 0 && errno != EWOULDBLOCK) {
445         OLSR_PRINTF(1, "error recvfrom: %s", strerror(errno));
446 #ifndef _WIN32
447         olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %m");
448 #endif /* _WIN32 */
449       }
450       break;
451     }
452
453     {
454       void * src;
455       void * dst;
456       size_t size;
457       if (olsr_cnf->ip_version == AF_INET) {
458         /* IPv4 sender address */
459         struct sockaddr_in * x = (struct sockaddr_in *) &from;
460         src = &x->sin_addr;
461         dst = &from_addr.v4;
462         size = sizeof(from_addr.v4);
463       } else {
464         /* IPv6 sender address */
465         struct sockaddr_in6 * x = (struct sockaddr_in6 *) &from;
466         src = &x->sin6_addr;
467         dst = &from_addr.v6;
468         size = sizeof(from_addr.v6);
469       }
470       memcpy(dst, src, size);
471     }
472
473 #ifdef DEBUG
474     OLSR_PRINTF(5, "Received a packet from %s\n",
475         olsr_ip_to_string(&buf, &from_addr));
476 #endif /* DEBUG */
477
478     if ((olsr_cnf->ip_version == AF_INET) && (fromlen != sizeof(struct sockaddr_in)))
479       break;
480     else if ((olsr_cnf->ip_version == AF_INET6) && (fromlen != sizeof(struct sockaddr_in6)))
481       break;
482
483     /* are we talking to ourselves? */
484     if (if_ifwithaddr(&from_addr) != NULL)
485       return;
486
487     if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
488       OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
489       olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
490                   cc);
491       return;
492     }
493     // call preprocessors
494     entry = preprocessor_functions;
495     packet = &inbuf[0];
496
497     while (entry) {
498       packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
499       // discard package ?
500       if (packet == NULL) {
501         return;
502       }
503       entry = entry->next;
504     }
505
506     /*
507      * &from - sender
508      * &inbuf.olsr
509      * cc - bytes read
510      */
511     parse_packet((struct olsr *)packet, cc, olsr_in_if, &from_addr);
512
513   }
514 }
515
516 /**
517  *Processing OLSR data from socket. Reading data, setting
518  *wich interface received the message, Sends IPC(if used)
519  *and passes the packet on to parse_packet().
520  *
521  *@param fd the filedescriptor that data should be read from.
522  *@param data unused
523  *@param flags unused
524  */
525 void
526 olsr_input_hostemu(int fd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
527 {
528   /* sockaddr_in6 is bigger than sockaddr !!!! */
529   struct sockaddr_storage from;
530   socklen_t fromlen;
531   struct interface_olsr *olsr_in_if;
532   union olsr_ip_addr from_addr;
533   uint16_t pcklen;
534   struct preprocessor_function_entry *entry;
535   char *packet;
536
537   /* Host emulator receives IP address first to emulate
538      direct link */
539
540   int cc = recv(fd, (void*)from_addr.v6.s6_addr, olsr_cnf->ipsize, 0);
541   if (cc != (int)olsr_cnf->ipsize) {
542     fprintf(stderr, "Error receiving host-client IP hook(%d) %s!\n", cc, strerror(errno));
543     memcpy(&from_addr, &((struct olsr *)inbuf)->olsr_msg->originator, olsr_cnf->ipsize);
544   }
545
546   /* are we talking to ourselves? */
547   if (if_ifwithaddr(&from_addr) != NULL)
548     return;
549
550   /* Extract size */
551   if ((cc = recv(fd, (void *)&pcklen, 2, MSG_PEEK)) != 2) {     /* Win needs a cast */
552     if (cc <= 0) {
553       char buf[1024];
554       snprintf(buf, sizeof(buf), "%s: Lost olsr_switch connection", __func__);
555       olsr_exit(buf, EXIT_FAILURE);
556     }
557     fprintf(stderr, "[hust-emu] error extracting size(%d) %s!\n", cc, strerror(errno));
558     return;
559   } else {
560     pcklen = ntohs(pcklen);
561   }
562
563   fromlen = sizeof(struct sockaddr_storage);
564
565   cc = olsr_recvfrom(fd, inbuf, pcklen, 0, (struct sockaddr *)&from, &fromlen);
566
567   if (cc <= 0) {
568     if (cc < 0 && errno != EWOULDBLOCK) {
569       const char *const err_msg = strerror(errno);
570       OLSR_PRINTF(1, "error recvfrom: %s", err_msg);
571       olsr_syslog(OLSR_LOG_ERR, "error recvfrom: %s", err_msg);
572     }
573     return;
574   }
575
576   if (cc != pcklen) {
577     printf("Could not read whole packet(size %d, read %d)\n", pcklen, cc);
578     return;
579   }
580
581   if ((olsr_in_if = if_ifwithsock(fd)) == NULL) {
582     struct ipaddr_str buf;
583     OLSR_PRINTF(1, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr), cc);
584     olsr_syslog(OLSR_LOG_ERR, "Could not find input interface for message from %s size %d\n", olsr_ip_to_string(&buf, &from_addr),
585                 cc);
586     return;
587   }
588   // call preprocessors
589   entry = preprocessor_functions;
590   packet = &inbuf[0];
591
592   while (entry) {
593     packet = entry->function(packet, olsr_in_if, &from_addr, &cc);
594     // discard package ?
595     if (packet == NULL) {
596       return;
597     }
598     entry = entry->next;
599   }
600
601   /*
602    * &from - sender
603    * &inbuf.olsr
604    * cc - bytes read
605    */
606   parse_packet((struct olsr *)inbuf, cc, olsr_in_if, &from_addr);
607
608 }
609
610 /*
611  * Local Variables:
612  * c-basic-offset: 2
613  * indent-tabs-mode: nil
614  * End:
615  */