GNUnet  0.10.x
Data Structures | Functions
regex_test_lib.c File Reference

library to read regexes representing IP networks from a file. More...

#include "platform.h"
#include "gnunet_util_lib.h"
Include dependency graph for regex_test_lib.c:

Go to the source code of this file.

Data Structures

struct  RegexCombineCtx
 Struct to hold the tree formed by prefix-combining the regexes. More...
 

Functions

static int c2i (char c, int size)
 Char 2 int. More...
 
static void space (int n)
 Printf spaces to indent the regex tree. More...
 
static void debugctx (struct RegexCombineCtx *ctx, int level)
 Printf the combined regex ctx. More...
 
static void regex_add (struct RegexCombineCtx *ctx, const char *regex)
 Add a single regex to a context, combining with exisiting regex by-prefix. More...
 
static struct RegexCombineCtxnew_regex_ctx (unsigned int alphabet_size)
 Create and initialize a new RegexCombineCtx. More...
 
static void move_children (struct RegexCombineCtx *dst, const struct RegexCombineCtx *src)
 
static char * regex_combine (struct RegexCombineCtx *ctx)
 Extract a string from all prefix-combined regexes. More...
 
static unsigned int get_prefix_length (const char *s1, const char *s2)
 Get the number of matching characters on the prefix of both strings. More...
 
static struct RegexCombineCtxget_longest_prefix (struct RegexCombineCtx *ctx, const char *regex)
 Return the child context with the longest prefix match with the regex. More...
 
static void regex_add_multiple (struct RegexCombineCtx *ctx, const char *regex, struct RegexCombineCtx **children)
 
static void regex_split (struct RegexCombineCtx *ctx, unsigned int len, unsigned int prefix_l)
 Add a single regex to a context, splitting the exisiting state. More...
 
static void regex_ctx_destroy (struct RegexCombineCtx *ctx)
 Free all resources used by the context node and all its children. More...
 
char * REGEX_TEST_combine (char *const regexes[], unsigned int alphabet_size)
 Combine an array of regexes into a single prefix-shared regex. More...
 
char ** REGEX_TEST_read_from_file (const char *filename)
 Read a set of regexes from a file, one per line and return them in an array suitable for REGEX_TEST_combine. More...
 
void REGEX_TEST_free_from_file (char **regexes)
 Free all memory reserved for a set of regexes created by read_from_file. More...
 

Detailed Description

library to read regexes representing IP networks from a file.

and simplyfinying the into one big regex, in order to run tests (regex performance, cadet profiler).

Author
Bartlomiej Polot

Definition in file regex_test_lib.c.

Function Documentation

◆ c2i()

static int c2i ( char  c,
int  size 
)
static

Char 2 int.

Convert a character into its int value depending on the base used

Parameters
cChar
sizebase (2, 8 or 16(hex))
Returns
Int in range [0, (base-1)]

Definition at line 65 of file regex_test_lib.c.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, and GNUNET_log.

Referenced by debugctx(), regex_add(), regex_add_multiple(), and regex_split().

66 {
67  switch (size)
68  {
69  case 2:
70  case 8:
71  return c - '0';
72  break;
73  case 16:
74  if (c >= '0' && c <= '9')
75  return c - '0';
76  else if (c >= 'A' && c <= 'F')
77  return c - 'A' + 10;
78  else if (c >= 'a' && c <= 'f')
79  return c - 'a' + 10;
80  else
81  {
83  "Cannot convert char %c in base %u\n",
84  c, size);
85  GNUNET_assert (0);
86  }
87  break;
88  default:
89  GNUNET_assert (0);
90  }
91 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define GNUNET_log(kind,...)
Here is the caller graph for this function:

◆ space()

static void space ( int  n)
static

Printf spaces to indent the regex tree.

Parameters
nIndentation level

Definition at line 100 of file regex_test_lib.c.

Referenced by debugctx().

101 {
102  for (int i = 0; i < n; i++)
103  fprintf (stderr, "| ");
104 }
Here is the caller graph for this function:

◆ debugctx()

static void debugctx ( struct RegexCombineCtx ctx,
int  level 
)
static

Printf the combined regex ctx.

Parameters
ctxThe ctx to printf
levelIndentation level to start with

Definition at line 114 of file regex_test_lib.c.

References c2i(), RegexCombineCtx::children, ctx, regex_add(), RegexCombineCtx::s, RegexCombineCtx::size, and space().

Referenced by REGEX_TEST_combine().

115 {
116 #if DEBUG_REGEX
117  if (NULL != ctx->s)
118  {
119  space (level - 1);
120  fprintf (stderr, "%u:'%s'\n", c2i(ctx->s[0], ctx->size), ctx->s);
121  }
122  else
123  fprintf (stderr, "ROOT (base %u)\n", ctx->size);
124  for (unsigned int i = 0; i < ctx->size; i++)
125  {
126  if (NULL != ctx->children[i])
127  {
128  space (level);
129  debugctx (ctx->children[i], level + 1);
130  }
131  }
132  fflush(stderr);
133 #endif
134 }
static void space(int n)
Printf spaces to indent the regex tree.
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
unsigned int size
Alphabet size (how many children there are)
static void debugctx(struct RegexCombineCtx *ctx, int level)
Printf the combined regex ctx.
static int c2i(char c, int size)
Char 2 int.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ regex_add()

static void regex_add ( struct RegexCombineCtx ctx,
const char *  regex 
)
static

Add a single regex to a context, combining with exisiting regex by-prefix.

Parameters
ctxContext with 0 or more regexes.
regexRegex to add.

Definition at line 435 of file regex_test_lib.c.

References c2i(), RegexCombineCtx::children, get_longest_prefix(), get_prefix_length(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_strdup, l, len, new_regex_ctx(), p, regex_add_multiple(), regex_split(), RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by debugctx(), and REGEX_TEST_combine().

436 {
437  struct RegexCombineCtx *p;
438  struct RegexCombineCtx *newctx;
439  long unsigned int l;
440  unsigned int prefix_l;
441  const char *rest_r;
442  const char *rest_s;
443  size_t len;
444  int idx;
445 
447  "regex_add '%s' into '%s'\n",
448  regex, ctx->s);
449  l = strlen (regex);
450  if (0UL == l)
451  return;
452 
453  /* If the regex is in the form of (a|b|c), add every character separately */
454  if ('(' == regex[0])
455  {
456  regex_add_multiple (ctx, regex, NULL);
457  return;
458  }
459 
460  p = get_longest_prefix (ctx, regex);
461  if (NULL != p)
462  {
463  /* There is some prefix match, reduce regex and try again */
464  prefix_l = get_prefix_length (p->s, regex);
465  rest_s = &p->s[prefix_l];
466  rest_r = &regex[prefix_l];
467  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "chosen '%s' [%u]\n", p->s, prefix_l);
468  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "prefix r '%.*s'\n", prefix_l, p->s);
469  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest r '%s'\n", rest_r);
470  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest s '%s'\n", rest_s);
471  len = strlen (p->s);
472  if (prefix_l < len)
473  {
474  regex_split (p, len, prefix_l);
475  }
476  regex_add (p, rest_r);
477  return;
478  }
479 
480  /* There is no prefix match, add new */
481  idx = c2i(regex[0], ctx->size);
482  if (NULL == ctx->children[idx] && NULL != ctx->s)
483  {
484  /* this was the end before, add empty string */
485  newctx = new_regex_ctx (ctx->size);
486  newctx->s = GNUNET_strdup ("");
487  ctx->children[idx] = newctx;
488  }
489  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " no match\n");
490  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " new state %s\n", regex);
491  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " under %s\n", ctx->s);
492  newctx = new_regex_ctx(ctx->size);
493  newctx->s = GNUNET_strdup (regex);
494  ctx->children[idx] = newctx;
495 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
static struct RegexCombineCtx * get_longest_prefix(struct RegexCombineCtx *ctx, const char *regex)
Return the child context with the longest prefix match with the regex.
static void regex_add_multiple(struct RegexCombineCtx *ctx, const char *regex, struct RegexCombineCtx **children)
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
unsigned int size
Alphabet size (how many children there are)
static struct LoggingHandle * l
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static int c2i(char c, int size)
Char 2 int.
static void regex_split(struct RegexCombineCtx *ctx, unsigned int len, unsigned int prefix_l)
Add a single regex to a context, splitting the exisiting state.
#define GNUNET_log(kind,...)
static struct RegexCombineCtx * new_regex_ctx(unsigned int alphabet_size)
Create and initialize a new RegexCombineCtx.
static void regex_add(struct RegexCombineCtx *ctx, const char *regex)
Add a single regex to a context, combining with exisiting regex by-prefix.
static unsigned int get_prefix_length(const char *s1, const char *s2)
Get the number of matching characters on the prefix of both strings.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ new_regex_ctx()

static struct RegexCombineCtx* new_regex_ctx ( unsigned int  alphabet_size)
static

Create and initialize a new RegexCombineCtx.

Parameters
alphabet_sizeSize of the alphabet (and the Trie array)

Definition at line 154 of file regex_test_lib.c.

References RegexCombineCtx::children, ctx, GNUNET_malloc, GNUNET_new, and RegexCombineCtx::size.

Referenced by regex_add(), regex_add_multiple(), regex_split(), and REGEX_TEST_combine().

155 {
156  struct RegexCombineCtx *ctx;
157  size_t array_size;
158 
159  array_size = sizeof(struct RegexCombineCtx *) * alphabet_size;
160  ctx = GNUNET_new (struct RegexCombineCtx);
161  ctx->children = GNUNET_malloc (array_size);
162  ctx->size = alphabet_size;
163 
164  return ctx;
165 }
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
unsigned int size
Alphabet size (how many children there are)
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the caller graph for this function:

◆ move_children()

static void move_children ( struct RegexCombineCtx dst,
const struct RegexCombineCtx src 
)
static

Definition at line 169 of file regex_test_lib.c.

References RegexCombineCtx::children, GNUNET_memcpy, and RegexCombineCtx::size.

Referenced by regex_split().

171 {
172  size_t array_size;
173 
174  array_size = sizeof(struct RegexCombineCtx *) * src->size;
175  GNUNET_memcpy (dst->children,
176  src->children,
177  array_size);
178  for (unsigned int i = 0; i < src->size; i++)
179  {
180  src->children[i] = NULL;
181  }
182 }
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
unsigned int size
Alphabet size (how many children there are)
#define GNUNET_memcpy(dst, src, n)
Here is the caller graph for this function:

◆ regex_combine()

static char* regex_combine ( struct RegexCombineCtx ctx)
static

Extract a string from all prefix-combined regexes.

Parameters
ctxContext with 0 or more regexes.
Returns
Regex that matches any of the added regexes.

Definition at line 193 of file regex_test_lib.c.

References RegexCombineCtx::children, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_NO, GNUNET_strdup, GNUNET_YES, len, p, RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by REGEX_TEST_combine().

194 {
195  struct RegexCombineCtx *p;
196  unsigned int i;
197  size_t len;
198  char *regex;
199  char *tmp;
200  char *s;
201  int opt;
202 
203  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new combine %s\n", ctx->s);
204  regex = GNUNET_strdup ("");
205  opt = GNUNET_NO;
206  for (i = 0; i < ctx->size; i++)
207  {
208  p = ctx->children[i];
209  if (NULL == p)
210  continue;
212  "adding '%s' to innner %s\n",
213  p->s, ctx->s);
214  s = regex_combine (p);
215  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " total '%s'\n", s);
216  if (strlen(s) == 0)
217  {
218  opt = GNUNET_YES;
219  }
220  else
221  {
222  GNUNET_asprintf (&tmp, "%s%s|", regex, s);
223  GNUNET_free_non_null (regex);
224  regex = tmp;
225  }
227  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " so far '%s' for inner %s\n", regex, ctx->s);
228  }
229 
230  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "opt: %d, innner: '%s'\n", opt, regex);
231  len = strlen (regex);
232  if (0 == len)
233  {
234  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "empty, returning ''\n");
235  GNUNET_free (regex);
236  return NULL == ctx->s ? NULL : GNUNET_strdup (ctx->s);
237  }
238 
239  if ('|' == regex[len - 1])
240  regex[len - 1] = '\0';
241 
242  if (NULL != ctx->s)
243  {
244  if (opt)
245  GNUNET_asprintf (&s, "%s(%s)?", ctx->s, regex);
246  else
247  GNUNET_asprintf (&s, "%s(%s)", ctx->s, regex);
248  GNUNET_free (regex);
249  regex = s;
250  }
251 
252  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "partial: %s\n", regex);
253  return regex;
254 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
unsigned int size
Alphabet size (how many children there are)
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static char * regex_combine(struct RegexCombineCtx *ctx)
Extract a string from all prefix-combined regexes.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_prefix_length()

