Diff: plugin_block_gns.c - plugin_block

	plugin_block_gns.c	plugin_block_gns.c

	skipping to change at line 65	skipping to change at line 65
	* @return characterization of result	* @return characterization of result
	*/	*/
	static enum GNUNET_BLOCK_EvaluationResult	static enum GNUNET_BLOCK_EvaluationResult
	block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,	block_plugin_gns_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
	const GNUNET_HashCode * query,	const GNUNET_HashCode * query,
	struct GNUNET_CONTAINER_BloomFilter **bf,	struct GNUNET_CONTAINER_BloomFilter **bf,
	int32_t bf_mutator, const void *xquery,	int32_t bf_mutator, const void *xquery,
	size_t xquery_size, const void *reply_block,	size_t xquery_size, const void *reply_block,
	size_t reply_block_size)	size_t reply_block_size)
	{	{

	if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
	return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
	if (reply_block_size == 0)
	return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;

	char* name;	char* name;

	GNUNET_HashCode pkey_hash;	GNUNET_HashCode pkey_hash_double;
	GNUNET_HashCode query_key;	GNUNET_HashCode query_key;

	GNUNET_HashCode name_hash;	GNUNET_HashCode name_hash_double;
	GNUNET_HashCode mhash;	GNUNET_HashCode mhash;
	GNUNET_HashCode chash;	GNUNET_HashCode chash;

		struct GNUNET_CRYPTO_ShortHashCode pkey_hash;
		struct GNUNET_CRYPTO_ShortHashCode name_hash;
	struct GNSNameRecordBlock *nrb;	struct GNSNameRecordBlock *nrb;

	struct GNSRecordBlock *rb;
	uint32_t rd_count;	uint32_t rd_count;

		char* rd_data = NULL;
		int rd_len;
		uint32_t record_xquery;
		unsigned int record_match;

		//GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "RB SIZE %d\n", reply_block_size);

		if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
		return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
		if (reply_block == NULL)
		{
		/**
		* check if request is valid
		* FIXME we could check for the record types here
		**/
		if (xquery_size < sizeof(uint32_t))
		{
		GNUNET_break_op (0);
		return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
		}
		return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
		}

		/* this is a reply */

	nrb = (struct GNSNameRecordBlock *)reply_block;	nrb = (struct GNSNameRecordBlock *)reply_block;
	name = (char*)&nrb[1];	name = (char*)&nrb[1];

	GNUNET_CRYPTO_hash(&nrb->public_key,	GNUNET_CRYPTO_short_hash(&nrb->public_key,
	sizeof(nrb->public_key),	sizeof(nrb->public_key),
	&pkey_hash);	&pkey_hash);


	GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);	GNUNET_CRYPTO_short_hash(name, strlen(name), &name_hash);


	GNUNET_CRYPTO_hash_xor(&pkey_hash, &name_hash, &query_key);	GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
		GNUNET_CRYPTO_short_hash_double(&pkey_hash, &pkey_hash_double);

		GNUNET_CRYPTO_hash_xor(&pkey_hash_double, &name_hash_double, &query_key);

		struct GNUNET_CRYPTO_HashAsciiEncoded xor_exp;
		struct GNUNET_CRYPTO_HashAsciiEncoded xor_got;
		GNUNET_CRYPTO_hash_to_enc (&query_key, &xor_exp);
		GNUNET_CRYPTO_hash_to_enc (query, &xor_got);

		//GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
		// "BLOCK_TEST for %s got %s expected %s\n",
		// name, (char) &xor_got, (char) &xor_exp);

	/* Check query key against public key */	/* Check query key against public key */
	if (0 != GNUNET_CRYPTO_hash_cmp(query, &query_key))	if (0 != GNUNET_CRYPTO_hash_cmp(query, &query_key))

	return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;	{
		GNUNET_break_op (0);
		return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
		}


		record_match = 0;
	rd_count = ntohl(nrb->rd_count);	rd_count = ntohl(nrb->rd_count);

		rd_data = (char*)&nrb[1];
		rd_data += strlen(name) + 1;
		rd_len = reply_block_size - (strlen(name) + 1
		+ sizeof(struct GNSNameRecordBlock));
		{
		struct GNUNET_NAMESTORE_RecordData rd[rd_count];
		unsigned int i;
		struct GNUNET_TIME_Absolute exp = GNUNET_TIME_UNIT_FOREVER_ABS;

		if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_len,
		rd_data,
		rd_count,
		rd))
		{
		GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
		"Data invalid (%d bytes, %d records)\n", rd_len, rd_count)
		;
		GNUNET_break_op (0);
		return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
		}


	struct GNUNET_NAMESTORE_RecordData rd[rd_count];	if (xquery_size < sizeof(uint32_t))
	int i = 0;	record_xquery = 0;
	int record_match = 0;	else
	uint32_t record_xquery = ntohl(((uint32_t)xquery));	record_xquery = ntohl(((uint32_t)xquery));
	rb = (struct GNSRecordBlock*)(&name[strlen(name) + 1]);


	for (i=0; i<rd_count; i++)	for (i=0; i<rd_count; i++)
	{	{
	rd[i].record_type = ntohl(rb->type);
	rd[i].expiration =	exp = GNUNET_TIME_absolute_min (exp, rd[i].expiration);
	GNUNET_TIME_absolute_ntoh(rb->expiration);
	rd[i].data_size = ntohl(rb->data_length);
	rd[i].flags = ntohl(rb->flags);
	rd[i].data = (char*)&rb[1];
	rb = (struct GNSRecordBlock )((char)&rb[1] + rd[i].data_size);


	if (xquery_size == 0)	GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
	continue;	"Got record of size %d\n", rd[i].data_size);


	if (rd[i].record_type == record_xquery)	if ((record_xquery != 0)
		&& (rd[i].record_type == record_xquery))
		{
		record_match++;
		}
		}

		GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
		"Verifying signature of %d records for name %s\n",
		rd_count, name);

		if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
		exp,
		name,
		rd_count,
		rd,
		&nrb->signature))
	{	{

	record_match++;	GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Signature invalid for name %s\n"
		);
		GNUNET_break_op (0);
		return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
	}	}
	}	}


	/*if (GNUNET_OK != GNUNET_NAMESTORE_verify_signature (&nrb->public_key,
	name,
	rd_count,
	rd,
	NULL))
	{
	GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Signature invalid\n");
	return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
	}*/

	//No record matches query
	if ((xquery_size > 0) && (record_match == 0))
	return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;

	GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Records match\n");
	//FIXME do bf check before or after crypto??
	if (NULL != bf)	if (NULL != bf)
	{	{
	GNUNET_CRYPTO_hash(reply_block, reply_block_size, &chash);	GNUNET_CRYPTO_hash(reply_block, reply_block_size, &chash);
	GNUNET_BLOCK_mingle_hash(&chash, bf_mutator, &mhash);	GNUNET_BLOCK_mingle_hash(&chash, bf_mutator, &mhash);
	if (NULL != *bf)	if (NULL != *bf)
	{	{

	GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Check BF\n");
	if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(*bf, &mhash))	if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(*bf, &mhash))
	return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;	return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
	}	}
	else	else
	{	{
	*bf = GNUNET_CONTAINER_bloomfilter_init(NULL, 8, BLOOMFILTER_K);	*bf = GNUNET_CONTAINER_bloomfilter_init(NULL, 8, BLOOMFILTER_K);
	}	}
	GNUNET_CONTAINER_bloomfilter_add(*bf, &mhash);	GNUNET_CONTAINER_bloomfilter_add(*bf, &mhash);
	}	}

	GNUNET_log(GNUNET_ERROR_TYPE_INFO, "No dup\n");
	return GNUNET_BLOCK_EVALUATION_OK_MORE;	return GNUNET_BLOCK_EVALUATION_OK_MORE;
	}	}

	/**	/**
	* Function called to obtain the key for a block.	* Function called to obtain the key for a block.
	*	*
	* @param cls closure	* @param cls closure
	* @param type block type	* @param type block type
	* @param block block to get the key for	* @param block block to get the key for
	* @param block_size number of bytes in block	* @param block_size number of bytes in block

	skipping to change at line 175	skipping to change at line 224
	* @return GNUNET_OK on success, GNUNET_SYSERR if type not supported	* @return GNUNET_OK on success, GNUNET_SYSERR if type not supported
	* (or if extracting a key from a block of this type does not work)	* (or if extracting a key from a block of this type does not work)
	*/	*/
	static int	static int
	block_plugin_gns_get_key (void *cls, enum GNUNET_BLOCK_Type type,	block_plugin_gns_get_key (void *cls, enum GNUNET_BLOCK_Type type,
	const void *block, size_t block_size,	const void *block, size_t block_size,
	GNUNET_HashCode * key)	GNUNET_HashCode * key)
	{	{
	if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)	if (type != GNUNET_BLOCK_TYPE_GNS_NAMERECORD)
	return GNUNET_SYSERR;	return GNUNET_SYSERR;

	GNUNET_HashCode name_hash;	struct GNUNET_CRYPTO_ShortHashCode name_hash;
	GNUNET_HashCode pkey_hash;	struct GNUNET_CRYPTO_ShortHashCode pkey_hash;
		GNUNET_HashCode name_hash_double;
		GNUNET_HashCode pkey_hash_double;

	struct GNSNameRecordBlock nrb = (struct GNSNameRecordBlock )block;	struct GNSNameRecordBlock nrb = (struct GNSNameRecordBlock )block;


	GNUNET_CRYPTO_hash(&nrb[1], strlen((char*)&nrb[1]), &name_hash);	GNUNET_CRYPTO_short_hash(&nrb[1], strlen((char*)&nrb[1]), &name_hash);
	GNUNET_CRYPTO_hash(&nrb->public_key,	GNUNET_CRYPTO_short_hash(&nrb->public_key,
	sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) ,	sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) ,
	&pkey_hash);	&pkey_hash);


	GNUNET_CRYPTO_hash_xor(&name_hash, &pkey_hash, key);	GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
		GNUNET_CRYPTO_short_hash_double(&pkey_hash, &pkey_hash_double);

		GNUNET_CRYPTO_hash_xor(&name_hash_double, &pkey_hash_double, key);


	//FIXME calculate key from name and hash(pkey) here
	return GNUNET_OK;	return GNUNET_OK;
	}	}

	/**	/**
	* Entry point for the plugin.	* Entry point for the plugin.
	*/	*/
	void *	void *
	libgnunet_plugin_block_gns_init (void *cls)	libgnunet_plugin_block_gns_init (void *cls)
	{	{
	static enum GNUNET_BLOCK_Type types[] =	static enum GNUNET_BLOCK_Type types[] =

End of changes. 24 change blocks.
	54 lines changed or deleted	110 lines changed or added
This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/