2 * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
26 #include "bundle_internal.h"
28 #include "keyval_array.h"
29 #include "keyval_type.h"
30 #include "bundle_log.h"
32 #define CHECKSUM_LENGTH 32
33 #define TAG_IMPORT_EXPORT_CHECK "`zaybxcwdveuftgsh`"
41 * Find a kv from bundle
43 static keyval_t *_bundle_find_kv(bundle *b, const char *key)
48 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
53 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
59 if (strcmp(key, kv->key) == 0) {
60 set_last_result(BUNDLE_ERROR_NONE);
66 set_last_result(BUNDLE_ERROR_KEY_NOT_AVAILABLE);
71 * Append kv into bundle
73 static int _bundle_append_kv(bundle *b, keyval_t *new_kv)
77 if (b->kv_head == NULL) {
86 return BUNDLE_ERROR_NONE;
89 static int _bundle_add_kv(bundle *b, const char *key, const void *val,
90 const size_t size, const int type, const unsigned int len)
96 /* basic value check */
98 return BUNDLE_ERROR_INVALID_PARAMETER;
100 return BUNDLE_ERROR_INVALID_PARAMETER;
101 if (strlen(key) == 0)
102 return BUNDLE_ERROR_INVALID_PARAMETER;
104 kv = _bundle_find_kv(b, key);
105 if (kv) /* Key already exists */
106 return BUNDLE_ERROR_KEY_EXISTS;
108 if (keyval_type_is_array(type)) {
110 kva = keyval_array_new(NULL, key, type,
111 (const void **) val, len);
112 new_kv = (keyval_t *)kva;
115 new_kv = keyval_new(NULL, key, type, val, size);
119 return BUNDLE_ERROR_OUT_OF_MEMORY;
121 _bundle_append_kv(b, new_kv);
123 return BUNDLE_ERROR_NONE;
126 static int _bundle_get_val(bundle *b, const char *key, const int type,
127 void **val, size_t *size, unsigned int *len,
128 size_t **array_element_size)
133 kv = _bundle_find_kv(b, key);
134 if (!kv) /* Key doesn't exist */
135 return get_last_result();
137 if (BUNDLE_TYPE_ANY != type && type != kv->type)
138 return BUNDLE_ERROR_INVALID_PARAMETER;
140 if (keyval_type_is_array(type)) {
141 kva = (keyval_array_t *)kv;
142 keyval_array_get_data(kva, NULL, (void ***)val,
143 len, array_element_size);
145 keyval_get_data(kv, NULL, val, size);
148 return BUNDLE_ERROR_NONE;
152 * global initialization
155 static void _bundle_global_init(void)
162 /* Run init functions */
170 bundle *bundle_create(void)
174 _bundle_global_init();
176 b = calloc(1, sizeof(bundle)); /* fill mem with NULL */
178 BUNDLE_EXCEPTION_PRINT(
179 "Unable to allocate memory for bundle\n");
180 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
184 set_last_result(BUNDLE_ERROR_NONE);
191 int bundle_free(bundle *b)
197 BUNDLE_EXCEPTION_PRINT("Bundle is already freed\n");
198 return BUNDLE_ERROR_INVALID_PARAMETER;
201 /* Free keyval list */
206 tmp_kv->method->free(tmp_kv, 1);
212 return BUNDLE_ERROR_NONE;
215 int bundle_add_str(bundle *b, const char *key, const char *str)
218 return BUNDLE_ERROR_INVALID_PARAMETER;
219 return _bundle_add_kv(b, key, str, strlen(str) + 1, BUNDLE_TYPE_STR, 1);
222 int bundle_get_str(bundle *b, const char *key, char **str)
224 return _bundle_get_val(b, key, BUNDLE_TYPE_STR, (void **)str,
228 int bundle_add(bundle *b, const char *key, const char *val)
230 return bundle_add_str(b, key, val);
233 int bundle_del(bundle *b, const char *key)
236 keyval_t *prev_kv = NULL;
238 /* basic value check */
240 return BUNDLE_ERROR_INVALID_PARAMETER;
242 return BUNDLE_ERROR_INVALID_PARAMETER;
243 if (strlen(key) == 0)
244 return BUNDLE_ERROR_INVALID_PARAMETER;
248 if (strcmp(key, kv->key) == 0)
255 return BUNDLE_ERROR_KEY_NOT_AVAILABLE;
258 prev_kv->next = kv->next;
259 if (kv == b->kv_head)
260 b->kv_head = kv->next;
261 kv->method->free(kv, 1);
264 return BUNDLE_ERROR_NONE;
267 const char *bundle_get_val(bundle *b, const char *key)
270 int ret = BUNDLE_ERROR_NONE;
272 ret = bundle_get_str(b, key, &val);
273 set_last_result(ret);
279 * @brief used by bundle_get_count() API, to count number of items in a bundle
281 static void _bundle_get_count_iter(const char *k, const int type,
282 const bundle_keyval_t *kv, void *user_data)
284 int *count = (int *)user_data;
288 int bundle_get_count(bundle *b)
294 bundle_foreach(b, _bundle_get_count_iter, &count);
298 void bundle_iterate(bundle *b, bundle_iterate_cb_t callback, void *data)
302 if (b == NULL || callback == NULL) {
303 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
309 callback(kv->key, kv->val, data);
313 set_last_result(BUNDLE_ERROR_NONE);
316 void bundle_foreach(bundle *b, bundle_iterator_t iter, void *user_data)
320 if (b == NULL || iter == NULL) {
321 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
322 return; /* TC_FIX if b = NULL- error handling */
327 iter(kv->key, kv->type, kv, user_data);
331 set_last_result(BUNDLE_ERROR_NONE);
334 /* keyval functions */
335 int bundle_keyval_get_type(bundle_keyval_t *kv)
338 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
341 set_last_result(BUNDLE_ERROR_NONE);
345 int bundle_keyval_type_is_array(bundle_keyval_t *kv)
348 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
351 set_last_result(BUNDLE_ERROR_NONE);
352 return keyval_type_is_array(kv->type);
355 int bundle_keyval_type_is_measurable(bundle_keyval_t *kv)
358 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
361 set_last_result(BUNDLE_ERROR_NONE);
362 return keyval_type_is_measurable(kv->type);
365 int bundle_keyval_get_basic_val(bundle_keyval_t *kv, void **val, size_t *size)
367 return keyval_get_data(kv, NULL, val, size);
370 int bundle_keyval_get_array_val(bundle_keyval_t *kv, void ***array_val,
371 unsigned int *array_len, size_t **array_item_size)
373 return keyval_array_get_data((keyval_array_t *)kv, NULL,
374 array_val, array_len, array_item_size);
377 bundle *bundle_dup(bundle *b_from)
382 keyval_array_t *kva_from;
385 if (b_from == NULL) {
386 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
390 b_to = bundle_create();
394 kv_from = b_from->kv_head;
395 while (kv_from != NULL) {
396 if (keyval_type_is_array(kv_from->type)) {
397 kva_from = (keyval_array_t *)kv_from;
398 kv_to = (keyval_t *)keyval_array_new(NULL, kv_from->key,
399 kv_from->type, NULL, kva_from->len);
403 for (i = 0; i < kva_from->len; i++) {
404 if (((keyval_array_t *)kv_from)->array_val[i]) {
405 keyval_array_set_element(
406 (keyval_array_t *)kv_to, i,
407 ((keyval_array_t *)kv_from)->array_val[i],
408 ((keyval_array_t *)kv_from)->array_element_size[i]);
412 _bundle_append_kv(b_to, kv_to);
414 if (_bundle_add_kv(b_to, kv_from->key,
415 kv_from->val, kv_from->size, kv_from->type, 0))
419 kv_from = kv_from->next;
429 int bundle_encode(bundle *b, bundle_raw **r, int *len)
439 if (b == NULL || r == NULL || len == NULL)
440 return BUNDLE_ERROR_INVALID_PARAMETER;
442 /* calculate memory size */
445 msize += kv->method->get_encoded_size(kv);
449 m = calloc(msize + CHECKSUM_LENGTH, sizeof(unsigned char));
450 if (unlikely(m == NULL))
451 return BUNDLE_ERROR_OUT_OF_MEMORY;
453 p_m = m + CHECKSUM_LENGTH; /* temporary pointer */
460 kv->method->encode(kv, &byte, &byte_len);
461 memcpy(p_m, byte, byte_len);
469 /* compute checksum from the data */
470 chksum_val = g_compute_checksum_for_string(G_CHECKSUM_MD5,
471 (const char *)(m + CHECKSUM_LENGTH), msize);
472 /* prefix checksum to the data */
473 memcpy(m, chksum_val, CHECKSUM_LENGTH);
475 /* base64 encode for whole string checksum and data */
476 *r = (unsigned char *)g_base64_encode(m, msize + CHECKSUM_LENGTH);
478 *len = strlen((char *)*r);
481 g_free(chksum_val); /* free checksum string */
483 return BUNDLE_ERROR_NONE;
486 int bundle_free_encoded_rawdata(bundle_raw **r)
489 return BUNDLE_ERROR_INVALID_PARAMETER; /* TC_FIX - double free sigabrt handling */
493 return BUNDLE_ERROR_NONE;
496 bundle *bundle_decode(const bundle_raw *r, const int data_size)
500 unsigned char *d_str;
503 unsigned int d_len_raw;
507 gchar *compute_cksum;
514 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
518 extract_cksum = calloc(CHECKSUM_LENGTH + 1, sizeof(char));
519 if (unlikely(extract_cksum == NULL)) {
520 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
525 * base 64 decode of input string
526 * Since base64 encodes 3 bytes in 4 chars (+3 may be needed in case of non-zero state)
527 * refer to: https://developer.gnome.org/glib/stable/glib-Base64-Encoding.html#g-base64-decode-step
529 d_str = malloc((data_size / 4) * 3 + 3);
530 if (unlikely(d_str == NULL)) {
531 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
536 d_len_raw = g_base64_decode_step((char *)r, data_size, d_str, &state, &save);
537 if (d_len_raw < CHECKSUM_LENGTH) {
538 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
544 /* extract checksum from the received string */
545 strncpy(extract_cksum, (const char *)d_str, CHECKSUM_LENGTH);
546 /* compute checksum for the data */
547 compute_cksum = g_compute_checksum_for_string(G_CHECKSUM_MD5,
548 (const char *)(d_str + CHECKSUM_LENGTH),
549 d_len_raw - CHECKSUM_LENGTH);
551 * compare checksum values- extracted from the received
552 * string and computed from the data
554 if (strcmp(extract_cksum, compute_cksum) != 0) {
557 g_free(compute_cksum);
560 d_r = d_str + CHECKSUM_LENGTH;
561 d_len = d_len_raw - CHECKSUM_LENGTH;
563 /* re-construct bundle */
568 g_free(compute_cksum);
572 p_r = (bundle_raw *)d_r;
573 while (p_r < d_r + d_len - 1) {
574 kv = NULL; /* To get a new kv */
576 byte_size = d_r + d_len - 1 - p_r;
577 if (byte_size < sizeof(size_t))
580 /* Find type, and use decode function according to type */
581 type = keyval_get_type_from_encoded_byte(p_r);
582 if (keyval_type_is_array(type)) {
583 bytes_read = keyval_array_decode(p_r,
584 (keyval_array_t **)&kv, byte_size);
586 bytes_read = keyval_decode(p_r, &kv, byte_size);
590 _bundle_append_kv(b, kv);
597 g_free(compute_cksum);
600 set_last_result(BUNDLE_ERROR_NONE);
610 int bundle_encode_raw(bundle *b, bundle_raw **r, int *len)
613 unsigned char *m = NULL;
614 unsigned char *p_m = NULL;
615 unsigned char *byte = NULL;
617 gchar *chksum_val = NULL;
620 if (b == NULL || r == NULL)
621 return BUNDLE_ERROR_INVALID_PARAMETER;
623 /* calculate memory size */
626 msize += kv->method->get_encoded_size(kv);
630 m = calloc(msize+CHECKSUM_LENGTH, sizeof(unsigned char));
631 if (unlikely(m == NULL))
632 return BUNDLE_ERROR_OUT_OF_MEMORY;
634 p_m = m + CHECKSUM_LENGTH; /* temporary pointer */
641 kv->method->encode(kv, &byte, &byte_len);
642 memcpy(p_m, byte, byte_len);
650 /* compute checksum from the data */
651 chksum_val = g_compute_checksum_for_string(G_CHECKSUM_MD5,
652 (const char *)(m + CHECKSUM_LENGTH), msize);
653 /* prefix checksum to the data */
654 memcpy(m, chksum_val, CHECKSUM_LENGTH);
657 *len = msize + CHECKSUM_LENGTH;
658 g_free(chksum_val); /* free checksum string */
660 return BUNDLE_ERROR_NONE;
663 bundle *bundle_decode_raw(const bundle_raw *r, const int data_size)
666 bundle_raw *p_r = NULL;
667 unsigned char *d_str = NULL;
668 unsigned int d_len_raw;
669 unsigned char *d_r = NULL;
672 gchar *compute_cksum = NULL;
679 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
683 extract_cksum = calloc(CHECKSUM_LENGTH + 1, sizeof(char));
684 if (unlikely(extract_cksum == NULL)) {
685 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
689 /* base 64 decode of input string*/
690 /* d_str = g_base64_decode((char*)r, &d_len_raw); */
691 d_str = (unsigned char *)r;
692 d_len_raw = data_size;
693 /* extract checksum from the received string */
694 strncpy(extract_cksum, (const char *)d_str, CHECKSUM_LENGTH);
695 /* compute checksum for the data */
696 compute_cksum = g_compute_checksum_for_string(G_CHECKSUM_MD5,
697 (const char *)(d_str + CHECKSUM_LENGTH),
698 d_len_raw - CHECKSUM_LENGTH);
700 * compare checksum values- extracted from the received
701 * string and computed from the data
703 if (strcmp(extract_cksum, compute_cksum) != 0) {
705 g_free(compute_cksum);
706 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
709 d_r = d_str + CHECKSUM_LENGTH;
710 d_len = d_len_raw - CHECKSUM_LENGTH;
712 /* re-construct bundle */
716 g_free(compute_cksum);
720 p_r = (bundle_raw *)d_r;
721 while (p_r < d_r + d_len - 1) {
722 kv = NULL; /* To get a new kv */
724 byte_size = d_r + d_len - 1 - p_r;
725 if (byte_size < sizeof(size_t))
728 /* Find type, and use decode function according to type */
729 type = keyval_get_type_from_encoded_byte(p_r);
730 if (keyval_type_is_array(type)) {
731 bytes_read = keyval_array_decode(p_r,
732 (keyval_array_t **)&kv, byte_size);
734 bytes_read = keyval_decode(p_r, &kv, byte_size);
738 _bundle_append_kv(b, kv);
745 g_free(compute_cksum);
746 set_last_result(BUNDLE_ERROR_NONE);
751 void _iter_export_to_argv(const char *key, const int type, const keyval_t *kv,
754 struct _argv_idx *vi = (struct _argv_idx *)user_data;
755 unsigned char *byte = NULL;
756 unsigned char *encoded_byte = NULL;
759 vi->argv[vi->idx] = strdup(key);
760 if (kv->method->encode((struct keyval_t *)kv, &byte, &byte_len) == 0) {
761 /* TODO: encode FAILED! */
762 BUNDLE_EXCEPTION_PRINT("bundle: FAILED to encode keyval: %s\n",
767 encoded_byte = (unsigned char *)g_base64_encode(byte, byte_len);
768 if (encoded_byte == NULL) {
769 BUNDLE_EXCEPTION_PRINT("bundle: failed to encode byte\n");
773 vi->argv[vi->idx + 1] = (char *)encoded_byte;
779 int bundle_export_to_argv(bundle *b, char ***argv)
785 if (b == NULL || argv == NULL) {
786 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
790 item_count = bundle_get_count(b);
791 argc = 2 * item_count + 2;
792 /* 2 more count for argv[0] and arv[1] = encoded */
793 *argv = calloc(argc + 1, sizeof(char *));
795 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
801 vi.idx = 2; /* start from index 2*/
802 vi.argv[1] = TAG_IMPORT_EXPORT_CHECK; /* set argv[1] as encoded*/
803 /* BUNDLE_LOG_PRINT("\nargument 1 is %s",vi.argv[1]); */
805 bundle_foreach(b, _iter_export_to_argv, &vi);
807 set_last_result(BUNDLE_ERROR_NONE);
811 int bundle_free_exported_argv(int argc, char ***argv)
816 return BUNDLE_ERROR_INVALID_PARAMETER;
818 if (!*argv || argc < 2)
819 return BUNDLE_ERROR_INVALID_PARAMETER;
821 for (i = 2; i < argc; i++)
826 return BUNDLE_ERROR_NONE;
829 bundle *bundle_import_from_argv(int argc, char **argv)
837 unsigned int byte_size;
841 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
842 return NULL; /* TC_FIX error handling for argv =NULL*/
847 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
852 set_last_result(BUNDLE_ERROR_NONE);
856 if (!argv[1] || strcmp(argv[1], TAG_IMPORT_EXPORT_CHECK)) {
857 /* start idx from one as argv[1] is user given argument */
858 for (idx = 1; idx + 1 < argc; idx = idx + 2)
859 bundle_add(b, argv[idx], argv[idx + 1]);
864 /* start idx from 2 as argv[1] is encoded */
865 for (idx = 2; idx + 1 < argc; idx = idx + 2) {
869 encoded_byte = argv[idx+1];
872 byte = g_base64_decode(encoded_byte, (gsize *)&byte_size);
875 set_last_result(bundle_free(b));
879 if (byte_size < sizeof(size_t)) {
886 type = keyval_get_type_from_encoded_byte(byte);
887 if (keyval_type_is_array(type)) {
888 if (keyval_array_decode(byte, &kva, byte_size) == 0) /* TODO: error! */
889 BUNDLE_EXCEPTION_PRINT("Unable to Decode array\n");
890 kv = (keyval_t *)kva;
892 if (keyval_decode(byte, &kv, byte_size) == 0) /* TODO: error! */
893 BUNDLE_EXCEPTION_PRINT("Unable to Decode\n");
895 _bundle_append_kv(b, kv);
902 set_last_result(BUNDLE_ERROR_NONE);
906 int bundle_get_type(bundle *b, const char *key)
908 keyval_t *kv = _bundle_find_kv(b, key);
913 set_last_result(BUNDLE_ERROR_KEY_NOT_AVAILABLE);
914 return BUNDLE_TYPE_NONE;
919 * Get length of an array
921 /* LCOV_EXCL_START */
922 unsigned int bundle_get_array_len(bundle *b, const char *key)
924 return BUNDLE_ERROR_NONE;
929 * Get size of an item in byte, of given pointer
931 /* LCOV_EXCL_START */
932 size_t bundle_get_array_val_size(bundle *b, const char *key,
935 return BUNDLE_ERROR_NONE;
939 static int bundle_set_array_val(bundle *b, const char *key, const int type,
940 const unsigned int idx, const void *val, const size_t size)
945 kv = _bundle_find_kv(b, key);
947 return get_last_result();
949 if (type != kv->type)
950 return BUNDLE_ERROR_INVALID_PARAMETER;
952 /* TODO: Is this needed? */
953 if (!keyval_type_is_array(kv->type))
954 return BUNDLE_ERROR_INVALID_PARAMETER;
956 kva = (keyval_array_t *)kv;
957 if (!keyval_array_is_idx_valid(kva, idx))
958 return BUNDLE_ERROR_INVALID_PARAMETER;
960 /* NULL value test (TODO: is this needed?) */
962 return BUNDLE_ERROR_INVALID_PARAMETER;
964 return keyval_array_set_element(kva, idx, (void *)val, size);
967 int bundle_add_str_array(bundle *b, const char *key, const char **str_array,
970 return _bundle_add_kv(b, key, str_array, 0, BUNDLE_TYPE_STR_ARRAY, len);
973 /* LCOV_EXCL_START */
974 int bundle_get_val_array(bundle *b, const char *key, char ***str_array,
977 return _bundle_get_val(b, key, BUNDLE_TYPE_STR_ARRAY,
978 (void **)str_array, NULL, (unsigned int *)len, NULL);
982 const char **bundle_get_str_array(bundle *b, const char *key, int *len)
984 int ret = BUNDLE_ERROR_NONE;
985 const char **arr_val = NULL;
987 ret = bundle_get_val_array(b, key, (char ***)&arr_val, len);
988 set_last_result(ret);
993 /* LCOV_EXCL_START */
994 int bundle_compare(bundle *b1, bundle *b2)
1002 if (bundle_get_count(b1) != bundle_get_count(b2))
1005 for (kv1 = b1->kv_head; kv1 != NULL; kv1 = kv1->next) {
1006 kv2 = _bundle_find_kv(b2, kv1->key);
1009 if (kv1->method->compare(kv1, kv2))
1015 /* LCOV_EXCL_STOP */
1017 int bundle_set_str_array_element(bundle *b, const char *key,
1018 const unsigned int idx, const char *val)
1021 return BUNDLE_ERROR_INVALID_PARAMETER;
1023 return bundle_set_array_val(b, key, BUNDLE_TYPE_STR_ARRAY,
1024 idx, val, strlen(val) + 1);
1027 int bundle_add_byte(bundle *b, const char *key, const void *byte,
1030 return _bundle_add_kv(b, key, byte, size, BUNDLE_TYPE_BYTE, 1);
1033 int bundle_get_byte(bundle *b, const char *key, void **byte, size_t *size)
1035 return _bundle_get_val(b, key, BUNDLE_TYPE_BYTE, (void **)byte,
1039 int bundle_add_byte_array(bundle *b, const char *key, void **byte_array,
1040 const unsigned int len)
1042 return _bundle_add_kv(b, key, byte_array, 0,
1043 BUNDLE_TYPE_BYTE_ARRAY, len);
1046 int bundle_get_byte_array(bundle *b, const char *key, void ***byte_array,
1047 unsigned int *len, unsigned int **array_element_size)
1049 return _bundle_get_val(b, key, BUNDLE_TYPE_BYTE_ARRAY,
1050 (void **)byte_array, NULL, len, (size_t **)array_element_size);
1053 int bundle_set_byte_array_element(bundle *b, const char *key,
1054 const unsigned int idx, const void *val, const size_t size)
1056 return bundle_set_array_val(b, key, BUNDLE_TYPE_BYTE_ARRAY,