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