regex.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for regex.c:

Go to the source code of this file.

Macros
#define	DOT   "(0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"
	'wildcard', matches all possible values (for HEX encoding). More...

Functions
void	GNUNET_TUN_ipv4toregexsearch (const struct in_addr *ip, uint16_t port, char *rxstr)
	Create a regex in rxstr from the given ip and port. More...
void	GNUNET_TUN_ipv6toregexsearch (const struct in6_addr *ipv6, uint16_t port, char *rxstr)
	Create a regex in rxstr from the given ipv6 and port. More...
static char *	nibble_to_regex (uint8_t value, uint8_t mask)
	Convert the given 4-bit (!) number to a regex. More...
static char *	num_to_regex (uint16_t value, uint16_t mask)
	Convert the given 16-bit number to a regex. More...
static int	needs_parens (const char *arg)
	Do we need to put parents around the given argument? More...
static char *	compute_policy (unsigned int start, unsigned int end, unsigned int step, const struct GNUNET_STRINGS_PortPolicy *pp)
	Compute port policy for the given range of port numbers. More...
static char *	port_to_regex (const struct GNUNET_STRINGS_PortPolicy *pp)
	Convert a port policy to a regular expression. More...
static char *	address_to_regex (const void *addr, const void *mask, size_t len)
	Convert an address (IPv4 or IPv6) to a regex. More...
static char *	ipv4_to_regex (const struct GNUNET_STRINGS_IPv4NetworkPolicy *v4)
	Convert a single line of an IPv4 policy to a regular expression. More...
static char *	ipv6_to_regex (const struct GNUNET_STRINGS_IPv6NetworkPolicy *v6)
	Convert a single line of an IPv4 policy to a regular expression. More...
char *	GNUNET_TUN_ipv4policy2regex (const char *policy)
	Convert an exit policy to a regular expression. More...
char *	GNUNET_TUN_ipv6policy2regex (const char *policy)
	Convert an exit policy to a regular expression. More...
void	GNUNET_TUN_service_name_to_hash (const char *service_name, struct GNUNET_HashCode *hc)
	Hash the service name of a hosted service to the hash code that is used to identify the service on the network. More...
void	GNUNET_TUN_compute_service_cadet_port (const struct GNUNET_HashCode *desc, uint16_t ip_port, struct GNUNET_HashCode *cadet_port)
	Compute the CADET port given a service descriptor (returned from GNUNET_TUN_service_name_to_hash) and a TCP/UDP port ip_port. More...

Macro Definition Documentation

DOT

#define DOT   "(0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)"

'wildcard', matches all possible values (for HEX encoding).

Definition at line 33 of file regex.c.

Function Documentation

nibble_to_regex()

static char* nibble_to_regex ( uint8_t  value, uint8_t  mask  )

static

Convert the given 4-bit (!) number to a regex.

Parameters

value	the value, only the lowest 4 bits will be looked at
mask	which bits in value are wildcards (any value)?

Definition at line 75 of file regex.c.

{
  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;
  }
}

References _, DOT, GNUNET_asprintf(), GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_strdup, ret, and value.

Referenced by num_to_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

num_to_regex()

static char* num_to_regex ( uint16_t  value, uint16_t  mask  )

static

Convert the given 16-bit number to a regex.

Parameters

value	the value
mask	which bits in value are wildcards (any value)?

Definition at line 138 of file regex.c.

{
  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);
  ret = NULL;
  if ((NULL != a) &&
      (NULL != b) &&
      (NULL != c) &&
      (NULL != d))
    GNUNET_asprintf (&ret,
                     "%s%s%s%s",
                     a, b, c, d);
  GNUNET_free (a);
  GNUNET_free (b);
  GNUNET_free (c);
  GNUNET_free (d);
  return ret;
}

References GNUNET_asprintf(), GNUNET_free, m, nibble_to_regex(), ret, and value.

Referenced by address_to_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

needs_parens()