static unsigned int get_prefix_length ( const char *  s1,
const char *  s2 
)
static

Get the number of matching characters on the prefix of both strings.

Parameters
s1String 1.
s2String 2.
Returns
Number of characters of matching prefix.

Definition at line 266 of file regex_test_lib.c.

Referenced by get_longest_prefix(), and regex_add().

267 {
268  unsigned int l1;
269  unsigned int l2;
270  unsigned int limit;
271  unsigned int i;
272 
273  l1 = strlen (s1);
274  l2 = strlen (s2);
275  limit = l1 > l2 ? l2 : l1;
276 
277  for (i = 0; i < limit; i++)
278  {
279  if (s1[i] != s2[i])
280  return i;
281  }
282  return limit;
283 }
Here is the caller graph for this function:

◆ get_longest_prefix()

static struct RegexCombineCtx* get_longest_prefix ( struct RegexCombineCtx ctx,
const char *  regex 
)
static

Return the child context with the longest prefix match with the regex.

Usually only one child will match, search all just in case.

Parameters
ctxContext whose children to search.
regexString to match.
Returns
Child with the longest prefix, NULL if no child matches.

Definition at line 296 of file regex_test_lib.c.

References RegexCombineCtx::children, get_prefix_length(), GNUNET_break, l, p, RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by regex_add().

