lib/mdns/src/mdns.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004-2009, the olsr.org team - see HISTORY file
   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
  42 #include "mdns.h"
  43
  44 /* System includes */
  45 #include <stddef.h>             /* NULL */
  46 #include <sys/types.h>          /* ssize_t */
  47 #include <string.h>             /* strerror() */
  48 #include <stdarg.h>             /* va_list, va_start, va_end */
  49 #include <errno.h>              /* errno */
  50 #include <assert.h>             /* assert() */
  51 #include <linux/if_ether.h>     /* ETH_P_IP */
  52 #include <linux/if_packet.h>    /* struct sockaddr_ll, PACKET_MULTICAST */
  53 #include <signal.h>             /* sigset_t, sigfillset(), sigdelset(), SIGINT */
  54 #include <netinet/ip.h>         /* struct ip */
  55 #include <netinet/udp.h>        /* struct udphdr */
  56 #include <unistd.h>             /* close() */
  57
  58 #include <netinet/in.h>
  59 #include <netinet/ip6.h>
  60
  61 /* OLSRD includes */
  62 #include "plugin_util.h"        /* set_plugin_int */
  63 #include "defs.h"               /* olsr_cnf, //OLSR_PRINTF */
  64 #include "ipcalc.h"
  65 #include "olsr.h"               /* //OLSR_PRINTF */
  66 #include "mid_set.h"            /* mid_lookup_main_addr() */
  67 #include "link_set.h"           /* get_best_link_to_neighbor() */
  68 #include "net_olsr.h"           /* ipequal */
  69
  70 /* plugin includes */
  71 #include "NetworkInterfaces.h"  /* TBmfInterface, CreateBmfNetworkInterfaces(), CloseBmfNetworkInterfaces() */
  72 #include "Address.h"            /* IsMulticast() */
  73 #include "Packet.h"             /* ENCAP_HDR_LEN, BMF_ENCAP_TYPE, BMF_ENCAP_LEN etc. */
  74 #include "list_backport.h"
  75 #include "RouterElection.h"
  76 #include "list_backport.h"
  77
  78 #define OLSR_FOR_ALL_FILTEREDNODES_ENTRIES(n, iterator) listbackport_for_each_element_safe(&ListOfFilteredHosts, n, list, iterator)
  79
  80 #define IPH_HL(hdr) (((hdr)->ip_hl)*4)
  81
  82 struct list_entity ListOfFilteredHosts;
  83 int FHListInit = 0;
  84
  85 static uint16_t ip_checksum(char* data, int len)
  86 {
  87     uint sum = 0;
  88     if ((len & 1) == 0)
  89         len = len >> 1;
  90     else
  91         len = (len >> 1) + 1;
  92     while (len > 0) {
  93         sum += *((unsigned short int*)(void *)data);
  94         data += sizeof(unsigned short int);
  95         len--;
  96     }
  97     sum = (sum >> 16) + (sum & 0xffff);
  98     sum += (sum >> 16);
  99     return(~sum);
 100 }
 101
 102
 103 /* -------------------------------------------------------------------------
 104  * Function   : PacketReceivedFromOLSR
 105  * Description: Handle a received packet from a OLSR message
 106  * Input      : ipPacket into an unsigned char and the lenght of the packet
 107  * Output     : none
 108  * Return     : none
 109  * Data Used  : BmfInterfaces
 110  * ------------------------------------------------------------------------- */
 111 static void
 112 PacketReceivedFromOLSR(unsigned char *encapsulationUdpData, int len)
 113 {
 114   struct ip *ipHeader;                 /* IP header inside the encapsulated IP packet */
 115   struct ip6_hdr *ip6Header;                 /* IP header inside the encapsulated IP packet */
 116   //union olsr_ip_addr mcSrc;            /* Original source of the encapsulated multicast packet */
 117   //union olsr_ip_addr mcDst;            /* Multicast destination of the encapsulated packet */
 118   struct TBmfInterface *walker;
 119   int stripped_len = 0;
 120   uint16_t csum_ip;
 121   ipHeader = (struct ip *)ARM_NOWARN_ALIGN(encapsulationUdpData);
 122   ip6Header = (struct ip6_hdr *)ARM_NOWARN_ALIGN(encapsulationUdpData);
 123
 124   //mcSrc.v4 = ipHeader->ip_src;
 125   //mcDst.v4 = ipHeader->ip_dst;
 126   //OLSR_DEBUG(LOG_PLUGINS, "MDNS PLUGIN got packet from OLSR message\n");
 127
 128
 129   /* Check with each network interface what needs to be done on it */
 130   for (walker = BmfInterfaces; walker != NULL; walker = walker->next) {
 131     /* To a non-OLSR interface: unpack the encapsulated IP packet and forward it */
 132     if (walker->olsrIntf == NULL) {
 133       int nBytesWritten;
 134       struct sockaddr_ll dest;
 135
 136       memset(&dest, 0, sizeof(dest));
 137       dest.sll_family = AF_PACKET;
 138       if ((encapsulationUdpData[0] & 0xf0) == 0x40) {
 139         dest.sll_protocol = htons(ETH_P_IP);
 140         stripped_len = ntohs(ipHeader->ip_len);
 141         if(my_TTL_Check)
 142                 ipHeader->ip_ttl = (u_int8_t) 1; //setting up TTL to 1 to avoid mdns packets flood
 143         }
 144         //Recalculate IP Checksum
 145         ipHeader->ip_sum=0x0000;
 146         csum_ip = ip_checksum((char*)ipHeader, IPH_HL(ipHeader));
 147         ipHeader->ip_sum=csum_ip;
 148
 149       if ((encapsulationUdpData[0] & 0xf0) == 0x60) {
 150         dest.sll_protocol = htons(ETH_P_IPV6);
 151         stripped_len = 40 + ntohs(ip6Header->ip6_plen); //IPv6 Header size (40) + payload_len
 152         if(my_TTL_Check)
 153                 ip6Header->ip6_hops = (uint8_t) 1; //setting up Hop Limit to 1 to avoid mdns packets flood
 154         }
 155       // Sven-Ola: Don't know how to handle the "stripped_len is uninitialized" condition, maybe exit(1) is better...?
 156       if (0 == stripped_len) return;
 157       //TODO: if packet is not IP die here
 158
 159       if (stripped_len > len) {
 160         //OLSR_DEBUG(LOG_PLUGINS, "MDNS: Stripped len bigger than len ??\n");
 161         }
 162       dest.sll_ifindex = if_nametoindex(walker->ifName);
 163       dest.sll_halen = IFHWADDRLEN;
 164
 165       /* Use all-ones as destination MAC address. When the IP destination is
 166        * a multicast address, the destination MAC address should normally also
 167        * be a multicast address. E.g., when the destination IP is 224.0.0.1,
 168        * the destination MAC should be 01:00:5e:00:00:01. However, it does not
 169        * seem to matter when the destination MAC address is set to all-ones
 170        * in that case. */
 171       memset(dest.sll_addr, 0xFF, IFHWADDRLEN);
 172
 173       if(walker->isActive == 0) {            //Don't forward packet if isn't master router
 174        OLSR_PRINTF(1,"Not forwarding mDNS packet to interface %s because this router is not master\n",walker->ifName);
 175        return;
 176        }
 177       nBytesWritten = sendto(walker->capturingSkfd, encapsulationUdpData, stripped_len, 0, (struct sockaddr *)&dest, sizeof(dest));
 178       if (nBytesWritten != stripped_len) {
 179         BmfPError("sendto() error forwarding unpacked encapsulated pkt on \"%s\"", walker->ifName);
 180       } else {
 181
 182         //OLSR_PRINTF(
 183         //  2,
 184         //  "%s: --> unpacked and forwarded on \"%s\"\n",
 185         //  PLUGIN_NAME_SHORT,
 186         //  walker->ifName);
 187       }
 188     }                           /* if (walker->olsrIntf == NULL) */
 189   }
 190 }                               /* PacketReceivedFromOLSR */
 191
 192
 193 bool
 194 olsr_parser(union olsr_message *m, struct interface_olsr *in_if __attribute__ ((unused)), union olsr_ip_addr *ipaddr)
 195 {
 196   union olsr_ip_addr originator;
 197   int size;
 198   //OLSR_DEBUG(LOG_PLUGINS, "MDNS PLUGIN: Received msg in parser\n");
 199   /* Fetch the originator of the messsage */
 200   if (olsr_cnf->ip_version == AF_INET) {
 201     memcpy(&originator, &m->v4.originator, olsr_cnf->ipsize);
 202     size = ntohs(m->v4.olsr_msgsize);
 203   } else {
 204     memcpy(&originator, &m->v6.originator, olsr_cnf->ipsize);
 205     size = ntohs(m->v6.olsr_msgsize);
 206   }
 207
 208   /* Check if message originated from this node.
 209    *         If so - back off */
 210   if (ipequal(&originator, &olsr_cnf->main_addr))
 211     return false;
 212
 213   /* Check that the neighbor this message was received from is symmetric.
 214    *         If not - back off*/
 215   if (check_neighbor_link(ipaddr) != SYM_LINK) {
 216     //struct ipaddr_str strbuf;
 217     //OLSR_PRINTF(3, "NAME PLUGIN: Received msg from NON SYM neighbor %s\n", olsr_ip_to_string(&strbuf, ipaddr));
 218     return false;
 219   }
 220
 221   if (olsr_cnf->ip_version == AF_INET) {
 222     PacketReceivedFromOLSR((unsigned char *)&m->v4.message, size - 12);
 223   } else {
 224     PacketReceivedFromOLSR((unsigned char *)&m->v6.message, size - 12 - 96);
 225   }
 226 //forward the message
 227 return true;
 228 }
 229
 230 //Sends a packet in the OLSR network
 231 void
 232 olsr_mdns_gen(unsigned char *packet, int len)
 233 {
 234   /* send buffer: huge */
 235   char buffer[10240];
 236   int aligned_size;
 237   union olsr_message *message = (union olsr_message *)buffer;
 238   struct interface_olsr *ifn;
 239
 240   aligned_size=len;
 241
 242 if ((aligned_size % 4) != 0) {
 243     aligned_size = (aligned_size - (aligned_size % 4)) + 4;
 244   }
 245
 246   /* fill message */
 247   if (olsr_cnf->ip_version == AF_INET) {
 248     /* IPv4 */
 249     message->v4.olsr_msgtype = MESSAGE_TYPE;
 250     message->v4.olsr_vtime = reltime_to_me(MDNS_VALID_TIME * MSEC_PER_SEC);
 251     memcpy(&message->v4.originator, &olsr_cnf->main_addr, olsr_cnf->ipsize);
 252     //message->v4.ttl = MAX_TTL;
 253     if (my_MDNS_TTL) message->v4.ttl = my_MDNS_TTL;
 254     else message->v4.ttl = MAX_TTL;
 255     message->v4.hopcnt = 0;
 256     message->v4.seqno = htons(get_msg_seqno());
 257
 258     message->v4.olsr_msgsize = htons(aligned_size + 12);
 259
 260     memset(&message->v4.message, 0, aligned_size);
 261     memcpy(&message->v4.message, packet, len);
 262     aligned_size = aligned_size + 12;
 263   } else {
 264     /* IPv6 */
 265     message->v6.olsr_msgtype = MESSAGE_TYPE;
 266     message->v6.olsr_vtime = reltime_to_me(MDNS_VALID_TIME * MSEC_PER_SEC);
 267     memcpy(&message->v6.originator, &olsr_cnf->main_addr, olsr_cnf->ipsize);
 268     //message->v6.ttl = MAX_TTL;
 269     if (my_MDNS_TTL) message->v6.ttl = my_MDNS_TTL;
 270     else message->v6.ttl = MAX_TTL;
 271     message->v6.hopcnt = 0;
 272     message->v6.seqno = htons(get_msg_seqno());
 273
 274     message->v6.olsr_msgsize = htons(aligned_size + 12 + 96);
 275     memset(&message->v6.message, 0, aligned_size);
 276     memcpy(&message->v6.message, packet, len);
 277     aligned_size = aligned_size + 12 + 96;
 278   }
 279
 280   /* looping trough interfaces */
 281  for (ifn = ifnet; ifn; ifn = ifn->int_next) {
 282     //OLSR_PRINTF(1, "MDNS PLUGIN: Generating packet - [%s]\n", ifn->int_name);
 283
 284     if (net_outbuffer_push(ifn, message, aligned_size) != aligned_size) {
 285       /* send data and try again */
 286       net_output(ifn);
 287       if (net_outbuffer_push(ifn, message, aligned_size) != aligned_size) {
 288         //OLSR_PRINTF(1, "MDNS PLUGIN: could not send on interface: %s\n", ifn->int_name);
 289       }
 290     }
 291   }
 292 }
 293
 294 /* -------------------------------------------------------------------------
 295  * Function   : BmfPError
 296  * Description: Prints an error message at OLSR debug level 1.
 297  *              First the plug-in name is printed. Then (if format is not NULL
 298  *              and *format is not empty) the arguments are printed, followed
 299  *              by a colon and a blank. Then the message and a new-line.
 300  * Input      : format, arguments
 301  * Output     : none
 302  * Return     : none
 303  * Data Used  : none
 304  * ------------------------------------------------------------------------- */
 305
 306 void
 307 BmfPError(const char *format, ...)
 308 {
 309 #define MAX_STR_DESC 255
 310   char strDesc[MAX_STR_DESC];
 311
 312 #if !defined REMOVE_LOG_DEBUG
 313   //char *stringErr = strerror(errno);
 314 #endif /* !defined REMOVE_LOG_DEBUG */
 315   /* Rely on short-circuit boolean evaluation */
 316   if (format == NULL || *format == '\0') {
 317     //OLSR_DEBUG(LOG_PLUGINS, "%s: %s\n", PLUGIN_NAME, stringErr);
 318   } else {
 319     va_list arglist;
 320
 321     va_start(arglist, format);
 322     vsnprintf(strDesc, MAX_STR_DESC, format, arglist);
 323     va_end(arglist);
 324
 325     strDesc[MAX_STR_DESC - 1] = '\0';   /* Ensures null termination */
 326
 327     //OLSR_DEBUG(LOG_PLUGINS, "%s: %s\n", strDesc, stringErr);
 328   }
 329 }                               /* BmfPError */
 330
 331 /* -------------------------------------------------------------------------
 332  * Function   : MainAddressOf
 333  * Description: Lookup the main address of a node
 334  * Input      : ip - IP address of the node
 335  * Output     : none
 336  * Return     : The main IP address of the node
 337  * Data Used  : none
 338  * ------------------------------------------------------------------------- */
 339 union olsr_ip_addr *
 340 MainAddressOf(union olsr_ip_addr *ip)
 341 {
 342   union olsr_ip_addr *result;
 343
 344   /* TODO: mid_lookup_main_addr() is not thread-safe! */
 345   result = mid_lookup_main_addr(ip);
 346   if (result == NULL) {
 347     result = ip;
 348   }
 349   return result;
 350 }                               /* MainAddressOf */
 351
 352 int
 353 AddFilteredHost(const char *FilteredHost, void *data __attribute__ ((unused)),
 354                 set_plugin_parameter_addon addon __attribute__ ((unused))){
 355
 356   int res = 0;
 357   struct FilteredHost *tmp;
 358   tmp = (struct FilteredHost *) malloc(sizeof(struct FilteredHost));
 359   listbackport_init_node(&tmp->list);
 360
 361   if(FHListInit == 0){
 362     listbackport_init_head(&ListOfFilteredHosts);
 363     FHListInit = 1;
 364   }
 365
 366   if(olsr_cnf->ip_version == AF_INET){
 367     res = inet_pton(AF_INET, FilteredHost, &tmp->host.v4);
 368     if(res > 0){
 369       listbackport_add_tail(&ListOfFilteredHosts, &tmp->list);
 370     }
 371     else
 372       free(tmp);
 373   }
 374   else{
 375     res = inet_pton(AF_INET6, FilteredHost, &tmp->host.v6);
 376     if(res > 0)
 377       listbackport_add_tail(&ListOfFilteredHosts, &tmp->list);
 378     else
 379       free(tmp);
 380   }
 381
 382   return 0;
 383 }
 384
 385 int
 386 isInFilteredList(union olsr_ip_addr *src){
 387
 388   struct FilteredHost *tmp, *iterator;
 389   struct ipaddr_str buf1;
 390   struct ipaddr_str buf2;
 391
 392   if(FHListInit == 0){
 393     listbackport_init_head(&ListOfFilteredHosts);
 394     FHListInit = 1;
 395   }
 396
 397
 398   if(listbackport_is_empty(&ListOfFilteredHosts)) {
 399     OLSR_PRINTF(2,"Accept packet captured because of filtered hosts ACL: List Empty\n");
 400     return 0;
 401   }
 402
 403   OLSR_FOR_ALL_FILTEREDNODES_ENTRIES(tmp, iterator){
 404     OLSR_PRINTF(2, "Checking host: %s against list entry: %s\n", olsr_ip_to_string(&buf1, src), olsr_ip_to_string(&buf2, &tmp->host) );
 405     if(olsr_cnf->ip_version == AF_INET){
 406       if(memcmp(&tmp->host.v4, &src->v4, sizeof(struct in_addr)) == 0)
 407         return 1;
 408     }
 409     else{
 410       if(memcmp(&tmp->host.v6, &src->v6, sizeof(struct in6_addr)) == 0)
 411         return 1;
 412     }
 413   }
 414
 415   OLSR_PRINTF(2,"Accept packet captured because of filtered hosts ACL: Did not find any match in list\n");
 416   return 0;
 417 }
 418
 419 /* -------------------------------------------------------------------------
 420  * Function   : BmfPacketCaptured
 421  * Description: Handle a captured IP packet
 422  * Input      : intf - the network interface on which the packet was captured
 423  *              sllPkttype - the type of packet. Either PACKET_OUTGOING,
 424  *                PACKET_BROADCAST or PACKET_MULTICAST.
 425  *              encapsulationUdpData - space for the encapsulation header, followed by
 426  *                the captured IP packet
 427  * Output     : none
 428  * Return     : none
 429  * Data Used  : BmfInterfaces
 430  * Notes      : The IP packet is assumed to be captured on a socket of family
 431  *              PF_PACKET and type SOCK_DGRAM (cooked).
 432  * ------------------------------------------------------------------------- */
 433 static void
 434 BmfPacketCaptured(
 435                    //struct TBmfInterface* intf,
 436                    //unsigned char sllPkttype,
 437                    unsigned char *encapsulationUdpData, int nBytes)
 438 {
 439   union olsr_ip_addr dst;              /* Destination IP address in captured packet */
 440   union olsr_ip_addr src;
 441   struct ip *ipHeader;                 /* The IP header inside the captured IP packet */
 442   struct ip6_hdr *ipHeader6;           /* The IP header inside the captured IP packet */
 443   struct udphdr *udpHeader;
 444   u_int16_t destPort;
 445
 446   if ((encapsulationUdpData[0] & 0xf0) == 0x40) {       //IPV4
 447
 448     ipHeader = (struct ip *)ARM_NOWARN_ALIGN(encapsulationUdpData);
 449
 450     dst.v4 = ipHeader->ip_dst;
 451     src.v4 = ipHeader->ip_src;
 452
 453     /* Only forward multicast packets. If configured, also forward local broadcast packets */
 454     if (IsMulticast(&dst)) {
 455       /* continue */
 456     } else {
 457       return;
 458     }
 459     if (ipHeader->ip_p != SOL_UDP) {
 460       /* Not UDP */
 461       //OLSR_PRINTF(1,"NON UDP PACKET\n");
 462       return;                   /* for */
 463     }
 464     udpHeader = (struct udphdr *)ARM_NOWARN_ALIGN(encapsulationUdpData + GetIpHeaderLength(encapsulationUdpData));
 465     destPort = ntohs(udpHeader->dest);
 466     if (destPort != 5353) {
 467       return;
 468     }
 469     if(my_TTL_Check) {
 470         if(((u_int8_t) ipHeader->ip_ttl) <= ((u_int8_t) 1)) {   // Discard mdns packet with TTL limit 1 or less
 471         OLSR_PRINTF(1,"Discarding packet captured with TTL = 1\n");
 472         return;
 473         }
 474     }
 475
 476     if (isInFilteredList(&src)) {
 477       OLSR_PRINTF(1,"Discarding packet captured because of filtered hosts ACL\n");
 478       return;
 479     }
 480
 481   }                             //END IPV4
 482
 483   else if ((encapsulationUdpData[0] & 0xf0) == 0x60) {  //IPv6
 484
 485     ipHeader6 = (struct ip6_hdr *)ARM_NOWARN_ALIGN(encapsulationUdpData);
 486
 487     //TODO: mettere dentro src.v6 l'indirizzo IPv6
 488
 489     if (ipHeader6->ip6_dst.s6_addr[0] == 0xff)  //Multicast
 490     {
 491       //Continua
 492     } else {
 493       return;                   //not multicast
 494     }
 495     if (ipHeader6->ip6_nxt != SOL_UDP) {
 496       /* Not UDP */
 497       //OLSR_PRINTF(1,"NON UDP PACKET\n");
 498       return;                   /* for */
 499     }
 500     udpHeader = (struct udphdr *)ARM_NOWARN_ALIGN(encapsulationUdpData + 40);
 501     destPort = ntohs(udpHeader->dest);
 502     if (destPort != 5353) {
 503       return;
 504     }
 505     if(my_TTL_Check) {
 506         if(((uint8_t) ipHeader6->ip6_hops) <= ((uint8_t) 1)) { // Discard mdns packet with hop limit 1 or less
 507         OLSR_PRINTF(1,"Discarding packet captured with TTL = 1\n");
 508         return;
 509         }
 510         }
 511
 512     if (isInFilteredList(&src)) {
 513       OLSR_PRINTF(1,"Discarding packet captured because of filtered hosts ACL\n");
 514       return;
 515     }
 516
 517   }                             //END IPV6
 518   else
 519     return;                     //Is not IP packet
 520
 521   /* Check if the frame is captured on an OLSR-enabled interface */
 522   //isFromOlsrIntf = (intf->olsrIntf != NULL); TODO: put again this check
 523
 524   // send the packet to OLSR forward mechanism
 525   olsr_mdns_gen(encapsulationUdpData, nBytes);
 526 }                               /* BmfPacketCaptured */
 527
 528
 529 /* -------------------------------------------------------------------------
 530  * Function   : DoMDNS
 531  * Description: This function is registered with the OLSR scheduler and called when something is captured
 532  * Input      : none
 533  * Output     : none
 534  * Return     : none
 535  * Data Used  :
 536  * ------------------------------------------------------------------------- */
 537 void
 538 DoMDNS(int skfd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 539 {
 540   unsigned char rxBuffer[BMF_BUFFER_SIZE];
 541   if (skfd >= 0) {
 542     struct sockaddr_ll pktAddr;
 543     socklen_t addrLen = sizeof(pktAddr);
 544     int nBytes;
 545     unsigned char *ipPacket;
 546     struct TBmfInterface *walker;
 547
 548     /* Receive the captured Ethernet frame, leaving space for the BMF
 549      * encapsulation header */
 550     ipPacket = GetIpPacket(rxBuffer);
 551     nBytes = recvfrom(skfd, ipPacket, BMF_BUFFER_SIZE,  //TODO: understand how to change this
 552                       0, (struct sockaddr *)&pktAddr, &addrLen);
 553     if (nBytes < 0) {
 554
 555       return;                   /* for */
 556     }
 557
 558     /* if (nBytes < 0) */
 559     /* Check if the number of received bytes is large enough for an IP
 560      * packet which contains at least a minimum-size IP header.
 561      * Note: There is an apparent bug in the packet socket implementation in
 562      * combination with VLAN interfaces. On a VLAN interface, the value returned
 563      * by 'recvfrom' may (but need not) be 4 (bytes) larger than the value
 564      * returned on a non-VLAN interface, for the same ethernet frame. */
 565     if (nBytes < (int)sizeof(struct ip)) {
 566       ////OLSR_PRINTF(
 567       //              1,
 568       //              "%s: captured frame too short (%d bytes) on \"%s\"\n",
 569       //              PLUGIN_NAME,
 570       //              nBytes,
 571       //              walker->ifName);
 572
 573       return;                   /* for */
 574     }
 575
 576     for(walker = BmfInterfaces; walker != NULL; walker = walker->next){ //if the router isn't the master for this interface
 577       if(skfd == walker->capturingSkfd && walker->isActive == 0) {      //discard mdns packets
 578          OLSR_PRINTF(1,"Not capturing mDNS packet from interface %s because this router is not master\n",walker->ifName);
 579          return;
 580       }
 581     }
 582
 583     if (pktAddr.sll_pkttype == PACKET_OUTGOING ||
 584         pktAddr.sll_pkttype == PACKET_MULTICAST || pktAddr.sll_pkttype == PACKET_BROADCAST) {
 585       /* A multicast or broadcast packet was captured */
 586
 587       ////OLSR_PRINTF(
 588       //              1,
 589       //              "%s: captured frame (%d bytes) on \"%s\"\n",
 590       //              PLUGIN_NAME,
 591       //              nBytes,
 592       //              walker->ifName);
 593       //BmfPacketCaptured(walker, pktAddr.sll_pkttype, rxBuffer);
 594       BmfPacketCaptured(ipPacket, nBytes);
 595
 596     }                           /* if (pktAddr.sll_pkttype == ...) */
 597   }                             /* if (skfd >= 0 && (FD_ISSET...)) */
 598 }                               /* DoMDNS */
 599
 600 int
 601 InitMDNS(struct interface_olsr *skipThisIntf)
 602 {
 603   //Tells OLSR to launch olsr_parser when the packets for this plugin arrive
 604   olsr_parser_add_function(&olsr_parser, PARSER_TYPE);
 605   //Creates captures sockets and register them to the OLSR scheduler
 606   CreateBmfNetworkInterfaces(skipThisIntf);
 607   InitRouterList(NULL);
 608
 609   return 1;
 610 }                               /* InitMDNS */
 611
 612 /* -------------------------------------------------------------------------
 613  * Function   : CloseMDNS
 614  * Description: Close the MDNS plugin and clean up
 615  * Input      : none
 616  * Output     : none
 617  * Return     : none
 618  * Data Used  :
 619  * ------------------------------------------------------------------------- */
 620 void
 621 CloseMDNS(void)
 622 {
 623   CloseBmfNetworkInterfaces();
 624 }
 625
 626 void DoElection(int skfd, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 627 {
 628   static const char * rxBufferPrefix = "$REP";
 629   static const ssize_t rxBufferPrefixLength = 4;
 630   unsigned char rxBuffer[HELLO_BUFFER_SIZE];
 631   ssize_t rxCount;
 632   union olsr_sockaddr sender;
 633   socklen_t senderSize = sizeof(sender);
 634   struct RtElHelloPkt *rcvPkt;
 635   struct RouterListEntry *listEntry;
 636   struct RouterListEntry6 *listEntry6;
 637
 638   OLSR_PRINTF(1,"Packet Received \n");
 639
 640   if (skfd >= 0) {
 641     memset(&sender, 0, senderSize);
 642     rxCount = recvfrom(skfd, &rxBuffer[0], (sizeof(rxBuffer) - 1), 0,
 643                 (struct sockaddr *)&sender, &senderSize);
 644     if(rxCount < 0){
 645       BmfPError("Receive error in %s, ignoring message.", __func__);
 646       return;
 647     }
 648
 649   /* make sure the string is null terminated */
 650   rxBuffer[rxCount] = '\0';
 651
 652   /* do not process when this message doesn't start with $REP */
 653   if ((rxCount < rxBufferPrefixLength) || (strncmp((char *) rxBuffer,
 654                   rxBufferPrefix, rxBufferPrefixLength) != 0))
 655     return;
 656
 657   if ( rxCount < (int)sizeof(struct RtElHelloPkt))
 658     return;                                     // too small to be a hello pkt
 659   else
 660     rcvPkt = (struct RtElHelloPkt *)ARM_NOWARN_ALIGN(rxBuffer);
 661
 662   if (rcvPkt->ipFamily == AF_INET){
 663     listEntry = (struct RouterListEntry *)malloc(sizeof(struct RouterListEntry));
 664     if(ParseElectionPacket(rcvPkt, listEntry, skfd)){
 665       OLSR_PRINTF(1,"processing ipv4 packet \n");
 666       if(UpdateRouterList(listEntry))
 667         free(listEntry);
 668     }
 669     else{
 670       free(listEntry);
 671       return;                                   //packet not valid
 672     }
 673   }
 674   else{
 675     listEntry6 = (struct RouterListEntry6 *)malloc(sizeof(struct RouterListEntry6));
 676     if(ParseElectionPacket6(rcvPkt, listEntry6, skfd)){
 677       OLSR_PRINTF(1,"processing ipv6 packet");
 678       if(UpdateRouterList6(listEntry6))
 679         free(listEntry6);
 680     }
 681     else{
 682       free(listEntry6);
 683       return;                                   //packet not valid
 684     }
 685   }
 686
 687   }
 688  return;
 689 }