regex_block_lib.h File Reference

common function to manipulate blocks stored by regex in the DHT More...

#include "platform.h"
#include "block_regex.h"

Include dependency graph for regex_block_lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	REGEX_BLOCK_Edge
	Edge representation. More...

Typedefs
typedef int(*	REGEX_INTERNAL_EgdeIterator) (void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)
	Iterator over edges in a block. More...

Functions
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...
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_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...
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	GNUNET_BLOCK_is_accepting (const struct RegexBlock *block, size_t block_len)
	Test if this block is marked as being an accept 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

common function to manipulate blocks stored by regex in the DHT

Author

Bartlomiej Polot

Definition in file regex_block_lib.h.

Typedef Documentation

REGEX_INTERNAL_EgdeIterator

typedef int(* REGEX_INTERNAL_EgdeIterator) (void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)

Iterator over edges in a block.

Parameters

cls	Closure.
token	Token that follows to next state.
len	Length of token.
key	Hash of next state.

Returns

GNUNET_YES if should keep iterating, GNUNET_NO otherwise.

Definition at line 111 of file regex_block_lib.h.

Function Documentation

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:

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_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_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:

GNUNET_BLOCK_is_accepting()

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_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: