* Has any edge matched the xquery so far? (GNUNET_OK / GNUNET_NO)
*/
int found;
+
+ /**
+ * Key of the block we are iterating (for debug purposes).
+ */
+ char *key;
};
{
struct regex_block_xquery_ctx *ctx = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " edge %.*s [%u]\n",
- (int) len, token, len);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " edge %.*s [%u]: %s->%s\n",
+ (int) len, token, len, ctx->key, GNUNET_h2s(key));
+
+ if (NULL == ctx->xquery)
+ return GNUNET_YES;
if (strlen (ctx->xquery) < len)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " too long!\n");
}
-/**
- * Check if the regex block is well formed, including all edges
- *
- * @param block The start of the block.
- * @param size The size of the block.
- * @param xquery String describing the edge we are looking for.
- *
- * @return GNUNET_OK in case it's fine.
- * GNUNET_NO in case the xquery is not found.
- * GNUNET_SYSERR if the block is invalid.
- */
int
GNUNET_REGEX_block_check (const struct RegexBlock *block,
- size_t size,
- const char *xquery)
+ size_t size,
+ const char *xquery)
{
int res;
struct regex_block_xquery_ctx ctx;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "* Checking block with xquery \"%s\"\n",
- xquery);
- if ( (GNUNET_YES == ntohl(block->accepting)) && ('\0' == xquery[0]) )
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "* Checking block with xquery \"%s\"\n",
+ NULL != xquery ? xquery : "NULL");
+ if ( (GNUNET_YES == ntohl (block->accepting)) &&
+ ( (NULL == xquery) || ('\0' == xquery[0]) )
+ )
return GNUNET_OK;
ctx.xquery = xquery;
ctx.found = GNUNET_NO;
+ ctx.key = GNUNET_strdup (GNUNET_h2s (&block->key));
res = GNUNET_REGEX_block_iterate (block, size, &check_edge, &ctx);
+ GNUNET_free (ctx.key);
if (GNUNET_SYSERR == res)
return GNUNET_SYSERR;
+ if (NULL == xquery)
+ return GNUNET_YES;
return ctx.found;
}
-/**
- * Iterate over all edges of a block of a regex state.
- *
- * @param block Block to iterate over.
- * @param size Size of block.
- * @param iterator Function to call on each edge in the block.
- * @param iter_cls Closure for the iterator.
- *
- * @return How many bytes of block have been processed
- */
int
GNUNET_REGEX_block_iterate (const struct RegexBlock *block,
- size_t size,
- GNUNET_REGEX_EgdeIterator iterator,
- void *iter_cls)
+ size_t size,
+ GNUNET_REGEX_EgdeIterator iterator,
+ void *iter_cls)
{
struct RegexEdge *edge;
unsigned int n;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"* Start iterating block of size %u, off %u\n",
size, offset);
- if (offset > size) // Is it safe to access the regex block?
+ if (offset >= size) /* Is it safe to access the regex block? */
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"* Block is smaller than struct RegexBlock, END\n");
offset += n;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"* Proof length: %u, off %u\n", n, offset);
- if (offset > size) // Is it safe to access the regex proof?
+ if (offset >= size) /* Is it safe to access the regex proof? */
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"* Block is smaller than Block + proof, END\n");
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- aux = (char *) &block[1]; // Skip regex block
- aux = &aux[n]; // Skip regex proof
+ aux = (char *) &block[1]; /* Skip regex block */
+ aux = &aux[n]; /* Skip regex proof */
n = ntohl (block->n_edges);
LOG (GNUNET_ERROR_TYPE_DEBUG, "* Edges: %u\n", n);
- for (i = 0; i < n; i++) // aux always points at the end of the previous block
+ /* aux always points at the end of the previous block */
+ for (i = 0; i < n; i++)
{
offset += sizeof (struct RegexEdge);
LOG (GNUNET_ERROR_TYPE_DEBUG, "* Edge %u, off %u\n", i, offset);
- if (offset > size) // Is it safe to access the next edge block?
+ if (offset >= size) /* Is it safe to access the next edge block? */
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"* Size not enough for RegexEdge, END\n");
n_token = ntohl (edge->n_token);
offset += n_token;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "* Token lenght %u, off %u\n", n_token, offset);
- if (offset > size) // Is it safe to access the edge token?
+ "* Token length %u, off %u\n", n_token, offset);
+ if (offset > size) /* Is it safe to access the edge token? */
{
LOG (GNUNET_ERROR_TYPE_WARNING,
"* Size not enough for edge token, END\n");
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- aux = (char *) &edge[1]; // Skip edge block
+ aux = (char *) &edge[1]; /* Skip edge block */
if (NULL != iterator)
if (GNUNET_NO == iterator (iter_cls, aux, n_token, &edge->key))
return GNUNET_OK;
- aux = &aux[n_token]; // Skip edge token
+ aux = &aux[n_token]; /* Skip edge token */
}
- // The total size should be exactly the size of (regex + all edges) blocks
- // If size == -1, block is from cache and therefore previously checked and
- // assumed correct.
+ /* The total size should be exactly the size of (regex + all edges) blocks
+ * If size == -1, block is from cache and therefore previously checked and
+ * assumed correct. */
if (offset == size || SIZE_MAX == size)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "* Block processed, END OK\n");
projects / oweals / gnunet.git / blobdiff