added new APIsubmit/tizen_2.1/20130514.051852submit/tizen/20130517.044838accepted/tizen/20130520.100943tizen_2.1

Signed-off-by: Jaeho Lee <jaeho81.lee@samsung.com>

4 files changed, 191 insertions, 4 deletions

diff --git a/include/bundle.h b/include/bundle.h
index 15b22fc..c1dc415 100755
--- a/include/bundle.h
+++ b/include/bundle.h
@@ -562,6 +562,61 @@ API int				bundle_free_encoded_rawdata(bundle_raw **r);
  */
 API bundle *		bundle_decode(const bundle_raw *r, const int len);
 
+/**
+ * @brief	Encode bundle to bundle_raw format
+ * @pre			b must be a valid bundle object.
+ * @post		None
+ * @see			None
+ * @param[in]	b	bundle object
+ * @param[out]	r	returned bundle_raw data(byte data)
+ *					r MUST BE FREED by free(r).
+ * @param[out]	len	size of r (in bytes)
+ * @return	size of raw data
+ * @retval		0		Success
+ * @retval		-1		Failure
+ * @remark		None
+ @code
+ #include <bundle.h>
+ bundle *b = bundle_create(); // Create new bundle object
+ bundle_add(b, "foo_key", "bar_val"); // add a key-val pair
+ bundle_raw *r;
+ int len;
+ bundle_encode_raw(b, &r, &len);	// encode b
+
+ bundle_free_encoded_rawdata(r);
+ bundle_free(b);
+ @endcode
+ */
+API int				bundle_encode_raw(bundle *b, bundle_raw **r, int *len);
+
+/**
+ * @brief	deserialize bundle_raw, and get bundle object
+ * @pre			b must be a valid bundle object.
+ * @post		None
+ * @see			None
+ * @param[in]	r	bundle_raw data to be converted to bundle object
+ * @param[in]	len	size of r
+ * @return	bundle object
+ * @retval	NULL	Failure
+ * @remark		None
+ @code
+ #include <bundle.h>
+ bundle *b = bundle_create(); // Create new bundle object
+ bundle_add(b, "foo_key", "bar_val"); // add a key-val pair
+
+ bundle_raw *encoded_b;
+ int len;
+ bundle_encode(b, &encoded_b, &len);	// encode b
+
+ bundle *b_dup;
+ b_dup = bundle_decode_raw(encoded_b, len);	// decoded bundle object
+
+ bundle_free(b);
+ free(encoded_b);
+ bundle_free(b_dup);
+ @endcode
+ */
+API bundle *		bundle_decode_raw(const bundle_raw *r, const int len);
 
 /**
  * @brief	Export bundle to argv
diff --git a/packaging/bundle.spec b/packaging/bundle.spec
index 95ab43c..85cbff6 100644
--- a/packaging/bundle.spec
+++ b/packaging/bundle.spec
@@ -1,6 +1,6 @@
 Name:       bundle
 Summary:    String key-val dictionary ADT
-Version:    0.1.30
+Version:    0.1.31
 Release:    1
 Group:      System/Libraries
 License:    Apache License, Version 2.0
diff --git a/src/bundle.c b/src/bundle.c
index 5775954..2d9902c 100755
--- a/src/bundle.c
+++ b/src/bundle.c
@@ -538,6 +538,139 @@ struct _argv_idx {
 	int idx;
 };
 
+int
+bundle_encode_raw(bundle *b, bundle_raw **r, int *len)
+{
+	keyval_t *kv = NULL;
+	unsigned char *m = NULL;
+	unsigned char *p_m = NULL;
+	unsigned char *byte = NULL;
+	size_t byte_len;
+	gchar *chksum_val = NULL;
+
+	if(NULL == b || NULL == r) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	/* calculate memory size */
+	size_t msize = 0;	// Sum of required size
+
+	kv = b->kv_head;
+	while(kv != NULL) {
+		msize += kv->method->get_encoded_size(kv);
+		kv = kv->next;
+	}
+	m = calloc(msize+CHECKSUM_LENGTH, sizeof(unsigned char));
+	if(unlikely(NULL == m ))  { errno = ENOMEM; return -1; }
+
+	p_m = m+CHECKSUM_LENGTH;	/* temporary pointer */
+
+	kv = b->kv_head;
+	while(kv != NULL) {
+		byte = NULL;
+		byte_len = 0;
+
+		kv->method->encode(kv, &byte, &byte_len);
+		memcpy(p_m, byte, byte_len);
+
+		p_m += byte_len;
+		kv = kv->next;
+
+		free(byte);
+	}
+
+	/*compute checksum from the data*/
+	chksum_val = g_compute_checksum_for_string(G_CHECKSUM_MD5,m+CHECKSUM_LENGTH,msize);
+	/*prefix checksum to the data */
+	memcpy(m,chksum_val,CHECKSUM_LENGTH);
+	/*if ( NULL != r ) {
+		*r =(unsigned char*)g_base64_encode(m,msize+CHECKSUM_LENGTH);
+		if ( NULL != len ) *len = strlen((char*)*r);
+	}
+	free(m);*/
+	*r = m;
+	*len = msize+CHECKSUM_LENGTH;
+	g_free(chksum_val);/*free checksum string */
+
+	return 0;
+}
+
+bundle *
+bundle_decode_raw(const bundle_raw *r, const int data_size)
+{
+	bundle *b = NULL;
+	bundle_raw *p_r = NULL;
+	unsigned char *d_str = NULL;
+	unsigned int d_len_raw;
+	unsigned char *d_r = NULL;
+	unsigned int d_len;
+	char *extract_cksum = NULL;
+	gchar* compute_cksum = NULL;
+
+	if(NULL == r) {
+		errno = EINVAL;
+		return NULL;
+	}
+
+	extract_cksum = calloc(CHECKSUM_LENGTH+1, sizeof(char));
+	if(unlikely(NULL== extract_cksum))
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	/* base 64 decode of input string*/
+	//d_str = g_base64_decode((char*)r, &d_len_raw);
+	d_str = r;
+	d_len_raw = data_size;
+	/*extract checksum from the received string */
+	strncpy(extract_cksum,d_str,CHECKSUM_LENGTH);
+	/* compute checksum for the data */
+	compute_cksum = g_compute_checksum_for_string(G_CHECKSUM_MD5,d_str+CHECKSUM_LENGTH,d_len_raw-CHECKSUM_LENGTH);
+	/*compare checksum values- extracted from the received string and computed from the data */
+	if(strcmp(extract_cksum,compute_cksum)!=0)
+	{
+		free(extract_cksum);
+		g_free(compute_cksum);
+		return NULL;
+	}
+	d_r = d_str+CHECKSUM_LENGTH;
+	d_len= d_len_raw-CHECKSUM_LENGTH;
+
+	/* re-construct bundle */
+	b = bundle_create();
+
+	p_r = (bundle_raw *)d_r;
+
+	size_t bytes_read;
+	keyval_t *kv;
+
+	while(p_r < d_r + d_len - 1) {
+		kv = NULL;	// To get a new kv
+
+		// Find type, and use decode function according to type
+		int type = keyval_get_type_from_encoded_byte(p_r);
+
+		if(keyval_type_is_array(type)) {
+			bytes_read = keyval_array_decode(p_r, (keyval_array_t **) &kv);
+		}
+		else {
+			bytes_read = keyval_decode(p_r, &kv);
+		}
+
+		if(kv) _bundle_append_kv(b, kv);
+		else { break; }
+		p_r += bytes_read;
+	}
+
+	free(extract_cksum);
+	g_free(compute_cksum);
+	//free(d_str);
+
+	return b;
+}
+
 
 void 
 _iter_export_to_argv(const char *key, const int type, const keyval_t *kv, void *user_data)
diff --git a/src/keyval_type.c b/src/keyval_type.c
index 38db370..0f69eee 100755
--- a/src/keyval_type.c
+++ b/src/keyval_type.c
@@ -28,12 +28,11 @@
 void
 keyval_type_init(void)
 {
-	static int is_done;
-	is_done = 0;
+	static int is_done = 0;
+
 	if(is_done) return;
 
 	// Still do nothing
-	
 	is_done = 1;
 }