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