static int needs_parens ( const char *  arg )

static

Do we need to put parents around the given argument?

Parameters

arg	part of a regular expression

Returns

GNUNET_YES if we should parens, GNUNET_NO if not

Definition at line 177 of file regex.c.

{
  size_t off;
  size_t len;
  unsigned int op;
 
  op = 0;
  len = strlen (arg);
  for (off = 0; off < len; off++)
  {
    switch (arg[off])
    {
    case '(':
      op++;
      break;
 
    case ')':
      GNUNET_assert (op > 0);
      op--;
      break;
 
    case '|':
      if (0 == op)
        return GNUNET_YES;
      break;
 
    default:
      break;
    }
  }
  return GNUNET_NO;
}

References find_typedefs::arg, GNUNET_assert, GNUNET_NO, GNUNET_YES, len, and op.

Referenced by compute_policy().

Here is the caller graph for this function:

compute_policy()

static char* compute_policy ( unsigned int  start, unsigned int  end, unsigned int  step, const struct GNUNET_STRINGS_PortPolicy *  pp  )

static

Compute port policy for the given range of port numbers.

Parameters

start	starting offset
end	end offset
step	increment level (power of 16)
pp	port policy to convert

Returns

corresponding regex

Definition at line 222 of file regex.c.

{
  unsigned int i;
  char before[36]; /* 16 * 2 + 3 dots + 0-terminator */
  char middlel[33]; /* 16 * 2 + 0-terminator */
  char middleh[33]; /* 16 * 2 + 0-terminator */
  char after[36]; /* 16 * 2 + 3 dots + 0-terminator */
  char beforep[36 + 2]; /* 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 buf[3];
  char *middle;
  char *ret;
  unsigned int xstep;
  char *recl;
  char *rech;
  char *reclp;
  char *rechp;
  unsigned int start_port;
  unsigned int end_port;
 
  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);
  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);
  else
    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);
  else
    strcpy (middlehp, middleh);
  if (needs_parens (after))
    GNUNET_snprintf (afterp,
                     sizeof(afterp),
                     "(%s)",
                     after);
  else
    strcpy (afterp, after);
  dots[0] = '\0';
  for (xstep = step / 16; xstep > 0; xstep /= 16)
    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 ("");
  }
  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);
  else
    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);
  }
  else
  {
    middle = GNUNET_strdup ("");
  }
  if ((strlen (before) > 0) &&
      (strlen (after) > 0))
  {
    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);
    }
    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);
    }
  }
  else if (strlen (before) > 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);
    }
    else
    {
      if (strlen (middle) > 0)
        GNUNET_asprintf (&ret,
                         "(%s|%s)",
                         before,
                         middle);
      else
        GNUNET_asprintf (&ret,
                         "%s",
                         before);
    }
  }
  else if (strlen (after) > 0)
  {
    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);
    }
    else
    {
      if (strlen (middle) > 0)
        GNUNET_asprintf (&ret,
                         "%s|%s",
                         middle,
                         after);
      else
        GNUNET_asprintf (&ret,
                         "%s",
                         after);
    }
  }
  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;
}

References buf, DOT, end, GNUNET_STRINGS_PortPolicy::end_port, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_snprintf(), GNUNET_strdup, GNUNET_YES, needs_parens(), GNUNET_STRINGS_PortPolicy::negate_portrange, ret, start, and GNUNET_STRINGS_PortPolicy::start_port.

Referenced by port_to_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

port_to_regex()

static char* port_to_regex ( const struct GNUNET_STRINGS_PortPolicy *  pp )

static

Convert a port policy to a regular expression.

Note: this is a very simplistic implementation, we might want to consider doing something more sophisiticated (resulting in smaller regular expressions) at a later time.

Parameters

pp	port policy to convert

Returns

NULL on error

Definition at line 504 of file regex.c.

{
  char *reg;
  char *ret;
  char *pos;
  unsigned int i;
  unsigned int cnt;
 
  if ((0 == pp->start_port) ||
      ((1 == pp->start_port) &&
       (0xFFFF == pp->end_port) &&
       (GNUNET_NO == pp->negate_portrange)))
    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;
  }
  if (pp->end_port < pp->start_port)
    return NULL;
 
  if (GNUNET_YES == pp->negate_portrange)
  {
    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++)
    {
      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_asprintf (&ret,
                     "(%s)",
                     reg);
    GNUNET_free (reg);
  }
  return ret;
}

References compute_policy(), DOT, GNUNET_STRINGS_PortPolicy::end_port, GNUNET_asprintf(), GNUNET_free, GNUNET_malloc, GNUNET_NO, GNUNET_snprintf(), GNUNET_strdup, GNUNET_YES, GNUNET_STRINGS_PortPolicy::negate_portrange, ret, and GNUNET_STRINGS_PortPolicy::start_port.

Referenced by ipv4_to_regex(), and ipv6_to_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

address_to_regex()

static char* address_to_regex ( const void *  addr, const void *  mask, size_t  len  )

static

Convert an address (IPv4 or IPv6) to a regex.

Parameters

addr	address
mask	network mask
len	number of bytes in addr and mask

Returns

NULL on error, otherwise regex for the address

Definition at line 576 of file regex.c.

{
  const uint16_t *a = addr;
  const uint16_t *m = mask;
  char *ret;
  char *tmp;
  char *reg;
  unsigned int i;
 
  ret = NULL;
  GNUNET_assert (1 != (len % 2));
  for (i = 0; i < len / 2; i++)
  {
    reg = num_to_regex (a[i], m[i]);
    if (NULL == reg)
    {
      GNUNET_free (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;
}

References GNUNET_asprintf(), GNUNET_assert, GNUNET_free, len, m, num_to_regex(), and ret.

Referenced by ipv4_to_regex(), and ipv6_to_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

ipv4_to_regex()

static char* ipv4_to_regex ( const struct GNUNET_STRINGS_IPv4NetworkPolicy *  v4 )

static

Convert a single line of an IPv4 policy to a regular expression.

Parameters

v4	line to convert

Returns

NULL on error

Definition at line 622 of file regex.c.

{
  char *reg;
  char *pp;
  char *ret;
 
  reg = address_to_regex (&v4->network,
                          &v4->netmask,
                          sizeof(struct in_addr));
  if (NULL == reg)
    return NULL;
  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);
  return ret;
}

References address_to_regex(), GNUNET_asprintf(), GNUNET_free, GNUNET_STRINGS_IPv4NetworkPolicy::netmask, GNUNET_STRINGS_IPv4NetworkPolicy::network, port_to_regex(), GNUNET_STRINGS_IPv4NetworkPolicy::pp, and ret.

Referenced by GNUNET_TUN_ipv4policy2regex().

Here is the call graph for this function:

Here is the caller graph for this function:

ipv6_to_regex()

static char* ipv6_to_regex ( const struct GNUNET_STRINGS_IPv6NetworkPolicy *  v6 )

static

Convert a single line of an IPv4 policy to a regular expression.

Parameters

v6	line to convert

Returns

NULL on error

Definition at line 655 of file regex.c.

{
  char *reg;
  char *pp;
  char *ret;
 
  reg = address_to_regex (&v6->network,
                          &v6->netmask,
                          sizeof(struct in6_addr));
  if (NULL == reg)
    return NULL;
  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);
  return ret;
}

References address_to_regex(), GNUNET_asprintf(), GNUNET_free, GNUNET_STRINGS_IPv6NetworkPolicy::netmask, GNUNET_STRINGS_IPv6NetworkPolicy::network, port_to_regex(), GNUNET_STRINGS_IPv6NetworkPolicy::pp, and ret.

Referenced by GNUNET_TUN_ipv6policy2regex().

Here is the call graph for this function:

Here is the caller graph for this function: