moon-abe cleanup

Change-Id: Ie1259856db03f0b9e80de3e967ec6bd1f03191b3

1 files changed, 0 insertions, 532 deletions

diff --git a/moon-abe/libbswabe-0.9/misc.c b/moon-abe/libbswabe-0.9/misc.c
deleted file mode 100644
index d6574ee8..00000000
--- a/moon-abe/libbswabe-0.9/misc.c
+++ /dev/null
@@ -1,532 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <glib.h>
-#include <pbc.h>
-
-#include "bswabe.h"
-#include "private.h"
-/* Serialize a 32 bit int
-   is used to serialize the lenght of the element
-   for each element first there its lenght on 32 bits then the element */
-void
-serialize_uint32( GByteArray* b, uint32_t k )
-{
-	int i;
-	guint8 byte;
-
-	for( i = 3; i >= 0; i-- )
-	{
-		byte = (k & 0xff<<(i*8))>>(i*8);
-		g_byte_array_append(b, &byte, 1);
-	}
-}
-
-uint32_t
-unserialize_uint32( GByteArray* b, int* offset )
-{
-	int i;
-	uint32_t r;
-
-	r = 0;
-	for( i = 3; i >= 0; i-- )
-		r |= (b->data[(*offset)++])<<(i*8);
-
-	return r;
-}
-
-/* First stores the length of the element then the bytes of the element
-   Knowing the length of the element is necessary in order to unserialize it  */
-void
-serialize_element( GByteArray* b, element_t e )
-{
-	uint32_t len;
-	unsigned char* buf;
-
-	len = element_length_in_bytes(e);
-	serialize_uint32(b, len);
-
-	buf = (unsigned char*) malloc(len);
-	element_to_bytes(buf, e);
-	g_byte_array_append(b, buf, len);
-	free(buf);
-}
-
-void
-unserialize_element( GByteArray* b, int* offset, element_t e )
-{
-	uint32_t len;
-	unsigned char* buf;
-
-	len = unserialize_uint32(b, offset);
-
-	buf = (unsigned char*) malloc(len);
-	memcpy(buf, b->data + *offset, len);
-	*offset += len;
-
-	element_from_bytes(e, buf);
-	free(buf);
-}
-
-void
-serialize_string( GByteArray* b, char* s )
-{
-	g_byte_array_append(b, (unsigned char*) s, strlen(s) + 1);
-}
-
-char*
-unserialize_string( GByteArray* b, int* offset )
-{
-	GString* s;
-	char* r;
-	char c;
-
-	s = g_string_sized_new(32);
-	while( 1 )
-	{
-		c = b->data[(*offset)++];
-		if( c && c != EOF )
-			g_string_append_c(s, c);
-		else
-			break;
-	}
-
-	r = s->str;
-	g_string_free(s, 0);
-
-	return r;
-}
-
-GByteArray*
-bswabe_pub_serialize( bswabe_pub_t* pub )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-	serialize_string(b,  pub->pairing_desc);
-	serialize_element(b, pub->g);
-	serialize_element(b, pub->h);
-	serialize_element(b, pub->gp);
-	serialize_element(b, pub->g_hat_alpha);
-
-	return b;
-}
-
-bswabe_pub_t*
-bswabe_pub_unserialize( GByteArray* b, int free )
-{
-	bswabe_pub_t* pub;
-	int offset;
-
-	pub = (bswabe_pub_t*) malloc(sizeof(bswabe_pub_t));
-	offset = 0;
-
-	pub->pairing_desc = unserialize_string(b, &offset);
-	pairing_init_set_buf(pub->p, pub->pairing_desc, strlen(pub->pairing_desc));
-
-	element_init_G1(pub->g,           pub->p);
-	element_init_G1(pub->h,           pub->p);
-	element_init_G2(pub->gp,          pub->p);
-	element_init_GT(pub->g_hat_alpha, pub->p);
-
-	unserialize_element(b, &offset, pub->g);
-	unserialize_element(b, &offset, pub->h);
-	unserialize_element(b, &offset, pub->gp);
-	unserialize_element(b, &offset, pub->g_hat_alpha);
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return pub;
-}
-
-GByteArray*
-bswabe_msk_serialize( bswabe_msk_t* msk )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-	serialize_element(b, msk->beta);
-	serialize_element(b, msk->g_alpha);
-
-	return b;
-}
-
-bswabe_msk_t*
-bswabe_msk_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	bswabe_msk_t* msk;
-	int offset;
-
-	msk = (bswabe_msk_t*) malloc(sizeof(bswabe_msk_t));
-	offset = 0;
-
-	element_init_Zr(msk->beta, pub->p);
-	element_init_G2(msk->g_alpha, pub->p);
-
-	unserialize_element(b, &offset, msk->beta);
-	unserialize_element(b, &offset, msk->g_alpha);
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return msk;
-}
-
-GByteArray*
-bswabe_prv_serialize( bswabe_prv_t* prv )
-{
-	GByteArray* b;
-	int i;
-
-	b = g_byte_array_new();
-
-	serialize_element(b, prv->d);
-	serialize_uint32( b, prv->comps->len);
-
-	for( i = 0; i < prv->comps->len; i++ )
-	{
-		serialize_string( b, g_array_index(prv->comps, bswabe_prv_comp_t, i).attr);
-		serialize_element(b, g_array_index(prv->comps, bswabe_prv_comp_t, i).d);
-		serialize_element(b, g_array_index(prv->comps, bswabe_prv_comp_t, i).dp);
-	}
-
-	return b;
-}
-
-bswabe_prv_t*
-bswabe_prv_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	bswabe_prv_t* prv;
-	int i;
-	int len;
-	int offset;
-
-	prv = (bswabe_prv_t*) malloc(sizeof(bswabe_prv_t));
-	offset = 0;
-
-	element_init_G2(prv->d, pub->p);
-	unserialize_element(b, &offset, prv->d);
-
-	prv->comps = g_array_new(0, 1, sizeof(bswabe_prv_comp_t));
-	len = unserialize_uint32(b, &offset);
-
-	for( i = 0; i < len; i++ )
-	{
-		bswabe_prv_comp_t c;
-
-		c.attr = unserialize_string(b, &offset);
-
-		element_init_G2(c.d,  pub->p);
-		element_init_G2(c.dp, pub->p);
-
-		unserialize_element(b, &offset, c.d);
-		unserialize_element(b, &offset, c.dp);
-
-		g_array_append_val(prv->comps, c);
-	}
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return prv;
-}
-/*
-GByteArray*
-peks_trap_serialize( peks_trap_t* trap )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-
-	serialize_element(b, trap->T);
-
-	return b;
-}
-peks_trap_t*
-peks_trap_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	peks_trap_t* trap;
-	int offset;
-
-	trap = (peks_trap_t*) malloc(sizeof(peks_trap_t));
-	offset = 0;
-
-		unserialize_element(b, &offset, trap->T);
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return trap;
-}
-
-*/
-GByteArray*
-peks_ind_serialize( peks_ind_t* ind )
-{
-	GByteArray* b;
-	int i;
-
-	b = g_byte_array_new();
-
-	/* First serialize the number of components   */
-	serialize_uint32( b, ind->comps->len);
-
-	for( i = 0; i < ind->comps->len; i++ )
-	{	
-	serialize_element(b, g_array_index(ind->comps, peks_sew_t, i).A );
-	serialize_element(b, g_array_index(ind->comps, peks_sew_t, i).B );
-	}
-
-	return b;
-}
-
-peks_ind_t*
-peks_ind_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	peks_ind_t* ind;
-	int i;
-	int len;
-	int offset;
-
-	ind = (peks_ind_t*) malloc(sizeof(peks_ind_t));
-	offset = 0;
-
-	ind->comps = g_array_new(0, 1, sizeof(peks_sew_t));
-	len = unserialize_uint32(b, &offset);
-
-	for( i = 0; i < len; i++ )
-	{
-		peks_sew_t sew;
-
-
-		element_init_G1(sew.A,  pub->p);
-		element_init_GT(sew.B, pub->p);
-
-		unserialize_element(b, &offset, sew.A);
-		unserialize_element(b, &offset, sew.B);
-
-		g_array_append_val(ind->comps, sew);
-	}
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return ind;
-}
-
-void
-serialize_policy( GByteArray* b, bswabe_policy_t* p )
-{
-	int i;
-
-	serialize_uint32(b, (uint32_t) p->k);
-
-	serialize_uint32(b, (uint32_t) p->children->len);
-	if( p->children->len == 0 )
-	{
-		serialize_string( b, p->attr);
-		serialize_element(b, p->c);
-		serialize_element(b, p->cp);
-	}
-	else
-		for( i = 0; i < p->children->len; i++ )
-			serialize_policy(b, g_ptr_array_index(p->children, i));
-}
-
-bswabe_policy_t*
-unserialize_policy( bswabe_pub_t* pub, GByteArray* b, int* offset )
-{
-	int i;
-	int n;
-	bswabe_policy_t* p;
-
-	p = (bswabe_policy_t*) malloc(sizeof(bswabe_policy_t));
-
-	p->k = (int) unserialize_uint32(b, offset);
-	p->attr = 0;
-	p->children = g_ptr_array_new();
-
-	n = unserialize_uint32(b, offset);
-	if( n == 0 )
-	{
-		p->attr = unserialize_string(b, offset);
-		element_init_G1(p->c,  pub->p);
-		element_init_G1(p->cp, pub->p);
-		unserialize_element(b, offset, p->c);
-		unserialize_element(b, offset, p->cp);
-	}
-	else
-		for( i = 0; i < n; i++ )
-			g_ptr_array_add(p->children, unserialize_policy(pub, b, offset));
-
-	return p;
-}
-
-GByteArray*
-bswabe_cph_serialize( bswabe_cph_t* cph )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-	serialize_element(b, cph->cs);
-	serialize_element(b, cph->c);
-	serialize_policy( b, cph->p);
-	serialize_string( b, cph->policy);
-
-	return b;
-}
-
-bswabe_cph_t*
-bswabe_cph_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	bswabe_cph_t* cph;
-	int offset;
-
-	cph = (bswabe_cph_t*) malloc(sizeof(bswabe_cph_t));
-	offset = 0;
-
-	element_init_GT(cph->cs, pub->p);
-	element_init_G1(cph->c,  pub->p);
-	unserialize_element(b, &offset, cph->cs);
-	unserialize_element(b, &offset, cph->c);
-	cph->p = unserialize_policy(pub, b, &offset);
-	cph->policy = unserialize_string(b, &offset);
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return cph;
-}
-
-GByteArray*
-peks_sew_serialize( peks_sew_t* sew )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-	serialize_element(b, sew->A);
-	serialize_element(b, sew->B);
-
-	return b;
-}
-
-peks_sew_t*
-peks_sew_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	peks_sew_t* sew;
-	int offset;
-
-	sew = (peks_sew_t*) malloc(sizeof(peks_sew_t));
-	offset = 0;
-
-	element_init_G1(sew->A, pub->p);
-	element_init_GT(sew->B, pub->p);
-
-	unserialize_element(b, &offset, sew->A);
-	unserialize_element(b, &offset, sew->B);
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return sew;
-}
-
-GByteArray*
-peks_trap_serialize( peks_trap_t* trap )
-{
-	GByteArray* b;
-
-	b = g_byte_array_new();
-	serialize_element(b, trap->T);
-
-	return b;
-}
-
-peks_trap_t*
-peks_trap_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
-{
-	peks_trap_t* trap;
-	int offset;
-
-	trap = (peks_trap_t*) malloc(sizeof(peks_trap_t));
-	offset = 0;
-
-	element_init_G1(trap->T, pub->p);
-
-	unserialize_element(b, &offset, trap->T);
-
-	if( free )
-		g_byte_array_free(b, 1);
-
-	return trap;
-}
-
-void
-bswabe_pub_free( bswabe_pub_t* pub )
-{
-	element_clear(pub->g);
-	element_clear(pub->h);
-	element_clear(pub->gp);
-	element_clear(pub->g_hat_alpha);
-	pairing_clear(pub->p);
-	free(pub->pairing_desc);
-	free(pub);
-}
-
-void
-bswabe_msk_free( bswabe_msk_t* msk )
-{
-	element_clear(msk->beta);
-	element_clear(msk->g_alpha);
-	free(msk);
-}
-
-void
-bswabe_prv_free( bswabe_prv_t* prv )
-{
-	int i;
-	
-	element_clear(prv->d);
-
-	for( i = 0; i < prv->comps->len; i++ )
-	{
-		bswabe_prv_comp_t c;
-
-		c = g_array_index(prv->comps, bswabe_prv_comp_t, i);
-		free(c.attr);
-		element_clear(c.d);
-		element_clear(c.dp);
-	}
-
-	g_array_free(prv->comps, 1);
-
-	free(prv);
-}
-
-void
-bswabe_policy_free( bswabe_policy_t* p )
-{
-	int i;
-
-	if( p->attr )
-	{
-		free(p->attr);
-		element_clear(p->c);
-		element_clear(p->cp);
-	}
-
-	for( i = 0; i < p->children->len; i++ )
-		bswabe_policy_free(g_ptr_array_index(p->children, i));
-
-	g_ptr_array_free(p->children, 1);
-
-	free(p);
-}
-
-void
-bswabe_cph_free( bswabe_cph_t* cph )
-{
-	element_clear(cph->cs);
-	element_clear(cph->c);
-	bswabe_policy_free(cph->p);
-}