Revert bernds patch do too much differences I cannot see the real changes :(
authorSven-Ola Tuecke <sven-ola@gmx.de>
Mon, 1 Dec 2008 23:20:06 +0000 (00:20 +0100)
committerSven-Ola Tuecke <sven-ola@gmx.de>
Mon, 1 Dec 2008 23:20:06 +0000 (00:20 +0100)
lib/quagga/test/quagga.try1.c
src/ipcalc.c
src/ipcalc.h

index 0a8927a..a617742 100644 (file)
@@ -1,8 +1,9 @@
-/* 
+
+/*
  *  (C) 2006 by Immo 'FaUl' Wehrenberg <immo@chaostreff-dortmund.de>
- *  
+ *
  *  This code is covered by the GPLv2
- *   
+ *
  */
 
 #include <stdint.h>
 #define ZAPI_MESSAGE_DISTANCE 0x04
 #define ZAPI_MESSAGE_METRIC   0x08
 
-
 #define STATUS_CONNECTED 1
 #define BUFSIZE 1024
 static char status = 0;
 
-static int zsock; // Socket to zebra...
-struct ipv4_route *quagga_routes = 0; // routes currently exportet to zebra
-
+static int zsock;                      // Socket to zebra...
+struct ipv4_route *quagga_routes = 0;  // routes currently exportet to zebra
 
 /* prototypes ntern */
-static char *try_read (ssize_t *);
-static char* zebra_route_packet (struct ipv4_route r, ssize_t *);
-static int parse_interface_add (char *, size_t);
-static int parse_interface_delete (char *, size_t);
-static int parse_interface_up (char *, size_t);
-static int parse_interface_down (char *, size_t);
-static int parse_interface_address_add (char *, size_t);
-static int parse_interface_address_delete (char *, size_t);
-static int parse_ipv4_route (char *, size_t, struct ipv4_route *);
-static int ipv4_route_add (char *, size_t);
-static int ipv4_route_delete (char *, size_t);
-static int parse_ipv6_route_add (char*, size_t);
-static uint32_t prefixlentomask (uint8_t);
-static void free_ipv4_route (struct ipv4_route);
-static void update_olsr_zebra_routes (struct ipv4_route*, struct ipv4_route*);
-static struct ipv4_route *zebra_create_ipv4_route_table_entry (uint32_t,
-                                                              uint32_t,
-                                                              uint32_t);
-static struct ipv4_route *zebra_create_ipv4_route_table (void);
-static void zebra_free_ipv4_route_table (struct ipv4_route*);
-static uint8_t masktoprefixlen (uint32_t);
-
-
+static char *try_read(ssize_t *);
+static char *zebra_route_packet(struct ipv4_route r, ssize_t *);
+static int parse_interface_add(char *, size_t);
+static int parse_interface_delete(char *, size_t);
+static int parse_interface_up(char *, size_t);
+static int parse_interface_down(char *, size_t);
+static int parse_interface_address_add(char *, size_t);
+static int parse_interface_address_delete(char *, size_t);
+static int parse_ipv4_route(char *, size_t, struct ipv4_route *);
+static int ipv4_route_add(char *, size_t);
+static int ipv4_route_delete(char *, size_t);
+static int parse_ipv6_route_add(char *, size_t);
+static uint32_t prefixlentomask(uint8_t);
+static void free_ipv4_route(struct ipv4_route);
+static void update_olsr_zebra_routes(struct ipv4_route *, struct ipv4_route *);
+static struct ipv4_route *zebra_create_ipv4_route_table_entry(uint32_t, uint32_t, uint32_t);
+static struct ipv4_route *zebra_create_ipv4_route_table(void);
+static void zebra_free_ipv4_route_table(struct ipv4_route *);
+static uint8_t masktoprefixlen(uint32_t);
 
 #ifdef MY_DEBUG
-static void dump_ipv4_route (struct ipv4_route r, char *c) {
+static void
+dump_ipv4_route(struct ipv4_route r, char *c)
+{
   int i = 0, x = 0;
 
-  puts (c);
+  puts(c);
   printf("type: %d\n", r.type);
   puts("flags:");
-  printf("  Internal: %s\n",r.flags&ZEBRA_FLAG_INTERNAL?"yes":"no");
-  printf("  Selfroute %s\n",r.flags&ZEBRA_FLAG_SELFROUTE?"yes":"no");
-  printf("  Blackhole %s\n",r.flags&ZEBRA_FLAG_BLACKHOLE?"yes":"no");
-  printf("  IBGP: %s\n",r.flags&ZEBRA_FLAG_IBGP?"yes":"no");
-  printf("  Selected: %s\n",r.flags&ZEBRA_FLAG_SELECTED?"yes":"no");
-  printf("  Changed: %s\n",r.flags&ZEBRA_FLAG_CHANGED?"yes":"no");
-  printf("  static: %s\n",r.flags&ZEBRA_FLAG_STATIC?"yes":"no");
-  printf("  reject: %s\n",r.flags&ZEBRA_FLAG_REJECT?"yes":"no");
+  printf("  Internal: %s\n", r.flags & ZEBRA_FLAG_INTERNAL ? "yes" : "no");
+  printf("  Selfroute %s\n", r.flags & ZEBRA_FLAG_SELFROUTE ? "yes" : "no");
+  printf("  Blackhole %s\n", r.flags & ZEBRA_FLAG_BLACKHOLE ? "yes" : "no");
+  printf("  IBGP: %s\n", r.flags & ZEBRA_FLAG_IBGP ? "yes" : "no");
+  printf("  Selected: %s\n", r.flags & ZEBRA_FLAG_SELECTED ? "yes" : "no");
+  printf("  Changed: %s\n", r.flags & ZEBRA_FLAG_CHANGED ? "yes" : "no");
+  printf("  static: %s\n", r.flags & ZEBRA_FLAG_STATIC ? "yes" : "no");
+  printf("  reject: %s\n", r.flags & ZEBRA_FLAG_REJECT ? "yes" : "no");
   puts("message:");
-  printf("  nexthop: %s\n",r.message&ZAPI_MESSAGE_NEXTHOP?"yes":"no");
-  printf("  ifindex: %s\n",r.message&ZAPI_MESSAGE_IFINDEX?"yes":"no");
-  printf("  distance: %s\n",r.message&ZAPI_MESSAGE_DISTANCE?"yes":"no");
-  printf("  metric: %s\n",r.message&ZAPI_MESSAGE_METRIC?"yes":"no");
+  printf("  nexthop: %s\n", r.message & ZAPI_MESSAGE_NEXTHOP ? "yes" : "no");
+  printf("  ifindex: %s\n", r.message & ZAPI_MESSAGE_IFINDEX ? "yes" : "no");
+  printf("  distance: %s\n", r.message & ZAPI_MESSAGE_DISTANCE ? "yes" : "no");
+  printf("  metric: %s\n", r.message & ZAPI_MESSAGE_METRIC ? "yes" : "no");
   printf("Prefixlen: %d\n", r.prefixlen);
   printf("Prefix: %d", (unsigned char)r.prefix);
-  c = (char*) &r.prefix;
-  while (++i < (r.prefixlen/8 + (r.prefixlen % 8 ? 1 : 0)))
-    printf(".%d",(unsigned char)*(c + i));
+  c = (char *)&r.prefix;
+  while (++i < (r.prefixlen / 8 + (r.prefixlen % 8 ? 1 : 0)))
+    printf(".%d", (unsigned char)*(c + i));
   while (i++ < 4)
     printf(".0");
   puts("");
-  i=0;
-  if (r.message&ZAPI_MESSAGE_NEXTHOP) {
-    
+  i = 0;
+  if (r.message & ZAPI_MESSAGE_NEXTHOP) {
+
     printf("nexthop-count: %d\n", r.nh_count);
     while (i++ < r.nh_count) {
-      c = (unsigned char*) &r.nexthops[i];
-      printf ("Nexthop %d: %d", i, (unsigned char) *c);
+      c = (unsigned char *)&r.nexthops[i];
+      printf("Nexthop %d: %d", i, (unsigned char)*c);
       while (++x < 4) {
-       printf (".%d", (unsigned char) c[x]);
+        printf(".%d", (unsigned char)c[x]);
       }
       puts("");
     }
-    i=0;
+    i = 0;
   }
-  if (r.message&ZAPI_MESSAGE_IFINDEX) {
-    
+  if (r.message & ZAPI_MESSAGE_IFINDEX) {
+
     printf("index-number: %d\n", r.ind_num);
     while (i++ < r.ind_num)
       printf("Index: %d: %d\n", i, r.index[i]);
-    i=0;
-    if (r.message&ZAPI_MESSAGE_DISTANCE)
-      printf("Distance: %d\n",r.distance);
-    if (r.message&ZAPI_MESSAGE_METRIC)
-      printf("Metric: %d\n",r.metric);
+    i = 0;
+    if (r.message & ZAPI_MESSAGE_DISTANCE)
+      printf("Distance: %d\n", r.distance);
+    if (r.message & ZAPI_MESSAGE_METRIC)
+      printf("Metric: %d\n", r.metric);
     puts("\n");
   }
 }
 #endif
 
-void *my_realloc (void *buf, size_t s, const char *c) {
-  buf = realloc (buf, s);
+void *
+my_realloc(void *buf, size_t s, const char *c)
+{
+  buf = realloc(buf, s);
   if (!buf) {
 #ifdef OLSR_PLUGIN
-    OLSR_PRINTF (1, "OUT OF MEMORY: %s\n", strerror(errno));
+    OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", strerror(errno));
     olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %m\n");
     olsr_exit(c, EXIT_FAILURE);
 #else
-    exit (EXIT_FAILURE);
+    exit(EXIT_FAILURE);
 #endif
   }
   return buf;
 }
 
-
-#ifndef OLSR_PLUGIN 
-void *olsr_malloc (size_t f, const char *c) {
-  void* v = malloc (f);
+#ifndef OLSR_PLUGIN
+void *
+olsr_malloc(size_t f, const char *c)
+{
+  void *v = malloc(f);
   return v;
 }
 #endif
 
 /* Connect to the zebra-daemon, returns a socket */
-int init_zebra () {
+int
+init_zebra()
+{
   struct sockaddr_in i;
   int ret;
 
-  zsock = socket (AF_INET,SOCK_STREAM, 0);
-  if (zsock <0 ) // TODO: Could not create socket
+  zsock = socket(AF_INET, SOCK_STREAM, 0);
+  if (zsock < 0)                // TODO: Could not create socket
     return -1;
-  memset (&i, 0, sizeof i);
+  memset(&i, 0, sizeof i);
   i.sin_family = AF_INET;
-  i.sin_port = htons (ZEBRA_PORT);
+  i.sin_port = htons(ZEBRA_PORT);
   //  i.sin_len = sizeof i;
-  i.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-  
-  ret = connect (zsock, (struct sockaddr *)&i, sizeof i);
-  if  (ret < 0) {
-    close (zsock);
+  i.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+  ret = connect(zsock, (struct sockaddr *)&i, sizeof i);
+  if (ret < 0) {
+    close(zsock);
     return -1;
   }
   status |= STATUS_CONNECTED;
   return zsock;
 }
 
-    
-/* Sends a command to zebra, command is 
-   the command defined in zebra.h, options is the packet-payload, 
+/* Sends a command to zebra, command is
+   the command defined in zebra.h, options is the packet-payload,
    optlen the length, of the payload */
-char zebra_send_command (unsigned char command, char * options, int optlen) {
+char
+zebra_send_command(unsigned char command, char *options, int optlen)
+{
+
+  char *p = olsr_malloc(optlen + 3, "zebra send_command");
+  uint16_t length = optlen + 3;        // length of option + command + packet_length
 
-  char *p = olsr_malloc (optlen+3, "zebra send_command");
-  uint16_t length = optlen + 3;  // length of option + command + packet_length
-  
   int ret;
-  
+
   uint16_t len = htons(length);
-  memcpy (p, &len, 2);
+  memcpy(p, &len, 2);
   p[2] = command;
-  memcpy (p + 3, options, optlen);
-  
+  memcpy(p + 3, options, optlen);
+
   do {
-    ret = write (zsock, p, length);
+    ret = write(zsock, p, length);
     if (ret < 0) {
-      if (errno == EINTR) continue;
-    }
-    else return -1;
-    p = p+ret;
-  } while ((length =- ret));
+      if (errno == EINTR)
+        continue;
+    } else
+      return -1;
+    p = p + ret;
+  }
+  while ((length -= ret));
 
   return 0;
 }
 
-
-/* Creates a Route-Packet-Payload, needs address, netmask, nexthop, 
+/* Creates a Route-Packet-Payload, needs address, netmask, nexthop,
    distance, and a pointer of an size_t */
-static char* zebra_route_packet (struct ipv4_route r, ssize_t *optlen) {
+static char *
+zebra_route_packet(struct ipv4_route r, ssize_t * optlen)
+{
 
   char *cmdopt, *t;
-  *optlen = 9; // first: type, flags, message, prefixlen, nexthop number, nexthop)
+  *optlen = 9;                  // first: type, flags, message, prefixlen, nexthop number, nexthop)
   *optlen += r.prefixlen / 8 + (r.prefixlen % 8 ? 1 : 0);
-  
-  cmdopt = olsr_malloc (*optlen, "zebra add_v4_route");
+
+  cmdopt = olsr_malloc(*optlen, "zebra add_v4_route");
   t = cmdopt;
-  *t++ = 10; // Type: olsr
-  *t++ = r.flags; // flags
-  *t++ = r.message; // message: contains nexthop
+  *t++ = 10;                    // Type: olsr
+  *t++ = r.flags;               // flags
+  *t++ = r.message;             // message: contains nexthop
   *t++ = r.prefixlen;
-  memcpy (t, &r.prefix, r.prefixlen/8 + (r.prefixlen % 8 ? 1 : 0));
-  *t += r.prefixlen/8 + (r.prefixlen % 8 ? 1 : 0);
+  memcpy(t, &r.prefix, r.prefixlen / 8 + (r.prefixlen % 8 ? 1 : 0));
+  *t += r.prefixlen / 8 + (r.prefixlen % 8 ? 1 : 0);
   *t++ = r.nh_count;
-  memcpy (t, r.nexthops, r.nh_count * sizeof *r.nexthops);
+  memcpy(t, r.nexthops, r.nh_count * sizeof *r.nexthops);
   return cmdopt;
 }
 
-
 /* adds a route to zebra-daemon (needs socket from zebra,
    address = prefix of the route
    mask = netmask of the route
    nexthop = nexthop of the route
    distance = distance-value of the route
 */
-int zebra_add_v4_route (struct ipv4_route r) {
-  
+int
+zebra_add_v4_route(struct ipv4_route r)
+{
+
   char *cmdopt;
   ssize_t optlen;
 
-  cmdopt = zebra_route_packet (r, &optlen);
+  cmdopt = zebra_route_packet(r, &optlen);
 
-  puts ("DEBUG: zebra_route_packet returned");
-  
-  
+  puts("DEBUG: zebra_route_packet returned");
 
-  return zebra_send_command (ZEBRA_IPV4_ROUTE_ADD, cmdopt, optlen);
+  return zebra_send_command(ZEBRA_IPV4_ROUTE_ADD, cmdopt, optlen);
 
 }
 
@@ -243,44 +248,49 @@ int zebra_add_v4_route (struct ipv4_route r) {
    nexthop = nexthop of the route
    distance = distance-value of the route
 */
-int zebra_delete_v4_route (struct ipv4_route r) {
-  
+int
+zebra_delete_v4_route(struct ipv4_route r)
+{
+
   char *cmdopt;
   ssize_t optlen;
-  
-  cmdopt = zebra_route_packet (r, &optlen);
-  
-  return zebra_send_command (ZEBRA_IPV4_ROUTE_DELETE, cmdopt, optlen);
 
-}
+  cmdopt = zebra_route_packet(r, &optlen);
 
+  return zebra_send_command(ZEBRA_IPV4_ROUTE_DELETE, cmdopt, optlen);
+
+}
 
 /* Check wether there is data from zebra aviable */
-void zebra_check (void* foo) {
+void
+zebra_check(void *foo)
+{
   char *data, *f;
   ssize_t len, ret;
 
   if (!status & STATUS_CONNECTED) {
   }
-  data = try_read (&len);
+  data = try_read(&len);
   if (data) {
     f = data;
     do {
-      ret = zebra_parse_packet (f, len);
-      if (!ret) {//something wired happened
-       puts ("DEBUG: IIIIIIIIIIRGS");
-       exit (EXIT_FAILURE);
+      ret = zebra_parse_packet(f, len);
+      if (!ret) {               //something wired happened
+        puts("DEBUG: IIIIIIIIIIRGS");
+        exit(EXIT_FAILURE);
       }
       f += ret;
-    } while ((f - data) < len);
-    free (data);
+    }
+    while ((f - data) < len);
+    free(data);
   }
 }
 
-
 // tries to read a packet from zebra_socket
 // if there is something to read - make sure to read whole packages
-static char *try_read (ssize_t *len) {
+static char *
+try_read(ssize_t * len)
+{
   char *buf = NULL;
   ssize_t ret = 0, bsize = 0;
   uint16_t length = 0, l = 0;
@@ -288,24 +298,23 @@ static char *try_read (ssize_t *len) {
 
   *len = 0;
 
-  sockstate = fcntl (zsock, F_GETFL, 0);
-  fcntl (zsock, F_SETFL, sockstate|O_NONBLOCK);
+  sockstate = fcntl(zsock, F_GETFL, 0);
+  fcntl(zsock, F_SETFL, sockstate | O_NONBLOCK);
 
-  do { 
+  do {
     if (*len == bsize) {
       bsize += BUFSIZE;
-      buf = my_realloc (buf, bsize, "Zebra try_read");
+      buf = my_realloc(buf, bsize, "Zebra try_read");
     }
-    ret = read (zsock, buf + l, bsize - l);
+    ret = read(zsock, buf + l, bsize - l);
     if (ret <= 0) {
       if (errno == EAGAIN) {
-       errno = 0;
+        errno = 0;
+      } else {
+        // TODO: errorhandling
+        ;
       }
-      else {
-       // TODO: errorhandling
-       ;
-      }
-      free (buf);
+      free(buf);
       return NULL;
     }
     *len += ret;
@@ -313,141 +322,149 @@ static char *try_read (ssize_t *len) {
     while ((*len - l) > length) {
       //      printf ("DEBUG: *len -l > length - %d - %d > %d\n", *len, l, length);
       l += length;
-      memcpy (&length, buf + l, 2);
-      length = ntohs (length);
+      memcpy(&length, buf + l, 2);
+      length = ntohs(length);
     }
     //    printf ("DEBUG: *len, l, length: %d,%d,%d\n", *len, l, length);
-    if (((*len) - l) == length) break; // GOT FULL PACKAGE!!
+    if (((*len) - l) == length)
+      break;                    // GOT FULL PACKAGE!!
     if (*len < l) {
       //      printf ("DEBUG: *len, l, length: %d,%d,%d\n", *len, l, length);
-      fcntl (zsock, F_SETFL, sockstate);
+      fcntl(zsock, F_SETFL, sockstate);
       continue;
     }
-  } while (1);
+  }
+  while (1);
 
-  fcntl (zsock, F_SETFL, sockstate);
+  fcntl(zsock, F_SETFL, sockstate);
   return buf;
 }
 
-
 /* Parse a packet recived from zebra */
-int zebra_parse_packet (char *packet, ssize_t maxlen) {
+int
+zebra_parse_packet(char *packet, ssize_t maxlen)
+{
 
   /* Array of functions */
   int (*foo[ZEBRA_MESSAGE_MAX]) (char *, size_t) = {
-    parse_interface_add,
-    parse_interface_delete,
-    parse_interface_address_add,
-    parse_interface_address_delete,
-    parse_interface_up,
-    parse_interface_down,
-    ipv4_route_add,
-    ipv4_route_delete,
-    parse_ipv6_route_add
-  };
-  
-  puts ("DEBUG: zebra_parse_packet");
+  parse_interface_add, parse_interface_delete, parse_interface_address_add, parse_interface_address_delete, parse_interface_up,
+      parse_interface_down, ipv4_route_add, ipv4_route_delete, parse_ipv6_route_add};
+
+  puts("DEBUG: zebra_parse_packet");
   uint16_t length;
-  
+
   int ret;
-  memcpy (&length, packet, 2);
-  length = ntohs (length);
-  
+  memcpy(&length, packet, 2);
+  length = ntohs(length);
+
   if (maxlen < length) {
     puts("Error: programmer is an idiot");
-    printf ("DEBUG: maxlen = %d, packet_length = %d\n", maxlen, length);
+    printf("DEBUG: maxlen = %d, packet_length = %d\n", maxlen, length);
     return maxlen;
   }
 
-  if (packet[2] - 1 < ZEBRA_MESSAGE_MAX && foo[packet[2] - 1]) { 
-    if (!(ret = foo[packet[2] - 1] (packet + 3, length - 3))) 
+  if (packet[2] - 1 < ZEBRA_MESSAGE_MAX && foo[packet[2] - 1]) {
+    if (!(ret = foo[packet[2] - 1] (packet + 3, length - 3)))
       return length;
-    else printf ("DEBUG: Parse error: %d\n", ret);
-  }
-  else
-    printf ("Unknown packet type: %d\n", packet[2]);
+    else
+      printf("DEBUG: Parse error: %d\n", ret);
+  else
+    printf("Unknown packet type: %d\n", packet[2]);
 
-  puts ("Quagga: RECIVED PACKET FROM ZEBRA THAT I CAN'T PARSE");
+  puts("Quagga: RECIVED PACKET FROM ZEBRA THAT I CAN'T PARSE");
 
   return length;
 }
 
-
-static int parse_interface_add (char *opt, size_t len) {
+static int
+parse_interface_add(char *opt, size_t len)
+{
   //todo
   return 0;
 }
 
-
-static int parse_interface_delete (char *opt, size_t len) {
+static int
+parse_interface_delete(char *opt, size_t len)
+{
   //todo
   return 0;
 }
 
+static int
+parse_interface_address_add(char *opt, size_t len)
+{
 
-static int parse_interface_address_add (char *opt, size_t len) {
-  
   //todo
   return 0;
 }
 
-static int parse_interface_up (char *opt, size_t len) {
-  
+static int
+parse_interface_up(char *opt, size_t len)
+{
+
   //todo
   return 0;
 }
 
-static int parse_interface_down (char *opt, size_t len) {
-  
+static int
+parse_interface_down(char *opt, size_t len)
+{
+
   //todo
   return 0;
 }
 
-
-static int parse_interface_address_delete (char *opt, size_t  len) {
+static int
+parse_interface_address_delete(char *opt, size_t len)
+{
   //todo
   return 0;
 }
 
-
 /* Parse an ipv4-route-packet recived from zebra
  */
-static int parse_ipv4_route (char *opt, size_t len, struct ipv4_route *r) {
+static int
+parse_ipv4_route(char *opt, size_t len, struct ipv4_route *r)
+{
   //  puts ("DEBUG: parse_ipv4_route");
-  if (len < 4) return -1;
-  
+  if (len < 4)
+    return -1;
+
   r->type = *opt++;
   r->flags = *opt++;
   r->message = *opt++;
   r->prefixlen = *opt++;
   len -= 4;
   r->prefix = 0;
-  
-  if ((int)len < r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0)) return -1;
-  
-  memcpy (&r->prefix, opt, r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0));
-  opt += r->prefixlen/8 + (r->prefixlen % 8 ? 1 : 0);
-  
+
+  if ((int)len < r->prefixlen / 8 + (r->prefixlen % 8 ? 1 : 0))
+    return -1;
+
+  memcpy(&r->prefix, opt, r->prefixlen / 8 + (r->prefixlen % 8 ? 1 : 0));
+  opt += r->prefixlen / 8 + (r->prefixlen % 8 ? 1 : 0);
+
   if (r->message & ZAPI_MESSAGE_NEXTHOP) {
-    if (len < 1) return -1;
+    if (len < 1)
+      return -1;
     r->nh_count = *opt++;
-    if (len < sizeof (uint32_t) * r->nh_count) return -1;
-    r->nexthops = olsr_malloc (sizeof (uint32_t) * r->nh_count, 
-                              "quagga: parse_ipv4_route_add");
-    memcpy (r->nexthops, opt, sizeof (uint32_t) * r->nh_count);
-    opt += sizeof (uint32_t) * r->nh_count;
-    len -= sizeof (uint32_t) * r->nh_count + 1;
+    if (len < sizeof(uint32_t) * r->nh_count)
+      return -1;
+    r->nexthops = olsr_malloc(sizeof(uint32_t) * r->nh_count, "quagga: parse_ipv4_route_add");
+    memcpy(r->nexthops, opt, sizeof(uint32_t) * r->nh_count);
+    opt += sizeof(uint32_t) * r->nh_count;
+    len -= sizeof(uint32_t) * r->nh_count + 1;
   }
 
   if (r->message & ZAPI_MESSAGE_IFINDEX) {
-    if (len < 1) return -2;
+    if (len < 1)
+      return -2;
     r->ind_num = *opt++;
-    if (len < sizeof (uint32_t) * r->ind_num) return -3;
-    r->index = olsr_malloc (sizeof (uint32_t) * r->ind_num,
-                           "quagga: parse_ipv4_route_add");
-    memcpy (r->index, opt, r->ind_num * sizeof (uint32_t));
-    opt += sizeof (uint32_t) * r->ind_num;
-    len -= sizeof (uint32_t) * r->ind_num;
+    if (len < sizeof(uint32_t) * r->ind_num)
+      return -3;
+    r->index = olsr_malloc(sizeof(uint32_t) * r->ind_num, "quagga: parse_ipv4_route_add");
+    memcpy(r->index, opt, r->ind_num * sizeof(uint32_t));
+    opt += sizeof(uint32_t) * r->ind_num;
+    len -= sizeof(uint32_t) * r->ind_num;
   }
 
   if (r->message & ZAPI_MESSAGE_DISTANCE)
@@ -455,77 +472,87 @@ static int parse_ipv4_route (char *opt, size_t len, struct ipv4_route *r) {
     ;
 
   if (r->message & ZAPI_MESSAGE_METRIC) {
-    if (len < sizeof (uint32_t)) return -4;
-    memcpy (&r->metric, opt, sizeof (uint32_t));
+    if (len < sizeof(uint32_t))
+      return -4;
+    memcpy(&r->metric, opt, sizeof(uint32_t));
   }
 
   return 0;
 }
 
-
-static int ipv4_route_add (char *opt, size_t len) {
+static int
+ipv4_route_add(char *opt, size_t len)
+{
 
   struct ipv4_route r;
   int f;
-  
+
   //  puts ("DEBUG: ipv4_route_add");
-  
-  f = parse_ipv4_route (opt, len, &r);
+
+  f = parse_ipv4_route(opt, len, &r);
   if (f < 0) {
-    printf ("parse-error: %d\n",f);
+    printf("parse-error: %d\n", f);
     return f;
   }
-  
-  add_hna4_route (r);
+
+  add_hna4_route(r);
   return 0;
 }
 
-static int ipv4_route_delete (char *opt, size_t len) {
+static int
+ipv4_route_delete(char *opt, size_t len)
+{
   struct ipv4_route r;
   int f;
-  
-  f = parse_ipv4_route (opt, len, &r);
-  if (f < 0) return f;
 
-  return delete_hna4_route (r);
+  f = parse_ipv4_route(opt, len, &r);
+  if (f < 0)
+    return f;
+
+  return delete_hna4_route(r);
   // OK, now delete that foo
-  
+
 }
 
-static int parse_ipv6_route_add (char *opt, size_t len) {
+static int
+parse_ipv6_route_add(char *opt, size_t len)
+{
   //todo
   return 0;
 }
 
-
 /* start redistribution FROM zebra */
-int zebra_redistribute (unsigned char type) {
+int
+zebra_redistribute(unsigned char type)
+{
 
-  return zebra_send_command (ZEBRA_REDISTRIBUTE_ADD, &type, 1);
-  
-  
-}  
+  return zebra_send_command(ZEBRA_REDISTRIBUTE_ADD, &type, 1);
 
+}
 
 /* end redistribution FROM zebra */
-int zebra_disable_redistribute (unsigned char type) {
-  
-  return zebra_send_command (ZEBRA_REDISTRIBUTE_DELETE, &type, 1);
+int
+zebra_disable_redistribute(unsigned char type)
+{
+
+  return zebra_send_command(ZEBRA_REDISTRIBUTE_DELETE, &type, 1);
 
 }
-  
-/* this is buggy. see prefix_to_netmask4() for a working version. */
-static uint32_t prefixlentomask (uint8_t prefix) {
+
+static uint32_t
+prefixlentomask(uint8_t prefix)
+{
   uint32_t mask;
-  /* this is buggy. see prefix_to_netmask4() for a working version. */
-  mask = 0xffffffff<<(32-prefix);
+  mask = 0xffffffff << (32 - prefix);
   mask = ntohl(mask);
   return mask;
 }
 
-int add_hna4_route (struct ipv4_route r) {
+int
+add_hna4_route(struct ipv4_route r)
+{
   union olsr_ip_addr net, mask;
-  
+
 #ifdef MY_DEBUG
   dump_ipv4_route(r, "add_hna4_route");
 #endif
@@ -533,7 +560,6 @@ int add_hna4_route (struct ipv4_route r) {
   mask.v4 = prefixlentomask(r.prefixlen);
   net.v4 = r.prefix;
 
-
 #ifdef OLSR_PLUGIN
   add_local_hna4_entry(&net, &mask);
 #endif
@@ -541,7 +567,9 @@ int add_hna4_route (struct ipv4_route r) {
   return 0;
 }
 
-int delete_hna4_route (struct ipv4_route r) {
+int
+delete_hna4_route(struct ipv4_route r)
+{
 
   union olsr_ip_addr net, mask;
 
@@ -555,36 +583,43 @@ int delete_hna4_route (struct ipv4_route r) {
 #ifdef OLSR_PLUGIN
   return remove_local_hna4_entry(&net, &mask) ? 0 : -1;
 #endif
-  
+
   free_ipv4_route(r);
   return 0;
 
 }
 
-static void free_ipv4_route (struct ipv4_route r) {
+static void
+free_ipv4_route(struct ipv4_route r)
+{
 
-  if(r.message&ZAPI_MESSAGE_IFINDEX && r.ind_num) free(r.index);
-  if(r.message&ZAPI_MESSAGE_NEXTHOP && r.nh_count) free(r.nexthops);
+  if (r.message & ZAPI_MESSAGE_IFINDEX && r.ind_num)
+    free(r.index);
+  if (r.message & ZAPI_MESSAGE_NEXTHOP && r.nh_count)
+    free(r.nexthops);
 
 }
-void zebra_clear_routes(void) {
+
+void
+zebra_clear_routes(void)
+{
 
   struct ipv4_route *t;
 
   t = quagga_routes;
   while (t) {
     zebra_delete_v4_route(*t);
-    t=t->next;
+    t = t->next;
   }
   zebra_free_ipv4_route_table(quagga_routes);
 
   quagga_routes = NULL;
 }
 
+void
+zebra_update_hna(void *f)
+{
 
-void zebra_update_hna (void* f) {
-  
   struct ipv4_route *a = zebra_create_ipv4_route_table();
   update_olsr_zebra_routes(a, quagga_routes);
   zebra_free_ipv4_route_table(quagga_routes);
@@ -593,120 +628,101 @@ void zebra_update_hna (void* f) {
 
 }
 
-static struct ipv4_route *zebra_create_ipv4_route_table (void) {
+static struct ipv4_route *
+zebra_create_ipv4_route_table(void)
+{
 
-  struct ipv4_route *r = 0, *t = 0 /* make compiler happy */;
+  struct ipv4_route *r = 0, *t = 0 /* make compiler happy */ ;
   int i;
   struct hna_entry *e;
   struct hna_net *n;
 
   for (i = 0; i < HASHSIZE; i++) {
     e = hna_set[i].next;
-    for(;e != &hna_set[i];e = e->next) {
+    for (; e != &hna_set[i]; e = e->next) {
       n = e->networks.next;
-      for(;n != &e->networks; n = n->next) {
-       if (!r) {
-         r = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, 
-                                                 n->A_netmask.v4,
-                                                 e->A_gateway_addr.v4);
-         t = r;
-       }
-       else {
-         t->next = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, 
-                                                       n->A_netmask.v4,
-                                                       e->A_gateway_addr.v4);
-         t = t->next;
-       }
+      for (; n != &e->networks; n = n->next) {
+        if (!r) {
+          r = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, n->A_netmask.v4, e->A_gateway_addr.v4);
+          t = r;
+        } else {
+          t->next = zebra_create_ipv4_route_table_entry(n->A_network_addr.v4, n->A_netmask.v4, e->A_gateway_addr.v4);
+          t = t->next;
+        }
       }
     }
   }
-  
+
   return r;
-  
+
 }
 
+static struct ipv4_route *
+zebra_create_ipv4_route_table_entry(uint32_t addr, uint32_t mask, uint32_t gw)
+{
 
-static struct ipv4_route *zebra_create_ipv4_route_table_entry (uint32_t addr, 
-                                                              uint32_t mask,
-                                                              uint32_t gw) {
-  
   struct ipv4_route *r;
-  
 
-  r = olsr_malloc (sizeof *r,"zebra_create_ipv4_route_table_entry");
-  memset (r, 0, sizeof *r);
+  r = olsr_malloc(sizeof *r, "zebra_create_ipv4_route_table_entry");
+  memset(r, 0, sizeof *r);
   r->prefix = addr;
-  r->prefixlen = masktoprefixlen (mask);
+  r->prefixlen = masktoprefixlen(mask);
   r->message |= ZAPI_MESSAGE_NEXTHOP;
   r->nh_count = 1;
-  r->nexthops = olsr_malloc (sizeof (uint32_t), "zebra_create_ipv4_route_table_entry"); 
+  r->nexthops = olsr_malloc(sizeof(uint32_t), "zebra_create_ipv4_route_table_entry");
   *r->nexthops = gw;
   r->next = NULL;
 
   return r;
 }
 
-static uint8_t masktoprefixlen (uint32_t mask) {
-  
-  
-  uint8_t prefixlen = 0;
-  while (mask & (1 << ++prefixlen && prefixlen < 32);
-  return prefixlen;
-
-}
-
-static void update_olsr_zebra_routes (struct ipv4_route *a, 
-                                     struct ipv4_route *r) {
-  
-  struct ipv4_route *t;
+static uint8_t
+masktoprefixlen(uint32_t mask)
+{
 
-  if (!r) {
-    puts("no quagga_routing_table aviable");
-    for (;a;a = a->next) {
-      dump_ipv4_route (*a, "adding this route");
-      //      zebra_add_v4_route(*r);
-    }
-    return;
-  }
-
-  while (a) {
-    for (t = r; t; t = t->next) {
-      if (a->prefix == t->prefix) 
-       if (a->prefixlen == t->prefixlen)
-         if (*a->nexthops == *t->nexthops) {
-           goto foo;
-         }
-    }
-    dump_ipv4_route (*a, "adding this route");
-    //zebra_add_v4_route(*a);
+  uint8_t prefixlen = 0;
+while (mask & (1 << ++prefixlen && prefixlen < 32); return prefixlen;}
+
+       static void update_olsr_zebra_routes(struct ipv4_route *a, struct ipv4_route *r) {
+
+       struct ipv4_route * t; if (!r) {
+       puts("no quagga_routing_table aviable"); for (; a; a = a->next) {
+       dump_ipv4_route(*a, "adding this route");
+       //      zebra_add_v4_route(*r);
+       }
+       return;}
+
+       while (a) {
+       for (t = r; t; t = t->next) {
+       if (a->prefix == t->prefix) if (a->prefixlen == t->prefixlen) if (*a->nexthops == *t->nexthops) {
+       goto foo;}
+       }
+       dump_ipv4_route(*a, "adding this route");
+       //zebra_add_v4_route(*a);
   foo:
-    a = a->next;
-  }
-
-  while (r) {
-    for (t = a; t; t = t->next) {
-      if (r->prefix == t->prefix) 
-       if (r->prefixlen == t->prefixlen)
-         if (*r->nexthops == *t->nexthops) {
-           goto bar;
-         }
-    }
-    dump_ipv4_route (*r, "deleting this route");
-    //zebra_delete_v4_route(*r);
+       a = a->next;}
+
+       while (r) {
+       for (t = a; t; t = t->next) {
+       if (r->prefix == t->prefix) if (r->prefixlen == t->prefixlen) if (*r->nexthops == *t->nexthops) {
+       goto bar;}
+       }
+       dump_ipv4_route(*r, "deleting this route");
+       //zebra_delete_v4_route(*r);
   bar:
-    r = r->next;
-  }
+       r = r->next;}
 
-}
+       }
 
+       static void zebra_free_ipv4_route_table(struct ipv4_route *r) {
+       struct ipv4_route * n; if (!r) return; while ((n = r->next)) {
+       if (r->message & ZAPI_MESSAGE_NEXTHOP) free(r->nexthops); if (r->message & ZAPI_MESSAGE_IFINDEX) free(r->index); free(r);
+       r = n;}
+       }
 
-static void zebra_free_ipv4_route_table (struct ipv4_route *r) {
-  struct ipv4_route *n;
-  if (!r) return;
-  while ((n = r->next)) {
-    if (r->message & ZAPI_MESSAGE_NEXTHOP) free (r->nexthops);
-    if (r->message & ZAPI_MESSAGE_IFINDEX) free (r->index);
-    free(r);
-    r = n;
-  }
-}
+/*
+ * Local Variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */
index 210c6df..4a0e19a 100644 (file)
@@ -1,33 +1,34 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2007, Bernd Petrovitsch <berndæfirmix.at>
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
  * are met:
  *
- * * Redistributions of source code must retain the above copyright 
+ * * Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in 
- *   the documentation and/or other materials provided with the 
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
  *   distribution.
- * * Neither the name of olsr.org, olsrd nor the names of its 
- *   contributors may be used to endorse or promote products derived 
+ * * Neither the name of olsr.org, olsrd nor the names of its
+ *   contributors may be used to endorse or promote products derived
  *   from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
  * Visit http://www.olsr.org for more information.
@@ -41,7 +42,7 @@
 #include "ipcalc.h"
 
 int
-prefix_to_netmask(olsr_u8_t *a, int len, olsr_u8_t prefixlen)
+prefix_to_netmask(olsr_u8_t * a, int len, olsr_u8_t prefixlen)
 {
 #if !defined(NODEBUG) && defined(DEBUG)
   struct ipaddr_str buf;
@@ -50,7 +51,7 @@ prefix_to_netmask(olsr_u8_t *a, int len, olsr_u8_t prefixlen)
   int p;
   const olsr_u8_t *a_end;
 
-  a_end = a+len;
+  a_end = a + len;
   for (p = prefixlen; a < a_end && p > 8; p -= 8) {
     *a++ = 0xff;
   }
@@ -69,10 +70,10 @@ prefix_to_netmask(olsr_u8_t *a, int len, olsr_u8_t prefixlen)
 }
 
 olsr_u8_t
-netmask_to_prefix(const olsr_u8_t *adr, int len)
+netmask_to_prefix(const olsr_u8_t * adr, int len)
 {
   struct ipaddr_str buf;
-  const olsr_u8_t * const a_end = adr+len;
+  const olsr_u8_t *const a_end = adr + len;
   olsr_u16_t prefix = 0;
   const olsr_u8_t *a;
   for (a = adr; a < a_end && *a == 0xff; a++) {
@@ -81,15 +82,33 @@ netmask_to_prefix(const olsr_u8_t *adr, int len)
   if (a < a_end) {
     /* handle the last byte */
     switch (*a) {
-    case   0: prefix += 0; break;
-    case 128: prefix += 1; break;
-    case 192: prefix += 2; break;
-    case 224: prefix += 3; break;
-    case 240: prefix += 4; break;
-    case 248: prefix += 5; break;
-    case 252: prefix += 6; break;
-    case 254: prefix += 7; break;
-    case 255: prefix += 8; break; /* Shouldn't happen */
+    case 0:
+      prefix += 0;
+      break;
+    case 128:
+      prefix += 1;
+      break;
+    case 192:
+      prefix += 2;
+      break;
+    case 224:
+      prefix += 3;
+      break;
+    case 240:
+      prefix += 4;
+      break;
+    case 248:
+      prefix += 5;
+      break;
+    case 252:
+      prefix += 6;
+      break;
+    case 254:
+      prefix += 7;
+      break;
+    case 255:
+      prefix += 8;
+      break;                    /* Shouldn't happen */
     default:
       OLSR_PRINTF(0, "%s: Got bogus netmask %s\n", __func__, olsr_ip_to_string(&buf, (const union olsr_ip_addr *)adr));
       prefix = UCHAR_MAX;
@@ -110,7 +129,7 @@ olsr_ip_prefix_to_string(const struct olsr_ip_prefix *prefix)
   static char buf[MAX(INET6_ADDRSTRLEN + 1 + 3, INET_ADDRSTRLEN + 1 + INET_ADDRSTRLEN)];
   const char *rv;
 
-  if(olsr_cnf->ip_version == AF_INET) {
+  if (olsr_cnf->ip_version == AF_INET) {
     /* IPv4 */
     int len;
     union olsr_ip_addr netmask;
@@ -118,27 +137,27 @@ olsr_ip_prefix_to_string(const struct olsr_ip_prefix *prefix)
     len = strlen(buf);
     buf[len++] = '/';
     olsr_prefix_to_netmask(&netmask, prefix->prefix_len);
-    inet_ntop(AF_INET, &netmask.v4, buf+len, sizeof(buf)-len);
+    inet_ntop(AF_INET, &netmask.v4, buf + len, sizeof(buf) - len);
   } else {
     /* IPv6 */
     int len;
     rv = inet_ntop(AF_INET6, &prefix->prefix.v6, buf, sizeof(buf));
     len = strlen(buf);
     buf[len++] = '/';
-    snprintf(buf+len, sizeof(buf)-len, "/%d", prefix->prefix_len);
+    snprintf(buf + len, sizeof(buf) - len, "/%d", prefix->prefix_len);
   }
   return rv;
 }
 
-
 /* see if the ipaddr is in the net. That is equivalent to the fact that the net part
  * of both are equal. So we must compare the first <prefixlen> bits.
  */
-int ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net)
+int
+ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net)
 {
   int rv;
-  if(olsr_cnf->ip_version == AF_INET) {
-    uint32_t netmask = ntohl(prefix_to_netmask4(net->prefix_len));
+  if (olsr_cnf->ip_version == AF_INET) {
+    olsr_u32_t netmask = ~0 << (32 - net->prefix_len);
     rv = (ipaddr->v4.s_addr & netmask) == (net->prefix.v4.s_addr & netmask);
   } else {
     /* IPv6 */
@@ -146,7 +165,6 @@ int ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net
     const olsr_u32_t *i = (const olsr_u32_t *)&ipaddr->v6;
     const olsr_u32_t *n = (const olsr_u32_t *)&net->prefix.v6;
     unsigned int prefix_len;
-    /* First we compare whole unsigned int's */
     for (prefix_len = net->prefix_len; prefix_len > 32; prefix_len -= 32) {
       if (*i != *n) {
         return OLSR_FALSE;
@@ -154,8 +172,7 @@ int ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net
       i++;
       n++;
     }
-    /* And the remaining is the same as in the IPv4 case */
-    netmask = ntohl(prefix_to_netmask4(prefix_len));
+    netmask = ~0 << (32 - prefix_len);
     rv = (*i & netmask) == (*n & netmask);
   }
   return rv;
@@ -164,5 +181,6 @@ int ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net
 /*
  * Local Variables:
  * c-basic-offset: 2
+ * indent-tabs-mode: nil
  * End:
  */
index bb59566..315750d 100644 (file)
@@ -1,33 +1,34 @@
+
 /*
  * The olsr.org Optimized Link-State Routing daemon(olsrd)
  * Copyright (c) 2007, Bernd Petrovitsch <berndæfirmix.at>
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
  * are met:
  *
- * * Redistributions of source code must retain the above copyright 
+ * * Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright 
- *   notice, this list of conditions and the following disclaimer in 
- *   the documentation and/or other materials provided with the 
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
  *   distribution.
- * * Neither the name of olsr.org, olsrd nor the names of its 
- *   contributors may be used to endorse or promote products derived 
+ * * Neither the name of olsr.org, olsrd nor the names of its
+ *   contributors may be used to endorse or promote products derived
  *   from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
  * Visit http://www.olsr.org for more information.
 #include <arpa/inet.h>
 
 struct ipaddr_str {
-    char buf[MAX(INET6_ADDRSTRLEN, INET_ADDRSTRLEN)];
-} __attribute__((unused));
+  char buf[MAX(INET6_ADDRSTRLEN, INET_ADDRSTRLEN)];
+} __attribute__ ((unused));
 
 /*
  * Macros for comparing and copying IP addresses
  */
-static INLINE int ip4cmp(const struct in_addr *a, const struct in_addr *b) { return a->s_addr > b->s_addr ? +1 : a->s_addr < b->s_addr ? -1 : 0; }
-static INLINE int ip4equal(const struct in_addr *a, const struct in_addr *b) { return a->s_addr == b->s_addr; }
-
-static INLINE int ip6cmp(const struct in6_addr *a, const struct in6_addr *b) { return memcmp(a, b, sizeof(*a)); }
-static INLINE int ip6equal(const struct in6_addr *a, const struct in6_addr *b) { return ip6cmp(a, b) == 0; }
+static INLINE int
+ip4cmp(const struct in_addr *a, const struct in_addr *b)
+{
+  return a->s_addr > b->s_addr ? +1 : a->s_addr < b->s_addr ? -1 : 0;
+}
+static INLINE int
+ip4equal(const struct in_addr *a, const struct in_addr *b)
+{
+  return a->s_addr == b->s_addr;
+}
+
+static INLINE int
+ip6cmp(const struct in6_addr *a, const struct in6_addr *b)
+{
+  return memcmp(a, b, sizeof(*a));
+}
+static INLINE int
+ip6equal(const struct in6_addr *a, const struct in6_addr *b)
+{
+  return ip6cmp(a, b) == 0;
+}
 
 #if 0
-static INLINE int ipcmp(const union olsr_ip_addr *a, const union olsr_ip_addr *b) { return olsr_cnf->ip_version == AF_INET ? ip4cmp(&a->v4, &b->v4) : ip6cmp(&a->v6, &b->v6); }
+static INLINE int
+ipcmp(const union olsr_ip_addr *a, const union olsr_ip_addr *b)
+{
+  return olsr_cnf->ip_version == AF_INET ? ip4cmp(&a->v4, &b->v4) : ip6cmp(&a->v6, &b->v6);
+}
 #endif
-static INLINE int ipequal(const union olsr_ip_addr *a, const union olsr_ip_addr *b) { return olsr_cnf->ip_version == AF_INET ? ip4equal(&a->v4, &b->v4) : ip6equal(&a->v6, &b->v6); }
+static INLINE int
+ipequal(const union olsr_ip_addr *a, const union olsr_ip_addr *b)
+{
+  return olsr_cnf->ip_version == AF_INET ? ip4equal(&a->v4, &b->v4) : ip6equal(&a->v6, &b->v6);
+}
 
 /* Do not use this - this is as evil as the COPY_IP() macro was and only used in
  * source which also needs cleanups.
  */
-static INLINE void genipcopy(void *dst, const void *src) { memcpy(dst, src, olsr_cnf->ipsize); }
+static INLINE void
+genipcopy(void *dst, const void *src)
+{
+  memcpy(dst, src, olsr_cnf->ipsize);
+}
 
 int ip_in_net(const union olsr_ip_addr *ipaddr, const struct olsr_ip_prefix *net);
 
-
 int prefix_to_netmask(olsr_u8_t *, int, olsr_u8_t);
 
-static INLINE int olsr_prefix_to_netmask(union olsr_ip_addr *adr, olsr_u8_t prefixlen) { return prefix_to_netmask(adr->v6.s6_addr, olsr_cnf->ipsize, prefixlen); }
+static INLINE int
+olsr_prefix_to_netmask(union olsr_ip_addr *adr, olsr_u8_t prefixlen)
+{
+  return prefix_to_netmask(adr->v6.s6_addr, olsr_cnf->ipsize, prefixlen);
+}
 
 olsr_u8_t netmask_to_prefix(const olsr_u8_t *, int);
 
-static INLINE olsr_u8_t olsr_netmask_to_prefix(const union olsr_ip_addr *adr) { return netmask_to_prefix(adr->v6.s6_addr, olsr_cnf->ipsize); }
-
-static INLINE olsr_u8_t olsr_netmask4_to_prefix(const olsr_u32_t *a) { return netmask_to_prefix((const olsr_u8_t *)a, sizeof(*a)); }
-static INLINE olsr_u8_t olsr_netmask6_to_prefix(const struct in6_addr *a) { return netmask_to_prefix((const olsr_u8_t *)a, sizeof(*a)); }
-
-static INLINE const char *ip4_to_string(struct ipaddr_str * const buf, const struct in_addr addr4) { return inet_ntop(AF_INET, &addr4, buf->buf, sizeof(buf->buf)); }
-
-static INLINE const char *ip6_to_string(struct ipaddr_str * const buf, const struct in6_addr * const addr6) {  return inet_ntop(AF_INET6, addr6, buf->buf, sizeof(buf->buf)); }
-
-static INLINE const char *olsr_ip_to_string(struct ipaddr_str * const buf, const union olsr_ip_addr *addr) { return inet_ntop(olsr_cnf->ip_version, addr, buf->buf, sizeof(buf->buf)); }
+static INLINE olsr_u8_t
+olsr_netmask_to_prefix(const union olsr_ip_addr *adr)
+{
+  return netmask_to_prefix(adr->v6.s6_addr, olsr_cnf->ipsize);
+}
+
+static INLINE olsr_u8_t
+olsr_netmask4_to_prefix(const olsr_u32_t * a)
+{
+  return netmask_to_prefix((const olsr_u8_t *)a, sizeof(*a));
+}
+static INLINE olsr_u8_t
+olsr_netmask6_to_prefix(const struct in6_addr *a)
+{
+  return netmask_to_prefix((const olsr_u8_t *)a, sizeof(*a));
+}
+
+static INLINE const char *
+ip4_to_string(struct ipaddr_str *const buf, const struct in_addr addr4)
+{
+  return inet_ntop(AF_INET, &addr4, buf->buf, sizeof(buf->buf));
+}
+
+static INLINE const char *
+ip6_to_string(struct ipaddr_str *const buf, const struct in6_addr *const addr6)
+{
+  return inet_ntop(AF_INET6, addr6, buf->buf, sizeof(buf->buf));
+}
+
+static INLINE const char *
+olsr_ip_to_string(struct ipaddr_str *const buf, const union olsr_ip_addr *addr)
+{
+  return inet_ntop(olsr_cnf->ip_version, addr, buf->buf, sizeof(buf->buf));
+}
 
 const char *olsr_ip_prefix_to_string(const struct olsr_ip_prefix *prefix);
 
-static INLINE const char *sockaddr4_to_string(struct ipaddr_str * const buf, const struct sockaddr * const addr) { const struct sockaddr_in * const addr4 = (const struct sockaddr_in *)addr; return ip4_to_string(buf, addr4->sin_addr); }
+static INLINE const char *
+sockaddr4_to_string(struct ipaddr_str *const buf, const struct sockaddr *const addr)
+{
+  const struct sockaddr_in *const addr4 = (const struct sockaddr_in *)addr;
+  return ip4_to_string(buf, addr4->sin_addr);
+}
 
+#endif
 
-/* we need to handle one value specifically since shifting 32 bits of a 32 bit integer is the same as shifting 0 bits.
- * The result is in host-byte-order.
+/*
+ * Local Variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
  */
-static INLINE uint32_t prefix_to_netmask4(uint8_t prefixlen) { return prefixlen == 0 ? 0 : (~0U << (32 - prefixlen)); }
-
-#endif