1 files changed, 470 insertions, 468 deletions
diff --git a/src/util/regex.c b/src/util/regex.c
index 24e83cfd1..d3ab35652 100644
--- a/src/util/regex.c
+++ b/src/util/regex.c
@@ -42,15 +42,15 @@
 *              bytes long.
 */
 void
-GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip,
+GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
-                             uint16_t port,
+                              uint16_t port,
-                             char *rxstr)
+                              char *rxstr)
 {
-  GNUNET_snprintf(rxstr,
+  GNUNET_snprintf (rxstr,
-                  GNUNET_TUN_IPV4_REGEXLEN,
+                   GNUNET_TUN_IPV4_REGEXLEN,
-                  "4-%04X-%08X",
+                   "4-%04X-%08X",
-                  (unsigned int)port,
+                   (unsigned int) port,
-                  ntohl(ip->s_addr));
+                   ntohl (ip->s_addr));
 }
@@ -63,21 +63,21 @@ GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip,
 *              bytes long.
 */
 void
-GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6,
+GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
-                             uint16_t port,
+                              uint16_t port,
-                             char *rxstr)
+                              char *rxstr)
 {
  const uint32_t *addr;
-  addr = (const uint32_t *)ipv6;
+  addr = (const uint32_t *) ipv6;
-  GNUNET_snprintf(rxstr,
+  GNUNET_snprintf (rxstr,
-                  GNUNET_TUN_IPV6_REGEXLEN,
+                   GNUNET_TUN_IPV6_REGEXLEN,
-                  "6-%04X-%08X%08X%08X%08X",
+                   "6-%04X-%08X%08X%08X%08X",
-                  (unsigned int)port,
+                   (unsigned int) port,
-                  ntohl(addr[0]),
+                   ntohl (addr[0]),
-                  ntohl(addr[1]),
+                   ntohl (addr[1]),
-                  ntohl(addr[2]),
+                   ntohl (addr[2]),
-                  ntohl(addr[3]));
+                   ntohl (addr[3]));
 }
@@ -88,59 +88,59 @@ GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6,
 * @param mask which bits in value are wildcards (any value)?
 */
 static char *
-nibble_to_regex(uint8_t value,
+nibble_to_regex (uint8_t value,
-                uint8_t mask)
+                 uint8_t mask)
 {
  char *ret;
  value &= mask;
  switch (mask)
-    {
+  {
-    case 0:
+  case 0:
-      return GNUNET_strdup(DOT);
+    return GNUNET_strdup (DOT);
-    case 8:
+  case 8:
-      GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                      "(%X|%X|%X|%X|%X|%X|%X|%X)",
+                     "(%X|%X|%X|%X|%X|%X|%X|%X)",
-                      value,
+                     value,
-                      value + 1,
+                     value + 1,
-                      value + 2,
+                     value + 2,
-                      value + 3,
+                     value + 3,
-                      value + 4,
+                     value + 4,
-                      value + 5,
+                     value + 5,
-                      value + 6,
+                     value + 6,
-                      value + 7);
+                     value + 7);
-      return ret;
+    return ret;
-    case 12:
+  case 12:
-      GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                      "(%X|%X|%X|%X)",
+                     "(%X|%X|%X|%X)",
-                      value,
+                     value,
-                      value + 1,
+                     value + 1,
-                      value + 2,
+                     value + 2,
-                      value + 3);
+                     value + 3);
-      return ret;
+    return ret;
-    case 14:
+  case 14:
-      GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                      "(%X|%X)",
+                     "(%X|%X)",
-                      value,
+                     value,
-                      value + 1);
+                     value + 1);
-      return ret;
+    return ret;
-    case 15:
+  case 15:
-      GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                      "%X",
+                     "%X",
-                      value);
+                     value);
-      return ret;
+    return ret;
-    default:
+  default:
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                 _("Bad mask: %d\n"),
+                _ ("Bad mask: %d\n"),
-                 mask);
+                mask);
-      GNUNET_break(0);
+    GNUNET_break (0);
-      return NULL;
+    return NULL;
-    }
+  }
 }
@@ -151,33 +151,33 @@ nibble_to_regex(uint8_t value,
 * @param mask which bits in value are wildcards (any value)?
 */
 static char *
-num_to_regex(uint16_t value,
+num_to_regex (uint16_t value,
-             uint16_t mask)
+              uint16_t mask)
 {
-  const uint8_t *v = (const uint8_t *)&value;
+  const uint8_t *v = (const uint8_t *) &value;
-  const uint8_t *m = (const uint8_t *)&mask;
+  const uint8_t *m = (const uint8_t *) &mask;
  char *a;
  char *b;
  char *c;
  char *d;
  char *ret;
-  a = nibble_to_regex(v[0] >> 4, m[0] >> 4);
+  a = nibble_to_regex (v[0] >> 4, m[0] >> 4);
-  b = nibble_to_regex(v[0] & 15, m[0] & 15);
+  b = nibble_to_regex (v[0] & 15, m[0] & 15);
-  c = nibble_to_regex(v[1] >> 4, m[1] >> 4);
+  c = nibble_to_regex (v[1] >> 4, m[1] >> 4);
-  d = nibble_to_regex(v[1] & 15, m[1] & 15);
+  d = nibble_to_regex (v[1] & 15, m[1] & 15);
  ret = NULL;
  if ((NULL != a) &&
      (NULL != b) &&
      (NULL != c) &&
      (NULL != d))
-    GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                    "%s%s%s%s",
+                     "%s%s%s%s",
-                    a, b, c, d);
+                     a, b, c, d);
-  GNUNET_free_non_null(a);
+  GNUNET_free_non_null (a);
-  GNUNET_free_non_null(b);
+  GNUNET_free_non_null (b);
-  GNUNET_free_non_null(c);
+  GNUNET_free_non_null (c);
-  GNUNET_free_non_null(d);
+  GNUNET_free_non_null (d);
  return ret;
 }
@@ -190,36 +190,36 @@ num_to_regex(uint16_t value,
 *         #GNUNET_NO if not
 */
 static int
-needs_parens(const char *arg)
+needs_parens (const char *arg)
 {
  size_t off;
  size_t len;
  unsigned int op;
  op = 0;
-  len = strlen(arg);
+  len = strlen (arg);
  for (off = 0; off < len; off++)
+  {
+    switch (arg[off])
    {
-      switch (arg[off])
+    case '(':
-        {
+      op++;
-        case '(':
+      break;
-          op++;
-          break;
+    case ')':
+      GNUNET_assert (op > 0);
-        case ')':
+      op--;
-          GNUNET_assert(op > 0);
+      break;
-          op--;
-          break;
+    case '|':
+      if (0 == op)
-        case '|':
+        return GNUNET_YES;
-          if (0 == op)
+      break;
-            return GNUNET_YES;
-          break;
+    default:
+      break;
-        default:
-          break;
-        }
    }
+  }
  return GNUNET_NO;
 }
@@ -235,10 +235,10 @@ needs_parens(const char *arg)
 * @return corresponding regex
 */
 static char *
-compute_policy(unsigned int start,
+compute_policy (unsigned int start,
-               unsigned int end,
+                unsigned int end,
-               unsigned int step,
+                unsigned int step,
-               const struct GNUNET_STRINGS_PortPolicy *pp)
+                const struct GNUNET_STRINGS_PortPolicy *pp)
 {
  unsigned int i;
  char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
@@ -249,7 +249,7 @@ compute_policy(unsigned int start,
  char middlehp[33 + 2]; /* 16 * 2 + 0-terminator + () */
  char middlelp[33 + 2]; /* 16 * 2 + 0-terminator + () */
  char afterp[36 + 2]; /* 16 * 2 + 3 dots + 0-terminator + () */
-  char dots[5 * strlen(DOT)];
+  char dots[5 * strlen (DOT)];
  char buf[3];
  char *middle;
  char *ret;
@@ -261,248 +261,248 @@ compute_policy(unsigned int start,
  unsigned int start_port;
  unsigned int end_port;
-  GNUNET_assert(GNUNET_YES == pp->negate_portrange);
+  GNUNET_assert (GNUNET_YES == pp->negate_portrange);
  start_port = pp->start_port;
  if (1 == start_port)
    start_port = 0;
  end_port = pp->end_port;
-  GNUNET_assert((end - start) / step <= 0xF);
+  GNUNET_assert ((end - start) / step <= 0xF);
  before[0] = '\0';
  middlel[0] = '\0';
  middleh[0] = '\0';
  after[0] = '\0';
  for (i = start; i <= end; i += step)
-    {
+  {
-      GNUNET_snprintf(buf,
+    GNUNET_snprintf (buf,
-                      sizeof(buf),
+                     sizeof(buf),
-                      "%X|",
+                     "%X|",
-                      (i - start) / step);
+                     (i - start) / step);
-      if (i / step < start_port / step)
+    if (i / step < start_port / step)
-        strcat(before, buf);
+      strcat (before, buf);
-      else if (i / step > end_port / step)
+    else if (i / step > end_port / step)
-        strcat(after, buf);
+      strcat (after, buf);
-      else if (i / step == start_port / step)
+    else if (i / step == start_port / step)
-        strcat(middlel, buf);
+      strcat (middlel, buf);
-      else if (i / step == end_port / step)
+    else if (i / step == end_port / step)
-        strcat(middleh, buf);
+      strcat (middleh, buf);
-    }
+  }
-  if (strlen(before) > 0)
+  if (strlen (before) > 0)
-    before[strlen(before) - 1] = '\0';
+    before[strlen (before) - 1] = '\0';
-  if (strlen(middlel) > 0)
+  if (strlen (middlel) > 0)
-    middlel[strlen(middlel) - 1] = '\0';
+    middlel[strlen (middlel) - 1] = '\0';
-  if (strlen(middleh) > 0)
+  if (strlen (middleh) > 0)
-    middleh[strlen(middleh) - 1] = '\0';
+    middleh[strlen (middleh) - 1] = '\0';
-  if (strlen(after) > 0)
+  if (strlen (after) > 0)
-    after[strlen(after) - 1] = '\0';
+    after[strlen (after) - 1] = '\0';
-  if (needs_parens(before))
+  if (needs_parens (before))
-    GNUNET_snprintf(beforep,
+    GNUNET_snprintf (beforep,
-                    sizeof(beforep),
+                     sizeof(beforep),
-                    "(%s)",
+                     "(%s)",
-                    before);
+                     before);
  else
-    strcpy(beforep, before);
+    strcpy (beforep, before);
-  if (needs_parens(middlel))
+  if (needs_parens (middlel))
-    GNUNET_snprintf(middlelp,
+    GNUNET_snprintf (middlelp,
-                    sizeof(middlelp),
+                     sizeof(middlelp),
-                    "(%s)",
+                     "(%s)",
-                    middlel);
+                     middlel);
  else
-    strcpy(middlelp, middlel);
+    strcpy (middlelp, middlel);
-  if (needs_parens(middleh))
+  if (needs_parens (middleh))
-    GNUNET_snprintf(middlehp,
+    GNUNET_snprintf (middlehp,
-                    sizeof(middlehp),
+                     sizeof(middlehp),
-                    "(%s)",
+                     "(%s)",
-                    middleh);
+                     middleh);
  else
-    strcpy(middlehp, middleh);
+    strcpy (middlehp, middleh);
-  if (needs_parens(after))
+  if (needs_parens (after))
-    GNUNET_snprintf(afterp,
+    GNUNET_snprintf (afterp,
-                    sizeof(afterp),
+                     sizeof(afterp),
-                    "(%s)",
+                     "(%s)",
-                    after);
+                     after);
  else
-    strcpy(afterp, after);
+    strcpy (afterp, after);
  dots[0] = '\0';
  for (xstep = step / 16; xstep > 0; xstep /= 16)
-    strcat(dots, DOT);
+    strcat (dots, DOT);
  if (step >= 16)
-    {
+  {
-      if (strlen(middlel) > 0)
+    if (strlen (middlel) > 0)
-        recl = compute_policy((start_port / step) * step,
+      recl = compute_policy ((start_port / step) * step,
-                              (start_port / step) * step + step - 1,
+                             (start_port / step) * step + step - 1,
-                              step / 16,
+                             step / 16,
-                              pp);
+                             pp);
-      else
+    else
-        recl = GNUNET_strdup("");
+      recl = GNUNET_strdup ("");
-      if (strlen(middleh) > 0)
+    if (strlen (middleh) > 0)
-        rech = compute_policy((end_port / step) * step,
+      rech = compute_policy ((end_port / step) * step,
-                              (end_port / step) * step + step - 1,
+                             (end_port / step) * step + step - 1,
-                              step / 16,
+                             step / 16,
-                              pp);
+                             pp);
-      else
+    else
-        rech = GNUNET_strdup("");
+      rech = GNUNET_strdup ("");
-    }
+  }
  else
-    {
+  {
-      recl = GNUNET_strdup("");
+    recl = GNUNET_strdup ("");
-      rech = GNUNET_strdup("");
+    rech = GNUNET_strdup ("");
-      middlel[0] = '\0';
+    middlel[0] = '\0';
-      middlelp[0] = '\0';
+    middlelp[0] = '\0';
-      middleh[0] = '\0';
+    middleh[0] = '\0';
-      middlehp[0] = '\0';
+    middlehp[0] = '\0';
-    }
+  }
-  if (needs_parens(recl))
+  if (needs_parens (recl))
-    GNUNET_asprintf(&reclp,
+    GNUNET_asprintf (&reclp,
-                    "(%s)",
+                     "(%s)",
-                    recl);
+                     recl);
  else
-    reclp = GNUNET_strdup(recl);
+    reclp = GNUNET_strdup (recl);
-  if (needs_parens(rech))
+  if (needs_parens (rech))
-    GNUNET_asprintf(&rechp,
+    GNUNET_asprintf (&rechp,
-                    "(%s)",
+                     "(%s)",
-                    rech);
+                     rech);
  else
-    rechp = GNUNET_strdup(rech);
+    rechp = GNUNET_strdup (rech);
-  if ((strlen(middleh) > 0) &&
+  if ((strlen (middleh) > 0) &&
-      (strlen(rech) > 0) &&
+      (strlen (rech) > 0) &&
-      (strlen(middlel) > 0) &&
+      (strlen (middlel) > 0) &&
-      (strlen(recl) > 0))
+      (strlen (recl) > 0))
-    {
+  {
-      GNUNET_asprintf(&middle,
+    GNUNET_asprintf (&middle,
-                      "%s%s|%s%s",
+                     "%s%s|%s%s",
-                      middlel,
+                     middlel,
-                      reclp,
+                     reclp,
-                      middleh,
+                     middleh,
-                      rechp);
+                     rechp);
-    }
+  }
-  else if ((strlen(middleh) > 0) &&
+  else if ((strlen (middleh) > 0) &&
-           (strlen(rech) > 0))
+           (strlen (rech) > 0))
-    {
+  {
-      GNUNET_asprintf(&middle,
+    GNUNET_asprintf (&middle,
-                      "%s%s",
+                     "%s%s",
-                      middleh,
+                     middleh,
-                      rechp);
+                     rechp);
-    }
+  }
-  else if ((strlen(middlel) > 0) &&
+  else if ((strlen (middlel) > 0) &&
-           (strlen(recl) > 0))
+           (strlen (recl) > 0))
-    {
+  {
-      GNUNET_asprintf(&middle,
+    GNUNET_asprintf (&middle,
-                      "%s%s",
+                     "%s%s",
-                      middlel,
+                     middlel,
-                      reclp);
+                     reclp);
-    }
+  }
  else
+  {
+    middle = GNUNET_strdup ("");
+  }
+  if ((strlen (before) > 0) &&
+      (strlen (after) > 0))
+  {
+    if (strlen (dots) > 0)
    {
-      middle = GNUNET_strdup("");
+      if (strlen (middle) > 0)
+        GNUNET_asprintf (&ret,
+                         "(%s%s|%s|%s%s)",
+                         beforep, dots,
+                         middle,
+                         afterp, dots);
+      else
+        GNUNET_asprintf (&ret,
+                         "(%s|%s)%s",
+                         beforep,
+                         afterp,
+                         dots);
    }
-  if ((strlen(before) > 0) &&
+    else
-      (strlen(after) > 0))
    {
-      if (strlen(dots) > 0)
+      if (strlen (middle) > 0)
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "(%s|%s|%s)",
-            GNUNET_asprintf(&ret,
+                         before,
-                            "(%s%s|%s|%s%s)",
+                         middle,
-                            beforep, dots,
+                         after);
-                            middle,
+      else if (1 == step)
-                            afterp, dots);
+        GNUNET_asprintf (&ret,
-          else
+                         "%s|%s",
-            GNUNET_asprintf(&ret,
+                         before,
-                            "(%s|%s)%s",
+                         after);
-                            beforep,
-                            afterp,
-                            dots);
-        }
      else
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "(%s|%s)",
-            GNUNET_asprintf(&ret,
+                         before,
-                            "(%s|%s|%s)",
+                         after);
-                            before,
-                            middle,
-                            after);
-          else if (1 == step)
-            GNUNET_asprintf(&ret,
-                            "%s|%s",
-                            before,
-                            after);
-          else
-            GNUNET_asprintf(&ret,
-                            "(%s|%s)",
-                            before,
-                            after);
-        }
    }
-  else if (strlen(before) > 0)
+  }
+  else if (strlen (before) > 0)
+  {
+    if (strlen (dots) > 0)
    {
-      if (strlen(dots) > 0)
+      if (strlen (middle) > 0)
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "(%s%s|%s)",
-            GNUNET_asprintf(&ret,
+                         beforep, dots,
-                            "(%s%s|%s)",
+                         middle);
-                            beforep, dots,
-                            middle);
-          else
-            GNUNET_asprintf(&ret,
-                            "%s%s",
-                            beforep, dots);
-        }
      else
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "%s%s",
-            GNUNET_asprintf(&ret,
+                         beforep, dots);
-                            "(%s|%s)",
-                            before,
-                            middle);
-          else
-            GNUNET_asprintf(&ret,
-                            "%s",
-                            before);
-        }
    }
-  else if (strlen(after) > 0)
+    else
    {
-      if (strlen(dots) > 0)
+      if (strlen (middle) > 0)
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "(%s|%s)",
-            GNUNET_asprintf(&ret,
+                         before,
-                            "(%s|%s%s)",
+                         middle);
-                            middle,
-                            afterp, dots);
-          else
-            GNUNET_asprintf(&ret,
-                            "%s%s",
-                            afterp, dots);
-        }
      else
-        {
+        GNUNET_asprintf (&ret,
-          if (strlen(middle) > 0)
+                         "%s",
-            GNUNET_asprintf(&ret,
+                         before);
-                            "%s|%s",
-                            middle,
-                            after);
-          else
-            GNUNET_asprintf(&ret,
-                            "%s",
-                            after);
-        }
    }
-  else if (strlen(middle) > 0)
+  }
+  else if (strlen (after) > 0)
+  {
+    if (strlen (dots) > 0)
    {
-      GNUNET_asprintf(&ret,
+      if (strlen (middle) > 0)
-                      "%s",
+        GNUNET_asprintf (&ret,
-                      middle);
+                         "(%s|%s%s)",
+                         middle,
+                         afterp, dots);
+      else
+        GNUNET_asprintf (&ret,
+                         "%s%s",
+                         afterp, dots);
    }
-  else
+    else
    {
-      ret = GNUNET_strdup("");
+      if (strlen (middle) > 0)
+        GNUNET_asprintf (&ret,
+                         "%s|%s",
+                         middle,
+                         after);
+      else
+        GNUNET_asprintf (&ret,
+                         "%s",
+                         after);
    }
-  GNUNET_free(middle);
+  }
-  GNUNET_free(reclp);
+  else if (strlen (middle) > 0)
-  GNUNET_free(rechp);
+  {
-  GNUNET_free(recl);
+    GNUNET_asprintf (&ret,
-  GNUNET_free(rech);
+                     "%s",
+                     middle);
+  }
+  else
+  {
+    ret = GNUNET_strdup ("");
+  }
+  GNUNET_free (middle);
+  GNUNET_free (reclp);
+  GNUNET_free (rechp);
+  GNUNET_free (recl);
+  GNUNET_free (rech);
  return ret;
 }
@@ -517,7 +517,7 @@ compute_policy(unsigned int start,
 * @return NULL on error
 */
 static char *
-port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp)
+port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
 {
  char *reg;
  char *ret;
@@ -529,53 +529,53 @@ port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp)
      ((1 == pp->start_port) &&
       (0xFFFF == pp->end_port) &&
       (GNUNET_NO == pp->negate_portrange)))
-    return GNUNET_strdup(DOT DOT DOT DOT);
+    return GNUNET_strdup (DOT DOT DOT DOT);
  if ((pp->start_port == pp->end_port) &&
      (GNUNET_NO == pp->negate_portrange))
-    {
+  {
-      GNUNET_asprintf(&ret,
+    GNUNET_asprintf (&ret,
-                      "%04X",
+                     "%04X",
-                      pp->start_port);
+                     pp->start_port);
-      return ret;
+    return ret;
-    }
+  }
  if (pp->end_port < pp->start_port)
    return NULL;
  if (GNUNET_YES == pp->negate_portrange)
-    {
+  {
-      ret = compute_policy(0, 0xFFFF, 0x1000, pp);
+    ret = compute_policy (0, 0xFFFF, 0x1000, pp);
-    }
+  }
  else
+  {
+    cnt = pp->end_port - pp->start_port + 1;
+    reg = GNUNET_malloc (cnt * 5 + 1);
+    pos = reg;
+    for (i = 1; i <= 0xFFFF; i++)
    {
-      cnt = pp->end_port - pp->start_port + 1;
+      if ((i >= pp->start_port) && (i <= pp->end_port))
-      reg = GNUNET_malloc(cnt * 5 + 1);
+      {
-      pos = reg;
+        if (pos == reg)
-      for (i = 1; i <= 0xFFFF; i++)
+        {
+          GNUNET_snprintf (pos,
+                           5,
+                           "%04X",
+                           i);
+        }
+        else
        {
-          if ((i >= pp->start_port) && (i <= pp->end_port))
+          GNUNET_snprintf (pos,
-            {
+                           6,
-              if (pos == reg)
+                           "|%04X",
-                {
+                           i);
-                  GNUNET_snprintf(pos,
-                                  5,
-                                  "%04X",
-                                  i);
-                }
-              else
-                {
-                  GNUNET_snprintf(pos,
-                                  6,
-                                  "|%04X",
-                                  i);
-                }
-              pos += strlen(pos);
-            }
        }
-      GNUNET_asprintf(&ret,
+        pos += strlen (pos);
-                      "(%s)",
+      }
-                      reg);
-      GNUNET_free(reg);
    }
+    GNUNET_asprintf (&ret,
+                     "(%s)",
+                     reg);
+    GNUNET_free (reg);
+  }
  return ret;
 }
@@ -589,9 +589,9 @@ port_to_regex(const struct GNUNET_STRINGS_PortPolicy *pp)
 * @return NULL on error, otherwise regex for the address
 */
 static char *
-address_to_regex(const void *addr,
+address_to_regex (const void *addr,
-                 const void *mask,
+                  const void *mask,
-                 size_t len)
+                  size_t len)
 {
  const uint16_t *a = addr;
  const uint16_t *m = mask;
@@ -601,29 +601,29 @@ address_to_regex(const void *addr,
  unsigned int i;
  ret = NULL;
-  GNUNET_assert(1 != (len % 2));
+  GNUNET_assert (1 != (len % 2));
  for (i = 0; i < len / 2; i++)
+  {
+    reg = num_to_regex (a[i], m[i]);
+    if (NULL == reg)
    {
-      reg = num_to_regex(a[i], m[i]);
+      GNUNET_free_non_null (ret);
-      if (NULL == reg)
+      return NULL;
-        {
+    }
-          GNUNET_free_non_null(ret);
+    if (NULL == ret)
-          return NULL;
+    {
-        }
+      ret = reg;
-      if (NULL == ret)
+    }
-        {
+    else
-          ret = reg;
+    {
-        }
+      GNUNET_asprintf (&tmp,
-      else
+                       "%s%s",
-        {
+                       ret, reg);
-          GNUNET_asprintf(&tmp,
+      GNUNET_free (ret);
-                          "%s%s",
+      GNUNET_free (reg);
-                          ret, reg);
+      ret = tmp;
-          GNUNET_free(ret);
-          GNUNET_free(reg);
-          ret = tmp;
-        }
    }
+  }
  return ret;
 }
@@ -635,28 +635,28 @@ address_to_regex(const void *addr,
 * @return NULL on error
 */
 static char *
-ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
+ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
 {
  char *reg;
  char *pp;
  char *ret;
-  reg = address_to_regex(&v4->network,
+  reg = address_to_regex (&v4->network,
-                         &v4->netmask,
+                          &v4->netmask,
-                         sizeof(struct in_addr));
+                          sizeof(struct in_addr));
  if (NULL == reg)
    return NULL;
-  pp = port_to_regex(&v4->pp);
+  pp = port_to_regex (&v4->pp);
  if (NULL == pp)
-    {
+  {
-      GNUNET_free(reg);
+    GNUNET_free (reg);
-      return NULL;
+    return NULL;
-    }
+  }
-  GNUNET_asprintf(&ret,
+  GNUNET_asprintf (&ret,
-                  "4-%s-%s",
+                   "4-%s-%s",
-                  pp, reg);
+                   pp, reg);
-  GNUNET_free(pp);
+  GNUNET_free (pp);
-  GNUNET_free(reg);
+  GNUNET_free (reg);
  return ret;
 }
@@ -668,28 +668,28 @@ ipv4_to_regex(const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
 * @return NULL on error
 */
 static char *
-ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
+ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
 {
  char *reg;
  char *pp;
  char *ret;
-  reg = address_to_regex(&v6->network,
+  reg = address_to_regex (&v6->network,
-                         &v6->netmask,
+                          &v6->netmask,
-                         sizeof(struct in6_addr));
+                          sizeof(struct in6_addr));
  if (NULL == reg)
    return NULL;
-  pp = port_to_regex(&v6->pp);
+  pp = port_to_regex (&v6->pp);
  if (NULL == pp)
-    {
+  {
-      GNUNET_free(reg);
+    GNUNET_free (reg);
-      return NULL;
+    return NULL;
-    }
+  }
-  GNUNET_asprintf(&ret,
+  GNUNET_asprintf (&ret,
-                  "6-%s-%s",
+                   "6-%s-%s",
-                  pp, reg);
+                   pp, reg);
-  GNUNET_free(pp);
+  GNUNET_free (pp);
-  GNUNET_free(reg);
+  GNUNET_free (reg);
  return ret;
 }
@@ -704,7 +704,7 @@ ipv6_to_regex(const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
 * @return regular expression, NULL on error
 */
 char *
-GNUNET_TUN_ipv4policy2regex(const char *policy)
+GNUNET_TUN_ipv4policy2regex (const char *policy)
 {
  struct GNUNET_STRINGS_IPv4NetworkPolicy *np;
  char *reg;
@@ -712,36 +712,36 @@ GNUNET_TUN_ipv4policy2regex(const char *policy)
  char *line;
  unsigned int i;
-  np = GNUNET_STRINGS_parse_ipv4_policy(policy);
+  np = GNUNET_STRINGS_parse_ipv4_policy (policy);
  if (NULL == np)
    return NULL;
  reg = NULL;
  for (i = 0; (0 == i) || (0 != np[i].network.s_addr); i++)
+  {
+    line = ipv4_to_regex (&np[i]);
+    if (NULL == line)
    {
-      line = ipv4_to_regex(&np[i]);
+      GNUNET_free_non_null (reg);
-      if (NULL == line)
+      GNUNET_free (np);
-        {
+      return NULL;
-          GNUNET_free_non_null(reg);
+    }
-          GNUNET_free(np);
+    if (NULL == reg)
-          return NULL;
+    {
-        }
+      reg = line;
-      if (NULL == reg)
-        {
-          reg = line;
-        }
-      else
-        {
-          GNUNET_asprintf(&tmp,
-                          "%s|(%s)",
-                          reg, line);
-          GNUNET_free(reg);
-          GNUNET_free(line);
-          reg = tmp;
-        }
-      if (0 == np[i].network.s_addr)
-        break;
    }
-  GNUNET_free(np);
+    else
+    {
+      GNUNET_asprintf (&tmp,
+                       "%s|(%s)",
+                       reg, line);
+      GNUNET_free (reg);
+      GNUNET_free (line);
+      reg = tmp;
+    }
+    if (0 == np[i].network.s_addr)
+      break;
+  }
+  GNUNET_free (np);
  return reg;
 }
@@ -756,7 +756,7 @@ GNUNET_TUN_ipv4policy2regex(const char *policy)
 * @return regular expression, NULL on error
 */
 char *
-GNUNET_TUN_ipv6policy2regex(const char *policy)
+GNUNET_TUN_ipv6policy2regex (const char *policy)
 {
  struct in6_addr zero;
  struct GNUNET_STRINGS_IPv6NetworkPolicy *np;
@@ -765,37 +765,39 @@ GNUNET_TUN_ipv6policy2regex(const char *policy)
  char *line;
  unsigned int i;
-  np = GNUNET_STRINGS_parse_ipv6_policy(policy);
+  np = GNUNET_STRINGS_parse_ipv6_policy (policy);
  if (NULL == np)
    return NULL;
  reg = NULL;
-  memset(&zero, 0, sizeof(struct in6_addr));
+  memset (&zero, 0, sizeof(struct in6_addr));
-  for (i = 0; (0 == i) || (0 != memcmp(&zero, &np[i].network, sizeof(struct in6_addr))); i++)
+  for (i = 0; (0 == i) || (0 != memcmp (&zero, &np[i].network, sizeof(struct
+                                                                      in6_addr)));
+       i++)
+  {
+    line = ipv6_to_regex (&np[i]);
+    if (NULL == line)
    {
-      line = ipv6_to_regex(&np[i]);
+      GNUNET_free_non_null (reg);
-      if (NULL == line)
+      GNUNET_free (np);
-        {
+      return NULL;
-          GNUNET_free_non_null(reg);
+    }
-          GNUNET_free(np);
+    if (NULL == reg)
-          return NULL;
+    {
-        }
+      reg = line;
-      if (NULL == reg)
+    }
-        {
+    else
-          reg = line;
+    {
-        }
+      GNUNET_asprintf (&tmp,
-      else
+                       "%s|(%s)",
-        {
+                       reg, line);
-          GNUNET_asprintf(&tmp,
+      GNUNET_free (reg);
-                          "%s|(%s)",
+      GNUNET_free (line);
-                          reg, line);
+      reg = tmp;
-          GNUNET_free(reg);
-          GNUNET_free(line);
-          reg = tmp;
-        }
-      if (0 == memcmp(&zero, &np[i].network, sizeof(struct in6_addr)))
-        break;
    }
-  GNUNET_free(np);
+    if (0 == memcmp (&zero, &np[i].network, sizeof(struct in6_addr)))
+      break;
+  }
+  GNUNET_free (np);
  return reg;
 }
@@ -809,12 +811,12 @@ GNUNET_TUN_ipv6policy2regex(const char *policy)
 * @param hc corresponding hash
 */
 void
-GNUNET_TUN_service_name_to_hash(const char *service_name,
+GNUNET_TUN_service_name_to_hash (const char *service_name,
-                                struct GNUNET_HashCode *hc)
+                                 struct GNUNET_HashCode *hc)
 {
-  GNUNET_CRYPTO_hash(service_name,
+  GNUNET_CRYPTO_hash (service_name,
-                     strlen(service_name),
+                      strlen (service_name),
-                     hc);
+                      hc);
 }
@@ -828,16 +830,16 @@ GNUNET_TUN_service_name_to_hash(const char *service_name,
 * @param[out] cadet_port CADET port to use
 */
 void
-GNUNET_TUN_compute_service_cadet_port(const struct GNUNET_HashCode *desc,
+GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
-                                      uint16_t ip_port,
+                                       uint16_t ip_port,
-                                      struct GNUNET_HashCode *cadet_port)
+                                       struct GNUNET_HashCode *cadet_port)
 {
-  uint16_t be_port = htons(ip_port);
+  uint16_t be_port = htons (ip_port);
  *cadet_port = *desc;
-  GNUNET_memcpy(cadet_port,
+  GNUNET_memcpy (cadet_port,
-                &be_port,
+                 &be_port,
-                sizeof(uint16_t));
+                 sizeof(uint16_t));
 }