297 {
298  struct RegexCombineCtx *p;
299  struct RegexCombineCtx *best;
300  unsigned int i;
301  unsigned int l;
302  unsigned int best_l;
303 
304  best_l = 0;
305  best = NULL;
306 
307  for (i = 0; i < ctx->size; i++)
308  {
309  p = ctx->children[i];
310  if (NULL == p)
311  continue;
312 
313  l = get_prefix_length (p->s, regex);
314  if (l > best_l)
315  {
316  GNUNET_break (0 == best_l);
317  best = p;
318  best_l = l;
319  }
320  }
321  return best;
322 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
unsigned int size
Alphabet size (how many children there are)
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct LoggingHandle * l
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static unsigned int get_prefix_length(const char *s1, const char *s2)
Get the number of matching characters on the prefix of both strings.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ regex_add_multiple()

static void regex_add_multiple ( struct RegexCombineCtx ctx,
const char *  regex,
struct RegexCombineCtx **  children 
)
static

Definition at line 325 of file regex_test_lib.c.

References c2i(), RegexCombineCtx::children, GNUNET_assert, GNUNET_memcpy, GNUNET_strdup, l, new_regex_ctx(), RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by regex_add(), and regex_split().

328 {
329  char tmp[2];
330  long unsigned int i;
331  size_t l;
332  struct RegexCombineCtx *newctx;
333  unsigned int count;
334 
335  if ('(' != regex[0])
336  {
337  GNUNET_assert (0);
338  }
339 
340  /* Does the regex cover *all* possible children? Then don't add any,
341  * as it will be covered by the post-regex "(a-z)*"
342  */
343  l = strlen (regex);
344  count = 0;
345  for (i = 1UL; i < l; i++)
346  {
347  if (regex[i] != '|' && regex[i] != ')')
348  {
349  count++;
350  }
351  }
352  if (count == ctx->size)
353  {
354  return;
355  }
356 
357  /* Add every component as a child node */
358  tmp[1] = '\0';
359  for (i = 1UL; i < l; i++)
360  {
361  if (regex[i] != '|' && regex[i] != ')')
362  {
363  tmp[0] = regex[i];
364  newctx = new_regex_ctx(ctx->size);
365  newctx->s = GNUNET_strdup (tmp);
366  if (children != NULL)
367  GNUNET_memcpy (newctx->children,
368  children,
369  sizeof (*children) * ctx->size);
370  ctx->children[c2i(tmp[0], ctx->size)] = newctx;
371  }
372  }
373 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
unsigned int size
Alphabet size (how many children there are)
static struct LoggingHandle * l
#define GNUNET_memcpy(dst, src, n)
static int c2i(char c, int size)
Char 2 int.
static struct RegexCombineCtx * new_regex_ctx(unsigned int alphabet_size)
Create and initialize a new RegexCombineCtx.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ regex_split()

static void regex_split ( struct RegexCombineCtx ctx,
unsigned int  len,
unsigned int  prefix_l 
)
static

Add a single regex to a context, splitting the exisiting state.

We only had a partial match, split existing state, truncate the current node so it only contains the prefix, add suffix(es) as children.

Parameters
ctxContext to split.
lenLenght of ctx->s
prefix_lLenght of common prefix of the new regex and ctx->s

Definition at line 386 of file regex_test_lib.c.

References c2i(), RegexCombineCtx::children, GNUNET_free, GNUNET_malloc, GNUNET_strlcpy(), move_children(), new_regex_ctx(), regex_add_multiple(), RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by regex_add().

389 {
390  struct RegexCombineCtx *newctx;
391  unsigned int idx;
392  char *suffix;
393 
394  suffix = GNUNET_malloc (len - prefix_l + 1);
395  /*
396  * We can use GNUNET_strlcpy because ctx->s is null-terminated
397  */
398  GNUNET_strlcpy (suffix, &ctx->s[prefix_l], len - prefix_l + 1);
399 
400  /* Suffix saved, truncate current node so it only contains the prefix,
401  * copy any children nodes to put as grandchildren and initialize new empty
402  * children array.
403  */
404  ctx->s[prefix_l] = '\0';
405 
406  /* If the suffix is an OR expression, add multiple children */
407  if ('(' == suffix[0])
408  {
409  struct RegexCombineCtx **tmp;
410 
411  tmp = ctx->children;
412  ctx->children = GNUNET_malloc (sizeof(*tmp) * ctx->size);
413  regex_add_multiple (ctx, suffix, tmp);
414  GNUNET_free (suffix);
415  GNUNET_free (tmp);
416  return;
417  }
418 
419  /* The suffix is a normal string, add as one node */
420  newctx = new_regex_ctx (ctx->size);
421  newctx->s = suffix;
422  move_children (newctx, ctx);
423  idx = c2i(suffix[0], ctx->size);
424  ctx->children[idx] = newctx;
425 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
Struct to hold the tree formed by prefix-combining the regexes.
static void regex_add_multiple(struct RegexCombineCtx *ctx, const char *regex, struct RegexCombineCtx **children)
unsigned int size
Alphabet size (how many children there are)
static void move_children(struct RegexCombineCtx *dst, const struct RegexCombineCtx *src)
static int c2i(char c, int size)
Char 2 int.
static struct RegexCombineCtx * new_regex_ctx(unsigned int alphabet_size)
Create and initialize a new RegexCombineCtx.
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ regex_ctx_destroy()

static void regex_ctx_destroy ( struct RegexCombineCtx ctx)
static

Free all resources used by the context node and all its children.

Parameters
ctxContext to free.

Definition at line 504 of file regex_test_lib.c.

References RegexCombineCtx::children, GNUNET_free, GNUNET_free_non_null, RegexCombineCtx::s, and RegexCombineCtx::size.

Referenced by REGEX_TEST_combine().

505 {
506  unsigned int i;
507 
508  if (NULL == ctx)
509  return;
510 
511  for (i = 0; i < ctx->size; i++)
512  {
513  regex_ctx_destroy (ctx->children[i]);
514  }
515  GNUNET_free_non_null (ctx->s); /* 's' on root node is null */
516  GNUNET_free (ctx->children);
517  GNUNET_free (ctx);
518 }
char * s
Token.
struct RegexCombineCtx ** children
Child nodes with same prefix and token.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
unsigned int size
Alphabet size (how many children there are)
static void regex_ctx_destroy(struct RegexCombineCtx *ctx)
Free all resources used by the context node and all its children.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ REGEX_TEST_combine()

char* REGEX_TEST_combine ( char *const  regexes[],
unsigned int  alphabet_size 
)

Combine an array of regexes into a single prefix-shared regex.

Returns a prefix-combine regex that matches the same strings as any of the original regexes.

WARNING: only useful for reading specific regexes for specific applications, namely the gnunet-regex-profiler / gnunet-regex-daemon. This function DOES NOT support arbitrary regex combining.

Parameters
regexesA NULL-terminated array of regexes.
alphabet_sizeSize of the alphabet the regex uses.
Returns
A string with a single regex that matches any of the original regexes

Definition at line 536 of file regex_test_lib.c.

References ctx, debugctx(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, new_regex_ctx(), regex_add(), regex_combine(), and regex_ctx_destroy().

Referenced by main(), and run().

537 {
538  unsigned int i;
539  char *combined;
540  const char *current;
541  struct RegexCombineCtx *ctx;
542 
543  ctx = new_regex_ctx (alphabet_size);
544  for (i = 0; regexes[i]; i++)
545  {
546  current = regexes[i];
547  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Regex %u: %s\n", i, current);
548  regex_add (ctx, current);
549  debugctx (ctx, 0);
550  }
551  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\nCombining...\n");
552  debugctx (ctx, 0);
553 
554  combined = regex_combine (ctx);
555 
556  regex_ctx_destroy (ctx);
557 
558  return combined;
559 }
Struct to hold the tree formed by prefix-combining the regexes.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static void debugctx(struct RegexCombineCtx *ctx, int level)
Printf the combined regex ctx.
static void regex_ctx_destroy(struct RegexCombineCtx *ctx)
Free all resources used by the context node and all its children.
static char * regex_combine(struct RegexCombineCtx *ctx)
Extract a string from all prefix-combined regexes.
#define GNUNET_log(kind,...)
static struct RegexCombineCtx * new_regex_ctx(unsigned int alphabet_size)
Create and initialize a new RegexCombineCtx.
static void regex_add(struct RegexCombineCtx *ctx, const char *regex)
Add a single regex to a context, combining with exisiting regex by-prefix.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ REGEX_TEST_read_from_file()

char** REGEX_TEST_read_from_file ( const char *  filename)

Read a set of regexes from a file, one per line and return them in an array suitable for REGEX_TEST_combine.

The array must be free'd using REGEX_TEST_free_from_file.

Parameters
filenameName of the file containing the regexes.
Returns
A newly allocated, NULL terminated array of regexes.

Definition at line 572 of file regex_test_lib.c.

References removetrailingwhitespace::f, GNUNET_array_grow, GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_free_non_null, GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_realloc, len, and RegexCombineCtx::size.

Referenced by main(), and run().

573 {
574  struct GNUNET_DISK_FileHandle *f;
575  unsigned int nr;
576  unsigned int offset;
577  off_t size;
578  size_t len;
579  char *buffer;
580  char *regex;
581  char **regexes;
582 
586  if (NULL == f)
587  {
589  "Can't open file %s for reading\n", filename);
590  return NULL;
591  }
592  if (GNUNET_OK != GNUNET_DISK_file_handle_size (f, &size))
593  {
595  "Can't get size of file %s\n", filename);
597  return NULL;
598  }
600  "using file %s, size %llu\n",
601  filename, (unsigned long long) size);
602 
603  buffer = GNUNET_malloc (size + 1);
604  GNUNET_DISK_file_read (f, buffer, size);
606  regexes = GNUNET_malloc (sizeof (char *));
607  nr = 1;
608  offset = 0;
609  regex = NULL;
610  do
611  {
612  if (NULL == regex)
613  regex = GNUNET_malloc (size + 1);
614  len = (size_t) sscanf (&buffer[offset], "%s", regex);
615  if (0 == len)
616  break;
617  len = strlen (regex);
618  offset += len + 1;
619  if (len < 1)
620  continue;
621  regex[len] = '\0';
622  regex = GNUNET_realloc (regex, len + 1);
623  GNUNET_array_grow (regexes, nr, nr + 1);
624  GNUNET_assert (NULL == regexes[nr - 2]);
625  regexes[nr - 2] = regex;
626  regexes[nr - 1] = NULL;
627  regex = NULL;
628  } while (offset < size);
629  GNUNET_free_non_null (regex);
630  GNUNET_free (buffer);
631 
632  return regexes;
633 }
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:881
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Nobody is allowed to do anything to the file.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_realloc(ptr, size)
Wrapper around realloc.
static char * filename
static unsigned int size
Size of the "table".
Definition: peer.c:67
int GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:208
#define GNUNET_log(kind,...)
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1673
Handle used to access files (and pipes).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ REGEX_TEST_free_from_file()

void REGEX_TEST_free_from_file ( char **  regexes)

Free all memory reserved for a set of regexes created by read_from_file.

Parameters
regexesNULL-terminated array of regexes.

Definition at line 642 of file regex_test_lib.c.

References GNUNET_free.

Referenced by main(), and run().

643 {
644  unsigned int i;
645 
646  for (i = 0; regexes[i]; i++)
647  GNUNET_free (regexes[i]);
648  GNUNET_free (regexes);
649 }
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function: