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