added new API

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

diff --git a/include/bundle.h b/include/bundle.h
index 15b22fc..c1dc415 100755 (executable)
--- 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 (file)
--- 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 (executable)
--- 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 (executable)
--- 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;
 }