src/net.c

   1
   2 /*
   3  * OLSR ad-hoc routing table management protocol
   4  * Copyright (C) 2003 Andreas Tønnesen (andreto@ifi.uio.no)
   5  *
   6  * This file is part of the olsr.org OLSR daemon.
   7  *
   8  * olsr.org is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * olsr.org is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with olsr.org; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  *
  23  * $Id: net.c,v 1.14 2004/09/25 21:06:07 kattemat Exp $
  24  *
  25  */
  26
  27 #include "net.h"
  28 #include "olsr.h"
  29 #include <stdlib.h>
  30
  31 #ifdef WIN32
  32 #define perror(x) WinSockPError(x)
  33 void
  34 WinSockPError(char *);
  35 #endif
  36
  37 #warning Interface configuration is now responsible for setting up outputbuffers!!
  38
  39 struct olsr_netbuf
  40 {
  41   char *buff;     /* Pointer to the allocated buffer */
  42   int if_index;
  43   int bufsize;    /* Size of the buffer */
  44   int maxsize;    /* Max bytes of payload that can be added to the buffer */
  45   int pending;    /* How much data is currently pending in the buffer */
  46   int reserved;   /* Plugins can reserve space in buffers */
  47 };
  48
  49
  50 static struct olsr_netbuf *netbufs[MAX_IFS];
  51
  52
  53
  54 void
  55 init_net()
  56 {
  57   ptf_list = NULL;
  58
  59   return;
  60 }
  61
  62 int
  63 net_add_buffer(struct interface *ifp)
  64 {
  65   struct olsr_netbuf *new_buf;
  66
  67   /* If a buffer already exists for this interface back off */
  68   if(netbufs[ifp->if_nr])
  69     return -1;
  70
  71   new_buf = olsr_malloc(sizeof(struct olsr_netbuf), "add_netbuff1");
  72   new_buf->buff = olsr_malloc(ifp->int_mtu, "add_netbuff2");
  73
  74   /* Fill struct */
  75   new_buf->bufsize = ifp->int_mtu;
  76   new_buf->if_index = ifp->if_nr;
  77   new_buf->maxsize = ifp->int_mtu - OLSR_HEADERSIZE;
  78   new_buf->pending = 0;
  79   new_buf->reserved = 0;
  80
  81   netbufs[ifp->if_nr] = new_buf;
  82
  83   return 0;
  84 }
  85
  86
  87 int
  88 net_remove_buffer(struct interface *ifp)
  89 {
  90
  91   /* If a buffer already exists for this interface back off */
  92   if(!netbufs[ifp->if_nr])
  93     return -1;
  94
  95   /* Flush pending data */
  96   if(netbufs[ifp->if_nr]->pending)
  97     net_output(ifp);
  98
  99   free(netbufs[ifp->if_nr]->buff);
 100   free(netbufs[ifp->if_nr]);
 101   netbufs[ifp->if_nr] = NULL;
 102
 103   return 0;
 104 }
 105
 106
 107
 108 int
 109 net_reserve_bufspace(struct interface *ifp, int size)
 110 {
 111
 112
 113   if((!netbufs[ifp->if_nr]) || (size > netbufs[ifp->if_nr]->maxsize))
 114     return -1;
 115
 116   netbufs[ifp->if_nr]->reserved = size;
 117   netbufs[ifp->if_nr]->maxsize -= size;
 118
 119   return 0;
 120 }
 121
 122
 123 inline olsr_u16_t
 124 net_output_pending(struct interface *ifp)
 125 {
 126   if(!netbufs[ifp->if_nr])
 127     return -1;
 128
 129   return netbufs[ifp->if_nr]->pending;
 130 }
 131
 132
 133
 134 /**
 135  * Add data to the buffer that is to be transmitted
 136  *
 137  * @return 0 if there was not enough room in buffer
 138  */
 139 int
 140 net_outbuffer_push(struct interface *ifp, olsr_u8_t *data, olsr_u16_t size)
 141 {
 142
 143   if(!netbufs[ifp->if_nr])
 144     return -1;
 145
 146   if((netbufs[ifp->if_nr]->pending + size) > netbufs[ifp->if_nr]->maxsize)
 147     return 0;
 148
 149   memcpy(&netbufs[ifp->if_nr]->buff[netbufs[ifp->if_nr]->pending + OLSR_HEADERSIZE], data, size);
 150   netbufs[ifp->if_nr]->pending += size;
 151
 152   return 1;
 153 }
 154
 155
 156 /**
 157  * Adddata to the reserved part of the buffer that is to be transmitted
 158  *
 159  * @return 0 if there was not enough room in buffer
 160  */
 161 int
 162 net_outbuffer_push_reserved(struct interface *ifp, olsr_u8_t *data, olsr_u16_t size)
 163 {
 164
 165   if(!netbufs[ifp->if_nr])
 166     return -1;
 167
 168   if((netbufs[ifp->if_nr]->pending + size) > (netbufs[ifp->if_nr]->maxsize + netbufs[ifp->if_nr]->reserved))
 169     return 0;
 170
 171   memcpy(&netbufs[ifp->if_nr]->buff[netbufs[ifp->if_nr]->pending + OLSR_HEADERSIZE], data, size);
 172   netbufs[ifp->if_nr]->pending += size;
 173
 174   return 1;
 175 }
 176
 177
 178 inline int
 179 net_outbuffer_bytes_left(struct interface *ifp)
 180 {
 181
 182   if(!netbufs[ifp->if_nr])
 183     return -1;
 184
 185   return (netbufs[ifp->if_nr]->maxsize - netbufs[ifp->if_nr]->pending);
 186 }
 187
 188
 189
 190
 191 /**
 192  *Sends a packet on a given interface.
 193  *
 194  *@param ifp the interface to send on.
 195  *
 196  *@return negative on error
 197  */
 198 int
 199 net_output(struct interface *ifp)
 200 {
 201   struct sockaddr_in *sin;
 202   struct sockaddr_in dst;
 203   struct sockaddr_in6 *sin6;
 204   struct sockaddr_in6 dst6;
 205   struct ptf *tmp_ptf_list;
 206   int i, x;
 207   union olsr_packet *outmsg;
 208
 209   sin = NULL;
 210   sin6 = NULL;
 211
 212   if(!netbufs[ifp->if_nr])
 213     return -1;
 214
 215   if(!netbufs[ifp->if_nr]->pending)
 216     return 0;
 217
 218   netbufs[ifp->if_nr]->pending += OLSR_HEADERSIZE;
 219
 220   outmsg = (union olsr_packet *)netbufs[ifp->if_nr]->buff;
 221   /* Add the Packet seqno */
 222   outmsg->v4.olsr_seqno = htons(ifp->olsr_seqnum++);
 223   /* Set the packetlength */
 224   outmsg->v4.olsr_packlen = htons(netbufs[ifp->if_nr]->pending);
 225
 226   if(ipversion == AF_INET)
 227     {
 228       /* IP version 4 */
 229       sin = (struct sockaddr_in *)&ifp->int_broadaddr;
 230
 231       /* Copy sin */
 232       dst = *sin;
 233       sin = &dst;
 234
 235       /* Set user defined broadcastaddr */
 236       if(bcast_set)
 237         memcpy(&dst.sin_addr.s_addr, &bcastaddr.sin_addr, sizeof(olsr_u32_t));
 238
 239       if (sin->sin_port == 0)
 240         sin->sin_port = olsr_udp_port;
 241     }
 242   else
 243     {
 244       /* IP version 6 */
 245       sin6 = (struct sockaddr_in6 *)&ifp->int6_multaddr;
 246       /* Copy sin */
 247       dst6 = *sin6;
 248       sin6 = &dst6;
 249     }
 250
 251   /*
 252    *Call possible packet transform functions registered by plugins
 253    */
 254   tmp_ptf_list = ptf_list;
 255   while(tmp_ptf_list != NULL)
 256     {
 257       tmp_ptf_list->function(netbufs[ifp->if_nr]->buff, &netbufs[ifp->if_nr]->pending);
 258       tmp_ptf_list = tmp_ptf_list->next;
 259     }
 260
 261   /*
 262    *if the '-disp- option was given
 263    *we print her decimal contetnt of the packets
 264    */
 265   if(disp_pack_out)
 266     {
 267       switch(netbufs[ifp->if_nr]->buff[4])
 268         {
 269         case(HELLO_MESSAGE):printf("\n\tHELLO ");break;
 270         case(TC_MESSAGE):printf("\n\tTC ");break;
 271         case(MID_MESSAGE):printf("\n\tMID ");break;
 272         case(HNA_MESSAGE):printf("\n\tHNA ");break;
 273         default:printf("\n\tTYPE: %d ", netbufs[ifp->if_nr]->buff[4]); break;
 274         }
 275       if(ipversion == AF_INET)
 276         printf("to %s size: %d\n\t", ip_to_string((olsr_u32_t *)&sin->sin_addr.s_addr), netbufs[ifp->if_nr]->pending);
 277       else
 278         printf("to %s size: %d\n\t", ip6_to_string(&sin6->sin6_addr), netbufs[ifp->if_nr]->pending);
 279
 280       x = 0;
 281
 282       for(i = 0; i < netbufs[ifp->if_nr]->pending;i++)
 283         {
 284           if(x == 4)
 285             {
 286               x = 0;
 287               printf("\n\t");
 288             }
 289           x++;
 290           if(ipversion == AF_INET)
 291             printf(" %3i", (u_char) netbufs[ifp->if_nr]->buff[i]);
 292           else
 293             printf(" %2x", (u_char) netbufs[ifp->if_nr]->buff[i]);
 294         }
 295
 296       printf("\n");
 297     }
 298
 299   /*
 300    *packet points to the same memory area as the *msg pointer
 301    *used when building packets.
 302    */
 303
 304   if(ipversion == AF_INET)
 305     {
 306       /* IP version 4 */
 307       if(sendto(ifp->olsr_socket,
 308                 netbufs[ifp->if_nr]->buff,
 309                 netbufs[ifp->if_nr]->pending,
 310                 MSG_DONTROUTE,
 311                 (struct sockaddr *)sin,
 312                 sizeof (*sin))
 313          < 0)
 314         {
 315           perror("sendto(v4)");
 316           olsr_syslog(OLSR_LOG_ERR, "OLSR: sendto IPv4 %m");
 317           netbufs[ifp->if_nr]->pending = 0;
 318           return -1;
 319         }
 320     }
 321   else
 322     {
 323       /* IP version 6 */
 324       if(sendto(ifp->olsr_socket,
 325                 netbufs[ifp->if_nr]->buff,
 326                 netbufs[ifp->if_nr]->pending,
 327                 MSG_DONTROUTE,
 328                 (struct sockaddr *)sin6,
 329                 sizeof (*sin6))
 330          < 0)
 331         {
 332           perror("sendto(v6)");
 333           olsr_syslog(OLSR_LOG_ERR, "OLSR: sendto IPv6 %m");
 334           fprintf(stderr, "Socket: %d interface: %d\n", ifp->olsr_socket, ifp->if_nr);
 335           fprintf(stderr, "To: %s (size: %d)\n", ip6_to_string(&sin6->sin6_addr), sizeof(*sin6));
 336           fprintf(stderr, "Outputsize: %d\n", netbufs[ifp->if_nr]->pending);
 337           netbufs[ifp->if_nr]->pending = 0;
 338           return -1;
 339         }
 340     }
 341
 342   netbufs[ifp->if_nr]->pending = 0;
 343
 344   return 1;
 345 }
 346
 347
 348
 349
 350
 351
 352 /*
 353  * Add a packet transform function
 354  */
 355 int
 356 add_ptf(int (*f)(char *, int *))
 357 {
 358
 359   struct ptf *new_ptf;
 360
 361   new_ptf = olsr_malloc(sizeof(struct ptf), "Add PTF");
 362
 363   new_ptf->next = ptf_list;
 364   new_ptf->function = f;
 365
 366   ptf_list = new_ptf;
 367
 368   return 1;
 369 }
 370
 371 /*
 372  * Remove a packet transform function
 373  */
 374 int
 375 del_ptf(int (*f)(char *, int *))
 376 {
 377   struct ptf *tmp_ptf, *prev;
 378
 379   tmp_ptf = ptf_list;
 380   prev = NULL;
 381
 382   while(tmp_ptf)
 383     {
 384       if(tmp_ptf->function == f)
 385         {
 386           /* Remove entry */
 387           if(prev == NULL)
 388             {
 389               ptf_list = tmp_ptf->next;
 390               free(tmp_ptf);
 391             }
 392           else
 393             {
 394               prev->next = tmp_ptf->next;
 395               free(tmp_ptf);
 396             }
 397           return 1;
 398         }
 399       prev = tmp_ptf;
 400       tmp_ptf = tmp_ptf->next;
 401     }
 402
 403   return 0;
 404 }
 405
 406
 407 int
 408 join_mcast(struct interface *ifs, int sock)
 409 {
 410   /* See linux/in6.h */
 411
 412   struct ipv6_mreq mcastreq;
 413
 414   COPY_IP(&mcastreq.ipv6mr_multiaddr, &ifs->int6_multaddr.sin6_addr);
 415   mcastreq.ipv6mr_interface = ifs->if_index;
 416
 417   olsr_printf(3, "Interface %s joining multicast %s...",        ifs->int_name, olsr_ip_to_string((union olsr_ip_addr *)&ifs->int6_multaddr.sin6_addr));
 418   /* Send multicast */
 419   if(setsockopt(sock,
 420                 IPPROTO_IPV6,
 421                 IPV6_ADD_MEMBERSHIP,
 422                 (char *)&mcastreq,
 423                 sizeof(struct ipv6_mreq))
 424      < 0)
 425     {
 426       perror("Join multicast");
 427       return -1;
 428     }
 429
 430
 431   /* Join reciever group */
 432   if(setsockopt(sock,
 433                 IPPROTO_IPV6,
 434                 IPV6_JOIN_GROUP,
 435                 (char *)&mcastreq,
 436                 sizeof(struct ipv6_mreq))
 437      < 0)
 438     {
 439       perror("Join multicast send");
 440       return -1;
 441     }
 442
 443
 444   if(setsockopt(sock,
 445                 IPPROTO_IPV6,
 446                 IPV6_MULTICAST_IF,
 447                 (char *)&mcastreq.ipv6mr_interface,
 448                 sizeof(mcastreq.ipv6mr_interface))
 449      < 0)
 450     {
 451       perror("Set multicast if");
 452       return -1;
 453     }
 454
 455
 456   olsr_printf(3, "OK\n");
 457   return 0;
 458 }
 459
 460
 461 /**
 462  * Create a IPv6 netmask based on a prefix length
 463  *
 464  */
 465 int
 466 olsr_prefix_to_netmask(union olsr_ip_addr *adr, olsr_u16_t prefix)
 467 {
 468   int p, i;
 469
 470   if(adr == NULL)
 471     return 0;
 472
 473   p = prefix;
 474   i = 0;
 475
 476   memset(adr, 0, ipsize);
 477
 478   for(;p > 0; p -= 8)
 479     {
 480       adr->v6.s6_addr[i] = (p < 8) ? 0xff ^ (0xff << p) : 0xff;
 481       i++;
 482     }
 483
 484 #ifdef DEBUG
 485   olsr_printf(3, "Prefix %d = Netmask: %s\n", prefix, olsr_ip_to_string(adr));
 486 #endif
 487
 488   return 1;
 489 }
 490
 491
 492
 493 /**
 494  * Calculate prefix length based on a netmask
 495  *
 496  */
 497 olsr_u16_t
 498 olsr_netmask_to_prefix(union olsr_ip_addr *adr)
 499 {
 500   olsr_u16_t prefix;
 501   int i, tmp;
 502
 503   prefix = 0;
 504
 505   memset(adr, 0, ipsize);
 506
 507   for(i = 0; i < 16; i++)
 508     {
 509       if(adr->v6.s6_addr[i] == 0xff)
 510         {
 511           prefix += 8;
 512         }
 513       else
 514         {
 515           for(tmp = adr->v6.s6_addr[i];
 516               tmp > 0;
 517               tmp = tmp >> 1)
 518             prefix++;
 519         }
 520     }
 521
 522 #ifdef DEBUG
 523   olsr_printf(3, "Netmask: %s = Prefix %d\n", olsr_ip_to_string(adr), prefix);
 524 #endif
 525
 526   return prefix;
 527 }
 528
 529
 530
 531 /**
 532  *Converts a sockaddr struct to a string representing
 533  *the IP address from the sockaddr struct
 534  *
 535  *<b>NON REENTRANT!!!!</b>
 536  *
 537  *@param address_to_convert the sockaddr struct to "convert"
 538  *@return a char pointer to the string containing the IP
 539  */
 540 char *
 541 sockaddr_to_string(struct sockaddr *address_to_convert)
 542 {
 543   struct sockaddr_in           *address;
 544
 545   address=(struct sockaddr_in *)address_to_convert;
 546   return(inet_ntoa(address->sin_addr));
 547
 548 }
 549
 550
 551 /**
 552  *Converts the 32bit olsr_u32_t datatype to
 553  *a char array.
 554  *
 555  *<b>NON REENTRANT!!!!</b>
 556  *
 557  *@param address the olsr_u32_t to "convert"
 558  *@return a char pointer to the string containing the IP
 559  */
 560
 561 char *
 562 ip_to_string(olsr_u32_t *address)
 563 {
 564
 565   struct in_addr in;
 566   in.s_addr=*address;
 567   return(inet_ntoa(in));
 568
 569 }
 570
 571
 572
 573
 574 /**
 575  *Converts the 32bit olsr_u32_t datatype to
 576  *a char array.
 577  *
 578  *<b>NON REENTRANT!!!!</b>
 579  *
 580  *@param addr6 the address to "convert"
 581  *@return a char pointer to the string containing the IP
 582  */
 583
 584 char *
 585 ip6_to_string(struct in6_addr *addr6)
 586 {
 587   return (char *)inet_ntop(AF_INET6, addr6, ipv6_buf, sizeof(ipv6_buf));
 588 }
 589
 590
 591 char *
 592 olsr_ip_to_string(union olsr_ip_addr *addr)
 593 {
 594
 595   char *ret;
 596   struct in_addr in;
 597
 598   if(ipversion == AF_INET)
 599     {
 600       in.s_addr=addr->v4;
 601       ret = inet_ntoa(in);
 602     }
 603   else
 604     {
 605       /* IPv6 */
 606       ret = (char *)inet_ntop(AF_INET6, &addr->v6, ipv6_buf, sizeof(ipv6_buf));
 607     }
 608
 609   return ret;
 610 }