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