regex_block_lib.c File Reference

functions for manipulating non-accept blocks stored for regex in the DHT More...

#include "platform.h"
#include "regex_block_lib.h"
#include "gnunet_constants.h"

Include dependency graph for regex_block_lib.c:

Go to the source code of this file.

Data Structures
struct	EdgeInfo
	Information for each edge. More...
struct	RegexBlock
	Block to announce a regex state. More...
struct	CheckEdgeContext
	Struct to keep track of the xquery while iterating all the edges in a block. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "regex-bck", __VA_ARGS__)

Functions
GNUNET_NETWORK_STRUCT_END int	GNUNET_BLOCK_is_accepting (const struct RegexBlock *block, size_t size)
	Test if this block is marked as being an accept state. More...
int	REGEX_BLOCK_check_proof (const char *proof, size_t proof_len, const struct GNUNET_HashCode *key)
	Check if the given 'proof' matches the given 'key'. More...
static int	check_edge (void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)
	Iterator over all edges in a block, checking for a presence of a given query. More...
int	REGEX_BLOCK_check (const struct RegexBlock *block, size_t size, const struct GNUNET_HashCode *query, const char *xquery)
	Check if the regex block is well formed, including all edges. More...
int	REGEX_BLOCK_get_key (const struct RegexBlock *block, size_t block_len, struct GNUNET_HashCode *key)
	Obtain the key that a particular block is to be stored under. More...
int	REGEX_BLOCK_iterate (const struct RegexBlock *block, size_t size, REGEX_INTERNAL_EgdeIterator iterator, void *iter_cls)
	Iterate over all edges of a block of a regex state. More...
struct RegexBlock *	REGEX_BLOCK_create (const char *proof, unsigned int num_edges, const struct REGEX_BLOCK_Edge *edges, int accepting, size_t *rsize)
	Construct a regex block to be stored in the DHT. More...

Detailed Description

functions for manipulating non-accept blocks stored for regex in the DHT

Author

Bartlomiej Polot

Definition in file regex_block_lib.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "regex-bck", __VA_ARGS__)

Definition at line 30 of file regex_block_lib.c.

Function Documentation

GNUNET_BLOCK_is_accepting()

GNUNET_NETWORK_STRUCT_END int GNUNET_BLOCK_is_accepting	(	const struct RegexBlock *	block,
		size_t	size
	)

Test if this block is marked as being an accept state.

Parameters

block	block to test
size	number of bytes in block

Returns

GNUNET_YES if the block is accepting, GNUNET_NO if not

Definition at line 101 of file regex_block_lib.c.

{
  if (size < sizeof(struct RegexBlock))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return ntohs (block->is_accepting);
}

References GNUNET_break_op, GNUNET_SYSERR, RegexBlock::is_accepting, and size.

Referenced by dht_get_string_handler(), and regex_result_iterator().

Here is the caller graph for this function:

REGEX_BLOCK_check_proof()

int REGEX_BLOCK_check_proof	(	const char *	proof,
		size_t	proof_len,
		const struct GNUNET_HashCode *	key
	)

Check if the given 'proof' matches the given 'key'.

Parameters

proof	partial regex of a state
proof_len	number of bytes in proof
key	hash of a state.

Returns

GNUNET_OK if the proof is valid for the given key.

Definition at line 114 of file regex_block_lib.c.

{
  struct GNUNET_HashCode key_check;
 
  if ((NULL == proof) || (NULL == key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Proof check failed, was NULL.\n");
    return GNUNET_NO;
  }
  GNUNET_CRYPTO_hash (proof, proof_len, &key_check);
  return (0 ==
          GNUNET_CRYPTO_hash_cmp (key, &key_check)) ? GNUNET_OK : GNUNET_NO;
}

References GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_OK, key, and proof.

Here is the call graph for this function:

check_edge()

static int check_edge ( void *  cls, const char *  token, size_t  len, const struct GNUNET_HashCode *  key  )

static

Iterator over all edges in a block, checking for a presence of a given query.

Parameters

cls	Closure, (xquery context).
token	Token that follows to next state.
len	Length of token.
key	Hash of next state.

Returns

GNUNET_YES, to keep iterating

Definition at line 159 of file regex_block_lib.c.

{
  struct CheckEdgeContext *ctx = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "edge %.*s [%u]: %s\n",
              (int) len,
              token,
              (unsigned int) len,
              GNUNET_h2s (key));
  if (NULL == ctx->xquery)
    return GNUNET_YES;
  if (strlen (ctx->xquery) < len)
    return GNUNET_YES; /* too long */
  if (0 == strncmp (ctx->xquery, token, len))
    ctx->found = GNUNET_OK;
  return GNUNET_YES; /* keep checking for malformed data! */
}

References ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_YES, and key.

Referenced by REGEX_BLOCK_check().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_BLOCK_check()

