* if inet_pton() fails it returns <= 0
[olsrd.git] / src / net_olsr.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  * $Id: net_olsr.c,v 1.20 2007/04/20 10:38:01 bernd67 Exp $
40  */
41
42 #include "net_olsr.h"
43 #include "log.h"
44 #include "olsr.h"
45 #include "net_os.h"
46 #include "print_packet.h"
47 #include "link_set.h"
48 #include <stdlib.h>
49 #include <assert.h>
50
51 extern olsr_bool lq_tc_pending;
52
53 static olsr_bool disp_pack_out = OLSR_FALSE;
54
55
56 #ifdef WIN32
57 #define perror(x) WinSockPError(x)
58 void
59 WinSockPError(char *);
60 #endif
61
62
63 struct deny_address_entry
64 {
65   union olsr_ip_addr        addr;
66   struct deny_address_entry *next;
67 };
68
69
70 /* Packet transform functions */
71
72 struct ptf
73 {
74   packet_transform_function function;
75   struct ptf *next;
76 };
77
78 static struct ptf *ptf_list;
79
80 static char ipv6_buf[100]; /* for address coversion */
81
82 static struct deny_address_entry *deny_entries;
83
84 static const char * const deny_ipv4_defaults[] =
85   {
86     "0.0.0.0",
87     "127.0.0.1",
88     NULL
89   };
90
91 static const char * const deny_ipv6_defaults[] =
92   {
93     "0::0",
94     "0::1",
95     NULL
96   };
97
98 void
99 net_set_disp_pack_out(olsr_bool val)
100 {
101   disp_pack_out = val;
102 }
103
104 void
105 init_net(void)
106 {
107   union olsr_ip_addr addr;
108   int i;
109
110   /* Block invalid addresses */
111   if(olsr_cnf->ip_version == AF_INET)
112     {
113       /* IPv4 */
114       for(i = 0; deny_ipv4_defaults[i] != NULL; i++)
115         {
116           if(inet_pton(olsr_cnf->ip_version, deny_ipv4_defaults[i], &addr) <= 0)
117             {
118               fprintf(stderr, "Error converting fixed IP %s for deny rule!!\n",
119                       deny_ipv4_defaults[i]);
120               continue;
121             }
122           olsr_add_invalid_address(&addr);
123         }
124     }
125   else 
126     {
127       /* IPv6 */
128       for(i = 0; deny_ipv6_defaults[i] != NULL; i++)
129         {
130           if(inet_pton(olsr_cnf->ip_version, deny_ipv6_defaults[i], &addr) <= 0)
131             {
132               fprintf(stderr, "Error converting fixed IP %s for deny rule!!\n",
133                       deny_ipv6_defaults[i]);
134               continue;
135             }
136           olsr_add_invalid_address(&addr);
137         }
138
139     }
140 }
141
142 /**
143  * Create a outputbuffer for the given interface. This
144  * function will allocate the needed storage according 
145  * to the MTU of the interface.
146  *
147  * @param ifp the interface to create a buffer for
148  *
149  * @return 0 on success, negative if a buffer already existed
150  *  for the given interface
151  */ 
152 int
153 net_add_buffer(struct interface *ifp)
154 {
155   /* Can the interfaces MTU actually change? If not, we can elimiate
156    * the "bufsize" field in "struct olsr_netbuf".
157    */
158   if (ifp->netbuf.bufsize != ifp->int_mtu && ifp->netbuf.buff != NULL) {
159     free(ifp->netbuf.buff);
160     ifp->netbuf.buff = NULL;
161   }
162   
163   if (ifp->netbuf.buff == NULL) {
164     ifp->netbuf.buff = olsr_malloc(ifp->int_mtu, "add_netbuff");
165   }
166
167   /* Fill struct */
168   ifp->netbuf.bufsize = ifp->int_mtu;
169   ifp->netbuf.maxsize = ifp->int_mtu - OLSR_HEADERSIZE;
170
171   ifp->netbuf.pending = 0;
172   ifp->netbuf.reserved = 0;
173
174   return 0;
175 }
176
177 /**
178  * Remove a outputbuffer. Frees the allocated memory.
179  *
180  * @param ifp the interface corresponding to the buffer
181  * to remove
182  *
183  * @return 0 on success, negative if no buffer is found
184  */
185 int
186 net_remove_buffer(struct interface *ifp)
187 {
188   /* Flush pending data */
189   if(ifp->netbuf.pending)
190     net_output(ifp);
191
192   free(ifp->netbuf.buff);
193   ifp->netbuf.buff = NULL;
194
195   return 0;
196 }
197
198
199 /**
200  * Reserve space in a outputbuffer. This should only be needed
201  * in very special cases. This will decrease the reported size
202  * of the buffer so that there is always <i>size</i> bytes
203  * of data available in the buffer. To add data in the reserved
204  * area one must use the net_outbuffer_push_reserved function.
205  *
206  * @param ifp the interface corresponding to the buffer
207  * to reserve space on
208  * @param size the number of bytes to reserve
209  *
210  * @return 0 on success, negative if there was not enough
211  *  bytes to reserve
212  */
213 int
214 net_reserve_bufspace(struct interface *ifp, int size)
215 {
216   if(size > ifp->netbuf.maxsize)
217     return -1;
218   
219   ifp->netbuf.reserved = size;
220   ifp->netbuf.maxsize -= size;
221   
222   return 0;
223 }
224
225 /**
226  * Returns the number of bytes pending in the buffer. That
227  * is the number of bytes added but not sent.
228  *
229  * @param ifp the interface corresponding to the buffer
230  *
231  * @return the number of bytes currently pending
232  */
233 olsr_u16_t
234 net_output_pending(struct interface *ifp)
235 {
236   return ifp->netbuf.pending;
237 }
238
239
240
241 /**
242  * Add data to a buffer.
243  *
244  * @param ifp the interface corresponding to the buffer
245  * @param data a pointer to the data to add
246  * @param size the number of byte to copy from data
247  *
248  * @return -1 if no buffer was found, 0 if there was not 
249  *  enough room in buffer or the number of bytes added on 
250  *  success
251  */
252 int
253 net_outbuffer_push(struct interface *ifp, olsr_u8_t *data, olsr_u16_t size)
254 {
255   if((ifp->netbuf.pending + size) > ifp->netbuf.maxsize)
256     return 0;
257
258   memcpy(&ifp->netbuf.buff[ifp->netbuf.pending + OLSR_HEADERSIZE], data, size);
259   ifp->netbuf.pending += size;
260
261   return size;
262 }
263
264
265 /**
266  * Add data to the reserved part of a buffer
267  *
268  * @param ifp the interface corresponding to the buffer
269  * @param data a pointer to the data to add
270  * @param size the number of byte to copy from data
271  *
272  * @return -1 if no buffer was found, 0 if there was not 
273  *  enough room in buffer or the number of bytes added on 
274  *  success
275  */
276 int
277 net_outbuffer_push_reserved(struct interface *ifp, olsr_u8_t *data, olsr_u16_t size)
278 {
279   if((ifp->netbuf.pending + size) > (ifp->netbuf.maxsize + ifp->netbuf.reserved))
280     return 0;
281
282   memcpy(&ifp->netbuf.buff[ifp->netbuf.pending + OLSR_HEADERSIZE], data, size);
283   ifp->netbuf.pending += size;
284
285   return size;
286 }
287
288 /**
289  * Report the number of bytes currently available in the buffer
290  * (not including possible reserved bytes)
291  *
292  * @param ifp the interface corresponding to the buffer
293  *
294  * @return the number of bytes available in the buffer or
295  */
296 int
297 net_outbuffer_bytes_left(struct interface *ifp)
298 {
299   return ifp->netbuf.maxsize - ifp->netbuf.pending;
300 }
301
302
303 /**
304  * Add a packet transform function. Theese are functions
305  * called just prior to sending data in a buffer.
306  *
307  * @param f the function pointer
308  *
309  * @returns 1
310  */
311 int
312 add_ptf(packet_transform_function f)
313 {
314
315   struct ptf *new_ptf;
316
317   new_ptf = olsr_malloc(sizeof(struct ptf), "Add PTF");
318
319   new_ptf->next = ptf_list;
320   new_ptf->function = f;
321
322   ptf_list = new_ptf;
323
324   return 1;
325 }
326
327 /**
328  * Remove a packet transform function
329  *
330  * @param f the function pointer
331  *
332  * @returns 1 if a functionpointer was removed
333  *  0 if not
334  */
335 int
336 del_ptf(packet_transform_function f)
337 {
338   struct ptf *tmp_ptf, *prev;
339
340   tmp_ptf = ptf_list;
341   prev = NULL;
342
343   while(tmp_ptf)
344     {
345       if(tmp_ptf->function == f)
346         {
347           /* Remove entry */
348           if(prev == NULL)
349               ptf_list = tmp_ptf->next;
350           else
351               prev->next = tmp_ptf->next;
352           free(tmp_ptf);
353           return 1;
354         }
355       prev = tmp_ptf;
356       tmp_ptf = tmp_ptf->next;
357     }
358
359   return 0;
360 }
361
362 /**
363  *Sends a packet on a given interface.
364  *
365  *@param ifp the interface to send on.
366  *
367  *@return negative on error
368  */
369 int
370 net_output(struct interface *ifp)
371 {
372   struct sockaddr_in *sin;  
373   struct sockaddr_in dst;
374   struct sockaddr_in6 *sin6;  
375   struct sockaddr_in6 dst6;
376   struct ptf *tmp_ptf_list;
377   union olsr_packet *outmsg;
378   int retval;
379
380   sin = NULL;
381   sin6 = NULL;
382
383   if(!ifp->netbuf.pending)
384     return 0;
385
386   ifp->netbuf.pending += OLSR_HEADERSIZE;
387
388   retval = ifp->netbuf.pending;
389
390   outmsg = (union olsr_packet *)ifp->netbuf.buff;
391   /* Add the Packet seqno */
392   outmsg->v4.olsr_seqno = htons(ifp->olsr_seqnum++);
393   /* Set the packetlength */
394   outmsg->v4.olsr_packlen = htons(ifp->netbuf.pending);
395
396   if(olsr_cnf->ip_version == AF_INET)
397     {
398       /* IP version 4 */
399       sin = (struct sockaddr_in *)&ifp->int_broadaddr;
400
401       /* Copy sin */
402       dst = *sin;
403       sin = &dst;
404
405       if (sin->sin_port == 0)
406         sin->sin_port = htons(OLSRPORT);
407     }
408   else
409     {
410       /* IP version 6 */
411       sin6 = (struct sockaddr_in6 *)&ifp->int6_multaddr;
412       /* Copy sin */
413       dst6 = *sin6;
414       sin6 = &dst6;
415     }
416
417   /*
418    *Call possible packet transform functions registered by plugins  
419    */
420   tmp_ptf_list = ptf_list;
421   while(tmp_ptf_list != NULL)
422     {
423       tmp_ptf_list->function(ifp->netbuf.buff, &ifp->netbuf.pending);
424       tmp_ptf_list = tmp_ptf_list->next;
425     }
426
427   /*
428    *if the -dispout option was given
429    *we print the content of the packets
430    */
431   if(disp_pack_out)
432     print_olsr_serialized_packet(stdout, (union olsr_packet *)ifp->netbuf.buff, 
433                                  ifp->netbuf.pending, &ifp->ip_addr); 
434   
435   if(olsr_cnf->ip_version == AF_INET)
436     {
437       /* IP version 4 */
438       if(olsr_sendto(ifp->olsr_socket, 
439                      ifp->netbuf.buff, 
440                      ifp->netbuf.pending, 
441                      MSG_DONTROUTE, 
442                      (struct sockaddr *)sin, 
443                      sizeof (*sin))
444          < 0)
445         {
446           perror("sendto(v4)");
447           olsr_syslog(OLSR_LOG_ERR, "OLSR: sendto IPv4 %m");
448           retval = -1;
449         }
450     }
451   else
452     {
453       /* IP version 6 */
454       if(olsr_sendto(ifp->olsr_socket, 
455                      ifp->netbuf.buff,
456                      ifp->netbuf.pending, 
457                      MSG_DONTROUTE, 
458                      (struct sockaddr *)sin6, 
459                      sizeof (*sin6))
460          < 0)
461         {
462           perror("sendto(v6)");
463           olsr_syslog(OLSR_LOG_ERR, "OLSR: sendto IPv6 %m");
464           fprintf(stderr, "Socket: %d interface: %d\n", ifp->olsr_socket, ifp->if_nr);
465           fprintf(stderr, "To: %s (size: %d)\n", ip6_to_string(&sin6->sin6_addr), (int)sizeof(*sin6));
466           fprintf(stderr, "Outputsize: %d\n", ifp->netbuf.pending);
467           retval = -1;
468         }
469     }
470   
471   ifp->netbuf.pending = 0;
472
473   // if we've just transmitted a TC message, let Dijkstra use the current
474   // link qualities for the links to our neighbours
475
476   olsr_update_dijkstra_link_qualities();
477   lq_tc_pending = OLSR_FALSE;
478
479   return retval;
480 }
481
482
483 /**
484  * Create a IPv6 netmask based on a prefix length
485  *
486  * @param allocated address to build the netmask in
487  * @param prefix the prefix length
488  *
489  * @returns 1 on success 0 on failure
490  */
491 int
492 olsr_prefix_to_netmask(union olsr_ip_addr *adr, olsr_u16_t prefix)
493 {
494   int p, i;
495
496   if(adr == NULL)
497     return 0;
498
499   p = prefix;
500   i = 0;
501
502   memset(adr, 0, olsr_cnf->ipsize);
503
504   for(;p > 0; p -= 8)
505     {
506       adr->v6.s6_addr[i] = (p < 8) ? 0xff ^ (0xff >> p) : 0xff;
507       i++;
508     }
509
510 #ifdef DEBUG
511   OLSR_PRINTF(3, "Prefix %d = Netmask: %s\n", prefix, olsr_ip_to_string(adr))
512 #endif
513
514   return 1;
515 }
516
517
518
519 /**
520  * Calculate prefix length based on a netmask
521  *
522  * @param adr the address to use to calculate the prefix length
523  *
524  * @return the prefix length
525  */
526 olsr_u16_t
527 olsr_netmask_to_prefix(union olsr_ip_addr *adr)
528 {
529   olsr_u16_t prefix;
530   int i, tmp;
531
532   prefix = 0;
533
534   for(i = 0; i < 16; i++)
535     {
536       if(adr->v6.s6_addr[i] == 0xff)
537         {
538           prefix += 8;
539         }
540       else
541         {
542           for(tmp = adr->v6.s6_addr[i];
543               tmp > 0;
544               tmp = (tmp << 1) & 0xff)
545             prefix++;
546         }
547     }
548
549 #ifdef DEBUG
550   OLSR_PRINTF(3, "Netmask: %s = Prefix %d\n", olsr_ip_to_string(adr), prefix)
551 #endif
552
553   return prefix;
554 }
555
556
557
558 /**
559  *Converts a sockaddr struct to a string representing
560  *the IP address from the sockaddr struct
561  *
562  *<b>NON REENTRANT!!!!</b>
563  *
564  *@param address_to_convert the sockaddr struct to "convert"
565  *@return a char pointer to the string containing the IP
566  */
567 char *
568 sockaddr_to_string(struct sockaddr *address_to_convert)
569 {
570   struct sockaddr_in           *address;
571   
572   address=(struct sockaddr_in *)address_to_convert; 
573   return(inet_ntoa(address->sin_addr));
574   
575 }
576
577
578 /**
579  *Converts the 32bit olsr_u32_t datatype to
580  *a char array.
581  *
582  *<b>NON REENTRANT!!!!</b>
583  *
584  *@param address the olsr_u32_t to "convert"
585  *@return a char pointer to the string containing the IP
586  */
587
588 char *
589 ip_to_string(olsr_u32_t *address)
590 {
591
592   struct in_addr in;
593   in.s_addr=*address;
594   return(inet_ntoa(in));
595   
596 }
597
598
599
600
601 /**
602  *Converts the 32bit olsr_u32_t datatype to
603  *a char array.
604  *
605  *<b>NON REENTRANT</b>
606  *
607  *@param addr6 the address to "convert"
608  *@return a char pointer to the string containing the IP
609  */
610
611 char *
612 ip6_to_string(struct in6_addr *addr6)
613 {
614   return (char *)inet_ntop(AF_INET6, addr6, ipv6_buf, sizeof(ipv6_buf));
615 }
616
617
618 char *
619 olsr_ip_to_string(union olsr_ip_addr *addr)
620 {
621   static int index = 0;
622   static char buff[4][100];
623   char *ret;
624   struct in_addr in;
625   
626   if(olsr_cnf->ip_version == AF_INET)
627     {
628       in.s_addr=addr->v4;
629       ret = inet_ntoa(in);
630     }
631   else
632     {
633       /* IPv6 */
634       ret = (char *)inet_ntop(AF_INET6, &addr->v6, ipv6_buf, sizeof(ipv6_buf));
635     }
636
637   strncpy(buff[index], ret, 100);
638
639   ret = buff[index];
640
641   index = (index + 1) & 3;
642
643   return ret;
644 }
645
646
647 void
648 olsr_add_invalid_address(union olsr_ip_addr *adr)
649 {
650   struct deny_address_entry *new_entry;
651
652   new_entry = olsr_malloc(sizeof(struct deny_address_entry), "Add deny address");
653
654   new_entry->next = deny_entries;
655   COPY_IP(&new_entry->addr, adr);
656
657   deny_entries = new_entry;
658
659   OLSR_PRINTF(1, "Added %s to IP deny set\n", olsr_ip_to_string(&new_entry->addr))
660   return;
661 }
662
663 /**
664  *Converts the 32bit olsr_u32_t datatype to
665  *a char array.
666  *
667  *<b>NON REENTRANT</b>
668  *
669  *@param addr6 the address to "convert"
670  *@return a char pointer to the string containing the IP
671  */
672 olsr_bool
673 olsr_validate_address(union olsr_ip_addr *adr)
674 {
675   struct deny_address_entry *deny_entry = deny_entries;
676
677   while(deny_entry)
678     {
679       if(COMP_IP(adr, &deny_entry->addr))
680         {
681           OLSR_PRINTF(1, "Validation of address %s failed!\n",
682                       olsr_ip_to_string(adr))
683           return OLSR_FALSE;
684         }
685
686       deny_entry = deny_entry->next;
687     }
688
689   return OLSR_TRUE;
690 }