/*
This file is part of GNUnet.
- (C) 2012,2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2012,2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @author Bartlomiej Polot
*
* @param block block to test
* @param size number of bytes in block
- * @return GNUNET_YES if the block is accepting, GNUNET_NO if not
- */
+ * @return #GNUNET_YES if the block is accepting, #GNUNET_NO if not
+ */
int
GNUNET_BLOCK_is_accepting (const struct RegexBlock *block,
size_t size)
* @param proof partial regex of a state
* @param proof_len number of bytes in 'proof'
* @param key hash of a state.
- *
- * @return GNUNET_OK if the proof is valid for the given key.
+ * @return #GNUNET_OK if the proof is valid for the given key.
*/
int
REGEX_BLOCK_check_proof (const char *proof,
* @param token Token that follows to next state.
* @param len Lenght of token.
* @param key Hash of next state.
- *
- * @return GNUNET_YES, to keep iterating
+ *
+ * @return #GNUNET_YES, to keep iterating
*/
static int
check_edge (void *cls,
{
struct CheckEdgeContext *ctx = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "edge %.*s [%u]: %s->%s\n",
- (int) len, token, len, GNUNET_h2s(key));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "edge %.*s [%u]: %sn",
+ (int) len,
+ token,
+ (unsigned int) len,
+ GNUNET_h2s (key));
if (NULL == ctx->xquery)
return GNUNET_YES;
if (strlen (ctx->xquery) < len)
* @param query the query for the block
* @param xquery String describing the edge we are looking for.
* Can be NULL in case this is a put block.
- *
- * @return 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.
+ * @return #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.
*/
int
REGEX_BLOCK_check (const struct RegexBlock *block,
struct CheckEdgeContext ctx;
int res;
- if (GNUNET_OK !=
+ 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 (0 != memcmp (&key,
- query,
- sizeof (struct GNUNET_HashCode)))
+ if (NULL != query &&
+ 0 != memcmp (&key,
+ query,
+ sizeof (struct GNUNET_HashCode)))
{
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);
return GNUNET_SYSERR;
if (NULL == xquery)
return GNUNET_YES;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Result %d\n", ctx.found);
return ctx.found;
}
*
* @param block block to get the key from
* @param block_len number of bytes in block
- * @param query where to store the key
- * @return GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
+ * @param key where to store the key
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the block is malformed
*/
int
REGEX_BLOCK_get_key (const struct RegexBlock *block,
- size_t block_len,
- struct GNUNET_HashCode *key)
+ size_t block_len,
+ struct GNUNET_HashCode *key)
{
uint16_t len;
const struct GNUNET_HashCode *destinations;
uint16_t num_edges;
size_t total;
- if (block_len < sizeof (struct RegexBlock))
+ 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;
+ total = sizeof (struct RegexBlock) + num_destinations * sizeof (struct GNUNET_HashCode) + num_edges * sizeof (struct EdgeInfo) + len;
if (block_len < total)
{
GNUNET_break_op (0);
* Iterate over all edges of a block of a regex state.
*
* @param block Block to iterate over.
- * @param size Size of block.
+ * @param size Size of @a block.
* @param iterator Function to call on each edge in the block.
- * @param iter_cls Closure for the iterator.
- *
- * @return GNUNET_SYSERR if an error has been encountered.
- * GNUNET_OK if no error has been encountered.
+ * @param iter_cls Closure for the @a iterator.
+ * @return #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.
+ * #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.
unsigned int n;
size_t off;
- if (size < sizeof (struct RegexBlock))
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Block iterate\n");
+ if (size < sizeof (struct RegexBlock))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
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)
+ 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)
+ total += ntohs (edges[n].token_length);
+ if (size != total)
{
fprintf (stderr, "Expected %u, got %u\n",
(unsigned int) size,
for (n=0;n<num_edges;n++)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Edge %u, off %u tokenlen %u\n", n, off,
- ntohs (edges[n].token_length));
+ "Edge %u/%u, off %u tokenlen %u (%.*s)\n",
+ n+1, num_edges, off,
+ ntohs (edges[n].token_length), ntohs (edges[n].token_length),
+ &aux[off]);
if (NULL != iterator)
- if (GNUNET_NO == iterator (iter_cls,
- &aux[off],
+ if (GNUNET_NO == iterator (iter_cls,
+ &aux[off],
ntohs (edges[n].token_length),
&destinations[ntohs (edges[n].destination_index)]))
return GNUNET_OK;
char *aux;
len = strlen (proof);
- if (len > UINT16_MAX)
+ if (len > UINT16_MAX)
{
GNUNET_break (0);
return NULL;
for (i=0;i<num_edges;i++)
{
slen = strlen (edges[i].label);
- if (len > UINT16_MAX)
+ if (slen > UINT16_MAX)
{
GNUNET_break (0);
return NULL;
edgeinfos = (struct EdgeInfo *) &dests[unique_destinations];
aux = (char *) &edgeinfos[num_edges];
off = len;
- memcpy (aux, proof, len);
+ memcpy (aux, proof, len);
for (i=0;i<num_edges;i++)
{
slen = strlen (edges[i].label);