#define LOG(kind,...) GNUNET_log_from (kind,"regex-bck",__VA_ARGS__)
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * @brief Block to announce a regex state.
+ */
+struct RegexBlock
+{
+
+ /**
+ * Length of the proof regex string.
+ */
+ uint16_t proof_len GNUNET_PACKED;
+
+ /**
+ * Is this state an accepting state?
+ */
+ int16_t is_accepting GNUNET_PACKED;
+
+ /**
+ * Numer of edges parting from this state.
+ */
+ uint32_t n_edges GNUNET_PACKED;
+
+ /* char proof[n_proof] */
+ /* struct RegexEdge edges[n_edges] */
+};
+
+
+/**
+ * @brief A RegexBlock contains one or more of this struct in the payload.
+ */
+struct RegexEdge
+{
+ /**
+ * Destination of this edge.
+ */
+ struct GNUNET_HashCode key;
+
+ /**
+ * Length of the token towards the new state.
+ */
+ uint32_t n_token GNUNET_PACKED;
+
+ /* char token[n_token] */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Test if this block is marked as being an accept state.
+ *
+ * @param block block to test
+ * @return GNUNET_YES if the block is accepting, GNUNET_NO if not
+ */
+int
+GNUNET_BLOCK_is_accepting (const struct RegexBlock *block)
+{
+ return ntohs (block->is_accepting);
+}
+
+
+/**
+ * Check if the given 'proof' matches the given 'key'.
+ *
+ * @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.
+ */
+int
+REGEX_BLOCK_check_proof (const char *proof,
+ size_t proof_len,
+ const struct GNUNET_HashCode *key)
+{
+ 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;
+}
+
+
/**
* Struct to keep track of the xquery while iterating all the edges in a block.
*/
-struct regex_block_xquery_ctx
+struct CheckEdgeContext
{
/**
* Xquery: string we are looking for.
*/
int found;
- /**
- * Key of the block we are iterating (for debug purposes).
- */
- char *key;
};
size_t len,
const struct GNUNET_HashCode *key)
{
- struct regex_block_xquery_ctx *ctx = cls;
+ struct CheckEdgeContext *ctx = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"edge %.*s [%u]: %s->%s\n",
- (int) len, token, len, ctx->key, GNUNET_h2s(key));
+ (int) len, token, len, GNUNET_h2s(key));
if (NULL == ctx->xquery)
return GNUNET_YES;
if (strlen (ctx->xquery) < len)
*
* @param block The start of the block.
* @param size The size of the block.
+ * @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.
*
int
REGEX_BLOCK_check (const struct RegexBlock *block,
size_t size,
+ const struct GNUNET_HashCode *query,
const char *xquery)
{
+ struct CheckEdgeContext ctx;
int res;
- struct regex_block_xquery_ctx ctx;
+ uint16_t len;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Checking block with xquery `%s'\n",
NULL != xquery ? xquery : "NULL");
- if ( (GNUNET_YES == ntohl (block->accepting)) &&
+ len = ntohs (block->proof_len);
+ if (size < sizeof (struct RegexBlock) + len)
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+ if (GNUNET_OK != REGEX_BLOCK_check_proof ((const char *) &block[1], len, query))
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+ if ( (GNUNET_YES == ntohs (block->is_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 = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
- GNUNET_free (ctx.key);
if (GNUNET_SYSERR == res)
return GNUNET_SYSERR;
if (NULL == xquery)
}
+/**
+ * Obtain the key that a particular block is to be stored under.
+ *
+ * @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
+ */
+int
+REGEX_BLOCK_get_key (const struct RegexBlock *block,
+ size_t block_len,
+ struct GNUNET_HashCode *key)
+{
+ uint16_t len;
+
+ len = ntohs (block->proof_len);
+ if (block_len < sizeof (struct RegexBlock) + len)
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+ GNUNET_CRYPTO_hash (&block[1], len, key);
+ return GNUNET_OK;
+}
+
+
/**
* Iterate over all edges of a block of a regex state.
*
*/
int
REGEX_BLOCK_iterate (const struct RegexBlock *block,
- size_t size,
- REGEX_INTERNAL_EgdeIterator iterator,
- void *iter_cls)
+ size_t size,
+ REGEX_INTERNAL_EgdeIterator iterator,
+ void *iter_cls)
{
struct RegexEdge *edge;
unsigned int n;
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
- n = ntohl (block->n_proof);
+ n = ntohs (block->proof_len);
offset += n;
if (offset >= size) /* Is it safe to access the regex proof? */
{
n = ntohl (block->n_edges);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Start iterating block of size %u, proof %u, off %u edges %u\n",
- size, ntohl (block->n_proof), offset, n);
+ size, ntohs (block->proof_len), offset, n);
/* aux always points at the end of the previous block */
for (i = 0; i < n; i++)
{
* @param proof proof string for the block
* @param num_edges number of edges in the block
* @param edges the edges of the block
- * @return the regex block
+ * @param accepting is this an accepting state
+ * @param rsize set to the size of the returned block (OUT-only)
+ * @return the regex block, NULL on error
*/
struct RegexBlock *
-REGEX_BLOCK_create (const struct GNUNET_HashCode *key,
- const char *proof,
- unsigned int num_edges,
- const struct REGEX_BLOCK_Edge *edges,
- int accepting,
- size_t *rsize)
+REGEX_BLOCK_create (const char *proof,
+ unsigned int num_edges,
+ const struct REGEX_BLOCK_Edge *edges,
+ int accepting,
+ size_t *rsize)
{
struct RegexBlock *block;
struct RegexEdge *block_edge;
unsigned int offset;
char *aux;
- len = strlen(proof);
+ len = strlen (proof);
+ if (len > UINT16_MAX)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
size = sizeof (struct RegexBlock) + len;
block = GNUNET_malloc (size);
- block->key = *key;
- block->n_proof = htonl (len);
+ block->proof_len = htons (len);
block->n_edges = htonl (num_edges);
- block->accepting = htonl (accepting);
+ block->is_accepting = htons (accepting);
/* Store the proof at the end of the block. */
aux = (char *) &block[1];
projects / oweals / gnunet.git / blobdiff