int REGEX_BLOCK_check	(	const struct RegexBlock *	block,
		size_t	size,
		const struct GNUNET_HashCode *	query,
		const char *	xquery
	)

Check if the regex block is well formed, including all edges.

Parameters

block	The start of the block.
size	The size of the block.
query	the query for the block
xquery	String describing the edge we are looking for. Can be NULL in case this is a put block.

Returns

GNUNET_OK in case it's fine. GNUNET_NO in case the xquery exists and is not found (IRRELEVANT). GNUNET_SYSERR if the block is invalid.

Definition at line 183 of file regex_block_lib.c.

{
  struct GNUNET_HashCode key;
  struct CheckEdgeContext ctx;
  int res;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Block check\n");
  if (GNUNET_OK !=
      REGEX_BLOCK_get_key (block, size,
                           &key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((NULL != query) &&
      (0 != GNUNET_memcmp (&key,
                           query)) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((GNUNET_YES == ntohs (block->is_accepting)) &&
      ((NULL == xquery) || ('\0' == xquery[0])))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "  out! Is accepting: %u, xquery %p\n",
         ntohs (block->is_accepting),
         xquery);
    return GNUNET_OK;
  }
  ctx.xquery = xquery;
  ctx.found = GNUNET_NO;
  res = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
  if (GNUNET_SYSERR == res)
    return GNUNET_SYSERR;
  if (NULL == xquery)
    return GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Result %d\n", ctx.found);
  return ctx.found;
}

References check_edge(), ctx, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, RegexBlock::is_accepting, key, LOG, REGEX_BLOCK_get_key(), REGEX_BLOCK_iterate(), res, size, and CheckEdgeContext::xquery.

Referenced by block_plugin_regex_check_block(), and block_plugin_regex_check_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_BLOCK_get_key()

int REGEX_BLOCK_get_key	(	const struct RegexBlock *	block,
		size_t	block_len,
		struct GNUNET_HashCode *	key
	)

Obtain the key that a particular block is to be stored under.

Parameters

block	block to get the key from
block_len	number of bytes in block
key	where to store the key

Returns

GNUNET_OK on success, GNUNET_SYSERR if the block is malformed

Definition at line 230 of file regex_block_lib.c.

{
  uint16_t len;
  const struct GNUNET_HashCode *destinations;
  const struct EdgeInfo *edges;
  uint16_t num_destinations;
  uint16_t num_edges;
  size_t total;
 
  if (block_len < sizeof(struct RegexBlock))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_destinations = ntohs (block->num_destinations);
  num_edges = ntohs (block->num_edges);
  len = ntohs (block->proof_len);
  destinations = (const struct GNUNET_HashCode *) &block[1];
  edges = (const struct EdgeInfo *) &destinations[num_destinations];
  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
                                                                GNUNET_HashCode)
          + num_edges * sizeof(struct EdgeInfo) + len;
  if (block_len < total)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_CRYPTO_hash (&edges[num_edges], len, key);
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_SYSERR, key, RegexBlock::num_destinations, RegexBlock::num_edges, and RegexBlock::proof_len.

Referenced by block_plugin_regex_get_key(), and REGEX_BLOCK_check().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_BLOCK_iterate()

int REGEX_BLOCK_iterate	(	const struct RegexBlock *	block,
		size_t	size,
		REGEX_INTERNAL_EgdeIterator	iterator,
		void *	iter_cls
	)

Iterate over all edges of a block of a regex state.

Parameters

block	Block to iterate over.
size	Size of block.
iterator	Function to call on each edge in the block.
iter_cls	Closure for the iterator.

Returns

GNUNET_SYSERR if an error has been encountered. GNUNET_OK if no error has been encountered. Note that if the iterator stops the iteration by returning GNUNET_NO, the block will no longer be checked for further errors. The return value will be GNUNET_OK meaning that no errors were found until the edge last notified to the iterator, but there might be errors in further edges.

Definition at line 265 of file regex_block_lib.c.

{
  uint16_t len;
  const struct GNUNET_HashCode *destinations;
  const struct EdgeInfo *edges;
  const char *aux;
  uint16_t num_destinations;
  uint16_t num_edges;
  size_t total;
  unsigned int n;
  size_t off;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Block iterate\n");
  if (size < sizeof(struct RegexBlock))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_destinations = ntohs (block->num_destinations);
  num_edges = ntohs (block->num_edges);
  len = ntohs (block->proof_len);
  destinations = (const struct GNUNET_HashCode *) &block[1];
  edges = (const struct EdgeInfo *) &destinations[num_destinations];
  aux = (const char *) &edges[num_edges];
  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
                                                                GNUNET_HashCode)
          + num_edges * sizeof(struct EdgeInfo) + len;
  if (size < total)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  for (n = 0; n < num_edges; n++)
    total += ntohs (edges[n].token_length);
  if (size != total)
  {
    fprintf (stderr, "Expected %u, got %u\n",
             (unsigned int) size,
             (unsigned int) total);
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  off = len;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Start iterating block of size %lu, proof %u, off %lu edges %u\n",
       (unsigned long) size, len, (unsigned long) off, n);
  /* &aux[off] always points to our token */
  for (n = 0; n < num_edges; n++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Edge %u/%u, off %lu tokenlen %u (%.*s)\n",
         n + 1, num_edges, (unsigned long) off,
         ntohs (edges[n].token_length), ntohs (edges[n].token_length),
         &aux[off]);
    if (NULL != iterator)
      if (GNUNET_NO == iterator (iter_cls,
                                 &aux[off],
                                 ntohs (edges[n].token_length),
                                 &destinations[ntohs (
                                                 edges[n].destination_index)]))
        return GNUNET_OK;
    off += ntohs (edges[n].token_length);
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, LOG, RegexBlock::num_destinations, RegexBlock::num_edges, RegexBlock::proof_len, and size.

Referenced by REGEX_BLOCK_check(), and regex_next_edge().

Here is the caller graph for this function:

REGEX_BLOCK_create()

struct RegexBlock * REGEX_BLOCK_create	(	const char *	proof,
		unsigned int	num_edges,
		const struct REGEX_BLOCK_Edge *	edges,
		int	accepting,
		size_t *	rsize
	)

Construct a regex block to be stored in the DHT.

Parameters

proof	proof string for the block
num_edges	number of edges in the block
edges	the edges of the block
accepting	is this an accepting state
rsize	set to the size of the returned block (OUT-only)

Returns

the regex block, NULL on error

Definition at line 346 of file regex_block_lib.c.

{
  struct RegexBlock *block;
  struct GNUNET_HashCode destinations[1024]; /* 1024 = 64k/64 bytes/key == absolute MAX */
  uint16_t destination_indices[num_edges];
  struct GNUNET_HashCode *dests;
  struct EdgeInfo *edgeinfos;
  size_t off;
  size_t len;
  size_t total;
  size_t slen;
  unsigned int unique_destinations;
  unsigned int j;
  unsigned int i;
  char *aux;
 
  len = strlen (proof);
  if (len > UINT16_MAX)
  {
    GNUNET_break (0);
    return NULL;
  }
  unique_destinations = 0;
  total = sizeof(struct RegexBlock) + len;
  for (i = 0; i < num_edges; i++)
  {
    slen = strlen (edges[i].label);
    if (slen > UINT16_MAX)
    {
      GNUNET_break (0);
      return NULL;
    }
    total += slen;
    for (j = 0; j < unique_destinations; j++)
      if (0 == memcmp (&destinations[j],
                       &edges[i].destination,
                       sizeof(struct GNUNET_HashCode)))
        break;
    if (j >= 1024)
    {
      GNUNET_break (0);
      return NULL;
    }
    destination_indices[i] = j;
    if (j == unique_destinations)
      destinations[unique_destinations++] = edges[i].destination;
  }
  total += num_edges * sizeof(struct EdgeInfo) + unique_destinations
           * sizeof(struct GNUNET_HashCode);
  if (total >= GNUNET_CONSTANTS_MAX_BLOCK_SIZE)
  {
    GNUNET_break (0);
    return NULL;
  }
  block = GNUNET_malloc (total);
  block->proof_len = htons (len);
  block->is_accepting = htons (accepting);
  block->num_edges = htons (num_edges);
  block->num_destinations = htons (unique_destinations);
  dests = (struct GNUNET_HashCode *) &block[1];
  GNUNET_memcpy (dests, destinations, sizeof(struct GNUNET_HashCode)
                 * unique_destinations);
  edgeinfos = (struct EdgeInfo *) &dests[unique_destinations];
  aux = (char *) &edgeinfos[num_edges];
  off = len;
  GNUNET_memcpy (aux, proof, len);
  for (i = 0; i < num_edges; i++)
  {
    slen = strlen (edges[i].label);
    edgeinfos[i].token_length = htons ((uint16_t) slen);
    edgeinfos[i].destination_index = htons (destination_indices[i]);
    GNUNET_memcpy (&aux[off],
                   edges[i].label,
                   slen);
    off += slen;
  }
  *rsize = total;
  return block;
}

References REGEX_BLOCK_Edge::destination, EdgeInfo::destination_index, GNUNET_break, GNUNET_CONSTANTS_MAX_BLOCK_SIZE, GNUNET_malloc, GNUNET_memcpy, RegexBlock::is_accepting, RegexBlock::num_destinations, RegexBlock::num_edges, proof, RegexBlock::proof_len, and EdgeInfo::token_length.

Referenced by regex_iterator().

Here is the caller graph for this function: