* bytes long.
*/
void
-GNUNET_TUN_ipv4toregexsearch(const struct in_addr *ip,
- uint16_t port,
- char *rxstr)
+GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip,
+ uint16_t port,
+ char *rxstr)
{
- GNUNET_snprintf(rxstr,
- GNUNET_TUN_IPV4_REGEXLEN,
- "4-%04X-%08X",
- (unsigned int)port,
- ntohl(ip->s_addr));
+ GNUNET_snprintf (rxstr,
+ GNUNET_TUN_IPV4_REGEXLEN,
+ "4-%04X-%08X",
+ (unsigned int) port,
+ ntohl (ip->s_addr));
}
* bytes long.
*/
void
-GNUNET_TUN_ipv6toregexsearch(const struct in6_addr *ipv6,
- uint16_t port,
- char *rxstr)
+GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6,
+ uint16_t port,
+ char *rxstr)
{
const uint32_t *addr;
- addr = (const uint32_t *)ipv6;
- GNUNET_snprintf(rxstr,
- GNUNET_TUN_IPV6_REGEXLEN,
- "6-%04X-%08X%08X%08X%08X",
- (unsigned int)port,
- ntohl(addr[0]),
- ntohl(addr[1]),
- ntohl(addr[2]),
- ntohl(addr[3]));
+ addr = (const uint32_t *) ipv6;
+ GNUNET_snprintf (rxstr,
+ GNUNET_TUN_IPV6_REGEXLEN,
+ "6-%04X-%08X%08X%08X%08X",
+ (unsigned int) port,
+ ntohl (addr[0]),
+ ntohl (addr[1]),
+ ntohl (addr[2]),
+ ntohl (addr[3]));
}
* @param mask which bits in value are wildcards (any value)?
*/
static char *
-nibble_to_regex(uint8_t value,
- uint8_t mask)
+nibble_to_regex (uint8_t value,
+ uint8_t mask)
{
char *ret;
value &= mask;
switch (mask)
- {
- case 0:
- return GNUNET_strdup(DOT);
-
- case 8:
- GNUNET_asprintf(&ret,
- "(%X|%X|%X|%X|%X|%X|%X|%X)",
- value,
- value + 1,
- value + 2,
- value + 3,
- value + 4,
- value + 5,
- value + 6,
- value + 7);
- return ret;
-
- case 12:
- GNUNET_asprintf(&ret,
- "(%X|%X|%X|%X)",
- value,
- value + 1,
- value + 2,
- value + 3);
- return ret;
-
- case 14:
- GNUNET_asprintf(&ret,
- "(%X|%X)",
- value,
- value + 1);
- return ret;
-
- case 15:
- GNUNET_asprintf(&ret,
- "%X",
- value);
- return ret;
-
- default:
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
- _("Bad mask: %d\n"),
- mask);
- GNUNET_break(0);
- return NULL;
- }
+ {
+ case 0:
+ return GNUNET_strdup (DOT);
+
+ case 8:
+ GNUNET_asprintf (&ret,
+ "(%X|%X|%X|%X|%X|%X|%X|%X)",
+ value,
+ value + 1,
+ value + 2,
+ value + 3,
+ value + 4,
+ value + 5,
+ value + 6,
+ value + 7);
+ return ret;
+
+ case 12:
+ GNUNET_asprintf (&ret,
+ "(%X|%X|%X|%X)",
+ value,
+ value + 1,
+ value + 2,
+ value + 3);
+ return ret;
+
+ case 14:
+ GNUNET_asprintf (&ret,
+ "(%X|%X)",
+ value,
+ value + 1);
+ return ret;
+
+ case 15:
+ GNUNET_asprintf (&ret,
+ "%X",
+ value);
+ return ret;
+
+ default:
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _ ("Bad mask: %d\n"),
+ mask);
+ GNUNET_break (0);
+ return NULL;
+ }
}
* @param mask which bits in value are wildcards (any value)?
*/
static char *
-num_to_regex(uint16_t value,
- uint16_t mask)
+num_to_regex (uint16_t value,
+ uint16_t mask)
{
- const uint8_t *v = (const uint8_t *)&value;
- const uint8_t *m = (const uint8_t *)&mask;
+ const uint8_t *v = (const uint8_t *) &value;
+ 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);
- b = nibble_to_regex(v[0] & 15, m[0] & 15);
- c = nibble_to_regex(v[1] >> 4, m[1] >> 4);
- d = nibble_to_regex(v[1] & 15, m[1] & 15);
+ a = nibble_to_regex (v[0] >> 4, m[0] >> 4);
+ b = nibble_to_regex (v[0] & 15, m[0] & 15);
+ c = nibble_to_regex (v[1] >> 4, m[1] >> 4);
+ d = nibble_to_regex (v[1] & 15, m[1] & 15);
ret = NULL;
if ((NULL != a) &&
(NULL != b) &&
(NULL != c) &&
(NULL != d))
- GNUNET_asprintf(&ret,
- "%s%s%s%s",
- a, b, c, d);
- GNUNET_free_non_null(a);
- GNUNET_free_non_null(b);
- GNUNET_free_non_null(c);
- GNUNET_free_non_null(d);
+ GNUNET_asprintf (&ret,
+ "%s%s%s%s",
+ a, b, c, d);
+ GNUNET_free_non_null (a);
+ GNUNET_free_non_null (b);
+ GNUNET_free_non_null (c);
+ GNUNET_free_non_null (d);
return ret;
}
* #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++;
- break;
-
- case ')':
- GNUNET_assert(op > 0);
- op--;
- break;
-
- case '|':
- if (0 == op)
- return GNUNET_YES;
- break;
-
- default:
- break;
- }
+ case '(':
+ op++;
+ break;
+
+ case ')':
+ GNUNET_assert (op > 0);
+ op--;
+ break;
+
+ case '|':
+ if (0 == op)
+ return GNUNET_YES;
+ break;
+
+ default:
+ break;
}
+ }
return GNUNET_NO;
}
* @return corresponding regex
*/
static char *
-compute_policy(unsigned int start,
- unsigned int end,
- unsigned int step,
- const struct GNUNET_STRINGS_PortPolicy *pp)
+compute_policy (unsigned int start,
+ unsigned int end,
+ unsigned int step,
+ const struct GNUNET_STRINGS_PortPolicy *pp)
{
unsigned int i;
char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
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;
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,
- sizeof(buf),
- "%X|",
- (i - start) / step);
- if (i / step < start_port / step)
- strcat(before, buf);
- else if (i / step > end_port / step)
- strcat(after, buf);
- else if (i / step == start_port / step)
- strcat(middlel, buf);
- else if (i / step == end_port / step)
- strcat(middleh, buf);
- }
- if (strlen(before) > 0)
- before[strlen(before) - 1] = '\0';
- if (strlen(middlel) > 0)
- middlel[strlen(middlel) - 1] = '\0';
- if (strlen(middleh) > 0)
- middleh[strlen(middleh) - 1] = '\0';
- if (strlen(after) > 0)
- after[strlen(after) - 1] = '\0';
- if (needs_parens(before))
- GNUNET_snprintf(beforep,
- sizeof(beforep),
- "(%s)",
- before);
+ {
+ GNUNET_snprintf (buf,
+ sizeof(buf),
+ "%X|",
+ (i - start) / step);
+ if (i / step < start_port / step)
+ strcat (before, buf);
+ else if (i / step > end_port / step)
+ strcat (after, buf);
+ else if (i / step == start_port / step)
+ strcat (middlel, buf);
+ else if (i / step == end_port / step)
+ strcat (middleh, buf);
+ }
+ if (strlen (before) > 0)
+ before[strlen (before) - 1] = '\0';
+ if (strlen (middlel) > 0)
+ middlel[strlen (middlel) - 1] = '\0';
+ if (strlen (middleh) > 0)
+ middleh[strlen (middleh) - 1] = '\0';
+ if (strlen (after) > 0)
+ after[strlen (after) - 1] = '\0';
+ if (needs_parens (before))
+ GNUNET_snprintf (beforep,
+ sizeof(beforep),
+ "(%s)",
+ before);
else
- strcpy(beforep, before);
- if (needs_parens(middlel))
- GNUNET_snprintf(middlelp,
- sizeof(middlelp),
- "(%s)",
- middlel);
+ strcpy (beforep, before);
+ if (needs_parens (middlel))
+ GNUNET_snprintf (middlelp,
+ sizeof(middlelp),
+ "(%s)",
+ middlel);
else
- strcpy(middlelp, middlel);
- if (needs_parens(middleh))
- GNUNET_snprintf(middlehp,
- sizeof(middlehp),
- "(%s)",
- middleh);
+ strcpy (middlelp, middlel);
+ if (needs_parens (middleh))
+ GNUNET_snprintf (middlehp,
+ sizeof(middlehp),
+ "(%s)",
+ middleh);
else
- strcpy(middlehp, middleh);
- if (needs_parens(after))
- GNUNET_snprintf(afterp,
- sizeof(afterp),
- "(%s)",
- after);
+ strcpy (middlehp, middleh);
+ if (needs_parens (after))
+ GNUNET_snprintf (afterp,
+ sizeof(afterp),
+ "(%s)",
+ 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)
- recl = compute_policy((start_port / step) * step,
- (start_port / step) * step + step - 1,
- step / 16,
- pp);
- else
- recl = GNUNET_strdup("");
- if (strlen(middleh) > 0)
- rech = compute_policy((end_port / step) * step,
- (end_port / step) * step + step - 1,
- step / 16,
- pp);
- else
- rech = GNUNET_strdup("");
- }
+ {
+ if (strlen (middlel) > 0)
+ recl = compute_policy ((start_port / step) * step,
+ (start_port / step) * step + step - 1,
+ step / 16,
+ pp);
+ else
+ recl = GNUNET_strdup ("");
+ if (strlen (middleh) > 0)
+ rech = compute_policy ((end_port / step) * step,
+ (end_port / step) * step + step - 1,
+ step / 16,
+ pp);
+ else
+ rech = GNUNET_strdup ("");
+ }
else
- {
- recl = GNUNET_strdup("");
- rech = GNUNET_strdup("");
- middlel[0] = '\0';
- middlelp[0] = '\0';
- middleh[0] = '\0';
- middlehp[0] = '\0';
- }
- if (needs_parens(recl))
- GNUNET_asprintf(&reclp,
- "(%s)",
- recl);
+ {
+ recl = GNUNET_strdup ("");
+ rech = GNUNET_strdup ("");
+ middlel[0] = '\0';
+ middlelp[0] = '\0';
+ middleh[0] = '\0';
+ middlehp[0] = '\0';
+ }
+ if (needs_parens (recl))
+ GNUNET_asprintf (&reclp,
+ "(%s)",
+ recl);
else
- reclp = GNUNET_strdup(recl);
- if (needs_parens(rech))
- GNUNET_asprintf(&rechp,
- "(%s)",
- rech);
+ reclp = GNUNET_strdup (recl);
+ if (needs_parens (rech))
+ GNUNET_asprintf (&rechp,
+ "(%s)",
+ rech);
else
- rechp = GNUNET_strdup(rech);
-
- if ((strlen(middleh) > 0) &&
- (strlen(rech) > 0) &&
- (strlen(middlel) > 0) &&
- (strlen(recl) > 0))
- {
- GNUNET_asprintf(&middle,
- "%s%s|%s%s",
- middlel,
- reclp,
- middleh,
- rechp);
- }
- else if ((strlen(middleh) > 0) &&
- (strlen(rech) > 0))
- {
- GNUNET_asprintf(&middle,
- "%s%s",
- middleh,
- rechp);
- }
- else if ((strlen(middlel) > 0) &&
- (strlen(recl) > 0))
- {
- GNUNET_asprintf(&middle,
- "%s%s",
- middlel,
- reclp);
- }
+ rechp = GNUNET_strdup (rech);
+
+ if ((strlen (middleh) > 0) &&
+ (strlen (rech) > 0) &&
+ (strlen (middlel) > 0) &&
+ (strlen (recl) > 0))
+ {
+ GNUNET_asprintf (&middle,
+ "%s%s|%s%s",
+ middlel,
+ reclp,
+ middleh,
+ rechp);
+ }
+ else if ((strlen (middleh) > 0) &&
+ (strlen (rech) > 0))
+ {
+ GNUNET_asprintf (&middle,
+ "%s%s",
+ middleh,
+ rechp);
+ }
+ else if ((strlen (middlel) > 0) &&
+ (strlen (recl) > 0))
+ {
+ GNUNET_asprintf (&middle,
+ "%s%s",
+ middlel,
+ 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) &&
- (strlen(after) > 0))
+ else
{
- if (strlen(dots) > 0)
- {
- 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 (middle) > 0)
+ GNUNET_asprintf (&ret,
+ "(%s|%s|%s)",
+ before,
+ middle,
+ after);
+ else if (1 == step)
+ GNUNET_asprintf (&ret,
+ "%s|%s",
+ before,
+ after);
else
- {
- if (strlen(middle) > 0)
- GNUNET_asprintf(&ret,
- "(%s|%s|%s)",
- before,
- middle,
- after);
- else if (1 == step)
- GNUNET_asprintf(&ret,
- "%s|%s",
- before,
- after);
- else
- GNUNET_asprintf(&ret,
- "(%s|%s)",
- before,
- after);
- }
+ 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,
- "(%s%s|%s)",
- beforep, dots,
- middle);
- else
- GNUNET_asprintf(&ret,
- "%s%s",
- beforep, dots);
- }
+ if (strlen (middle) > 0)
+ GNUNET_asprintf (&ret,
+ "(%s%s|%s)",
+ beforep, dots,
+ middle);
else
- {
- if (strlen(middle) > 0)
- GNUNET_asprintf(&ret,
- "(%s|%s)",
- before,
- middle);
- else
- GNUNET_asprintf(&ret,
- "%s",
- before);
- }
+ GNUNET_asprintf (&ret,
+ "%s%s",
+ beforep, dots);
}
- else if (strlen(after) > 0)
+ else
{
- if (strlen(dots) > 0)
- {
- if (strlen(middle) > 0)
- GNUNET_asprintf(&ret,
- "(%s|%s%s)",
- middle,
- afterp, dots);
- else
- GNUNET_asprintf(&ret,
- "%s%s",
- afterp, dots);
- }
+ if (strlen (middle) > 0)
+ GNUNET_asprintf (&ret,
+ "(%s|%s)",
+ before,
+ middle);
else
- {
- if (strlen(middle) > 0)
- GNUNET_asprintf(&ret,
- "%s|%s",
- middle,
- after);
- else
- GNUNET_asprintf(&ret,
- "%s",
- after);
- }
+ GNUNET_asprintf (&ret,
+ "%s",
+ before);
}
- else if (strlen(middle) > 0)
+ }
+ else if (strlen (after) > 0)
+ {
+ if (strlen (dots) > 0)
{
- GNUNET_asprintf(&ret,
- "%s",
- middle);
+ if (strlen (middle) > 0)
+ GNUNET_asprintf (&ret,
+ "(%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);
- GNUNET_free(rechp);
- GNUNET_free(recl);
- GNUNET_free(rech);
+ }
+ else if (strlen (middle) > 0)
+ {
+ GNUNET_asprintf (&ret,
+ "%s",
+ middle);
+ }
+ else
+ {
+ ret = GNUNET_strdup ("");
+ }
+ GNUNET_free (middle);
+ GNUNET_free (reclp);
+ GNUNET_free (rechp);
+ GNUNET_free (recl);
+ GNUNET_free (rech);
return ret;
}
* @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;
((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,
- "%04X",
- pp->start_port);
- return ret;
- }
+ {
+ GNUNET_asprintf (&ret,
+ "%04X",
+ pp->start_port);
+ 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;
- reg = GNUNET_malloc(cnt * 5 + 1);
- pos = reg;
- for (i = 1; i <= 0xFFFF; i++)
+ if ((i >= pp->start_port) && (i <= pp->end_port))
+ {
+ if (pos == reg)
+ {
+ GNUNET_snprintf (pos,
+ 5,
+ "%04X",
+ i);
+ }
+ else
{
- if ((i >= pp->start_port) && (i <= pp->end_port))
- {
- if (pos == reg)
- {
- GNUNET_snprintf(pos,
- 5,
- "%04X",
- i);
- }
- else
- {
- GNUNET_snprintf(pos,
- 6,
- "|%04X",
- i);
- }
- pos += strlen(pos);
- }
+ GNUNET_snprintf (pos,
+ 6,
+ "|%04X",
+ i);
}
- GNUNET_asprintf(&ret,
- "(%s)",
- reg);
- GNUNET_free(reg);
+ pos += strlen (pos);
+ }
}
+ GNUNET_asprintf (&ret,
+ "(%s)",
+ reg);
+ GNUNET_free (reg);
+ }
return ret;
}
* @return NULL on error, otherwise regex for the address
*/
static char *
-address_to_regex(const void *addr,
- const void *mask,
- size_t len)
+address_to_regex (const void *addr,
+ const void *mask,
+ size_t len)
{
const uint16_t *a = addr;
const uint16_t *m = mask;
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]);
- if (NULL == reg)
- {
- GNUNET_free_non_null(ret);
- return NULL;
- }
- if (NULL == ret)
- {
- ret = reg;
- }
- else
- {
- GNUNET_asprintf(&tmp,
- "%s%s",
- ret, reg);
- GNUNET_free(ret);
- GNUNET_free(reg);
- ret = tmp;
- }
+ GNUNET_free_non_null (ret);
+ return NULL;
+ }
+ if (NULL == ret)
+ {
+ ret = reg;
+ }
+ else
+ {
+ GNUNET_asprintf (&tmp,
+ "%s%s",
+ ret, reg);
+ GNUNET_free (ret);
+ GNUNET_free (reg);
+ ret = tmp;
}
+ }
return ret;
}
* @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,
- &v4->netmask,
- sizeof(struct in_addr));
+ reg = address_to_regex (&v4->network,
+ &v4->netmask,
+ 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);
- return NULL;
- }
- GNUNET_asprintf(&ret,
- "4-%s-%s",
- pp, reg);
- GNUNET_free(pp);
- GNUNET_free(reg);
+ {
+ GNUNET_free (reg);
+ return NULL;
+ }
+ GNUNET_asprintf (&ret,
+ "4-%s-%s",
+ pp, reg);
+ GNUNET_free (pp);
+ GNUNET_free (reg);
return ret;
}
* @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,
- &v6->netmask,
- sizeof(struct in6_addr));
+ reg = address_to_regex (&v6->network,
+ &v6->netmask,
+ 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);
- return NULL;
- }
- GNUNET_asprintf(&ret,
- "6-%s-%s",
- pp, reg);
- GNUNET_free(pp);
- GNUNET_free(reg);
+ {
+ GNUNET_free (reg);
+ return NULL;
+ }
+ GNUNET_asprintf (&ret,
+ "6-%s-%s",
+ pp, reg);
+ GNUNET_free (pp);
+ GNUNET_free (reg);
return ret;
}
* @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;
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]);
- if (NULL == line)
- {
- GNUNET_free_non_null(reg);
- GNUNET_free(np);
- return NULL;
- }
- 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_non_null (reg);
+ GNUNET_free (np);
+ return NULL;
+ }
+ if (NULL == reg)
+ {
+ reg = line;
}
- 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;
}
* @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;
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));
- for (i = 0; (0 == i) || (0 != memcmp(&zero, &np[i].network, sizeof(struct in6_addr))); i++)
+ memset (&zero, 0, sizeof(struct in6_addr));
+ 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]);
- if (NULL == line)
- {
- GNUNET_free_non_null(reg);
- GNUNET_free(np);
- return NULL;
- }
- if (NULL == reg)
- {
- reg = line;
- }
- else
- {
- GNUNET_asprintf(&tmp,
- "%s|(%s)",
- reg, line);
- GNUNET_free(reg);
- GNUNET_free(line);
- reg = tmp;
- }
- if (0 == memcmp(&zero, &np[i].network, sizeof(struct in6_addr)))
- break;
+ GNUNET_free_non_null (reg);
+ GNUNET_free (np);
+ return NULL;
+ }
+ if (NULL == reg)
+ {
+ reg = line;
+ }
+ else
+ {
+ GNUNET_asprintf (&tmp,
+ "%s|(%s)",
+ reg, line);
+ GNUNET_free (reg);
+ GNUNET_free (line);
+ reg = tmp;
}
- GNUNET_free(np);
+ if (0 == memcmp (&zero, &np[i].network, sizeof(struct in6_addr)))
+ break;
+ }
+ GNUNET_free (np);
return reg;
}
* @param hc corresponding hash
*/
void
-GNUNET_TUN_service_name_to_hash(const char *service_name,
- struct GNUNET_HashCode *hc)
+GNUNET_TUN_service_name_to_hash (const char *service_name,
+ struct GNUNET_HashCode *hc)
{
- GNUNET_CRYPTO_hash(service_name,
- strlen(service_name),
- hc);
+ GNUNET_CRYPTO_hash (service_name,
+ strlen (service_name),
+ hc);
}
* @param[out] cadet_port CADET port to use
*/
void
-GNUNET_TUN_compute_service_cadet_port(const struct GNUNET_HashCode *desc,
- uint16_t ip_port,
- struct GNUNET_HashCode *cadet_port)
+GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc,
+ uint16_t ip_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,
- &be_port,
- sizeof(uint16_t));
+ GNUNET_memcpy (cadet_port,
+ &be_port,
+ sizeof(uint16_t));
}
projects / oweals / gnunet.git / blobdiff