/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
/**
*
* @ingroup SLP_PG
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
#ifndef __BUNDLE_H__
#define __BUNDLE_H__
extern "C" {
# endif
-#define API __attribute__((visibility("default")))
+#define API __attribute__((visibility("default")))
#define likely(x) __builtin_expect(x,1)
#define unlikely(x) __builtin_expect(x,0)
*/
typedef enum
{
- BUNDLE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
- BUNDLE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
- BUNDLE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- BUNDLE_ERROR_KEY_NOT_AVAILABLE = TIZEN_ERROR_KEY_NOT_AVAILABLE, /**< Required key not available */
- BUNDLE_ERROR_KEY_EXISTS = TIZEN_ERROR_BUNDLE | 0x01 /**< Key exists */
+ BUNDLE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ BUNDLE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ BUNDLE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ BUNDLE_ERROR_KEY_NOT_AVAILABLE = TIZEN_ERROR_KEY_NOT_AVAILABLE, /**< Required key not available */
+ BUNDLE_ERROR_KEY_EXISTS = TIZEN_ERROR_BUNDLE | 0x01 /**< Key exists */
} bundle_error_e;
/**
*/
typedef unsigned char bundle_raw;
-
/**
* @brief Enumeration for key-value pair types.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
enum bundle_type_property {
- BUNDLE_TYPE_ARRAY = 0x0100, /**< Array type */
- BUNDLE_TYPE_PRIMITIVE = 0x0200, /**< Primitive type */
- BUNDLE_TYPE_MEASURABLE = 0x0400 /**< Measurable type */
+ BUNDLE_TYPE_ARRAY = 0x0100, /**< Array type */
+ BUNDLE_TYPE_PRIMITIVE = 0x0200, /**< Primitive type */
+ BUNDLE_TYPE_MEASURABLE = 0x0400 /**< Measurable type */
};
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
enum bundle_type {
- BUNDLE_TYPE_NONE = -1, /**< None */
- BUNDLE_TYPE_ANY = 0, /**< Any type */
- BUNDLE_TYPE_STR = 1 | BUNDLE_TYPE_MEASURABLE, /**< String type (Default) */
- BUNDLE_TYPE_STR_ARRAY = BUNDLE_TYPE_STR | BUNDLE_TYPE_ARRAY | BUNDLE_TYPE_MEASURABLE, /**< String array type */
- BUNDLE_TYPE_BYTE = 2, /**< Byte type */
- BUNDLE_TYPE_BYTE_ARRAY = BUNDLE_TYPE_BYTE | BUNDLE_TYPE_ARRAY /**< Byte array type */
+ BUNDLE_TYPE_NONE = -1, /**< None */
+ BUNDLE_TYPE_ANY = 0, /**< Any type */
+ BUNDLE_TYPE_STR = 1 | BUNDLE_TYPE_MEASURABLE, /**< String type (Default) */
+ BUNDLE_TYPE_STR_ARRAY = BUNDLE_TYPE_STR | BUNDLE_TYPE_ARRAY | BUNDLE_TYPE_MEASURABLE, /**< String array type */
+ BUNDLE_TYPE_BYTE = 2, /**< Byte type */
+ BUNDLE_TYPE_BYTE_ARRAY = BUNDLE_TYPE_BYTE | BUNDLE_TYPE_ARRAY /**< Byte array type */
};
/**
*/
typedef struct keyval_t bundle_keyval_t;
-
/**
* @brief Called for every key-value pair.
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
bundle_free(b); // free bundle
@endcode
*/
-API bundle* bundle_create(void);
+API bundle *bundle_create(void);
/**
* @brief Frees the given bundle object with key-value pairs in it.
bundle_free(b); // free bundle
@endcode
*/
-API int bundle_free(bundle *b);
+API int bundle_free(bundle *b);
/**
* @brief Adds a strings array type key-value pair into a given bundle.
bundle_free(b);
@endcode
*/
-API int bundle_del(bundle *b, const char* key);
+API int bundle_del(bundle *b, const char *key);
/**
* @brief Gets a string array from a given key.
bundle_free(b);
@endcode
*/
-API const char** bundle_get_str_array(bundle *b, const char *key,int *len);
+API const char **bundle_get_str_array(bundle *b, const char *key, int *len);
/**
* @brief Gets the number of bundle items.
bundle_free(b);
@endcode
*/
-API int bundle_get_count(bundle *b);
+API int bundle_get_count(bundle *b);
/**
* @brief Gets the type of a value with a given key.
bundle_free(b_dup);
@endcode
*/
-API bundle * bundle_dup(bundle *b_from);
+API bundle *bundle_dup(bundle *b_from);
/**
* @brief Iterates a callback function for each key-value pair in a given bundle.
}
@endcode
*/
-API void bundle_foreach(bundle *b, bundle_iterator_t iter, void *user_data);
+API void bundle_foreach(bundle *b, bundle_iterator_t iter, void *user_data);
/**
* @brief Gets the type of a key-value pair.
bundle_free(b);
@endcode
*/
-API int bundle_encode(bundle *b, bundle_raw **r, int *len);
+API int bundle_encode(bundle *b, bundle_raw **r, int *len);
/**
* @brief Deserializes bundle_raw and gets the bundle object.
bundle_free(b_dup);
@endcode
*/
-API bundle * bundle_decode(const bundle_raw *r, const int len);
+API bundle *bundle_decode(const bundle_raw *r, const int len);
/**
* @brief Adds a string type key-value pair into a bundle.
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
#ifndef __BUNDLE_INTERNAL_H__
#define __BUNDLE_INTERNAL_H__
* @pre @a b must be a valid bundle object.
* @see bundle_add_str()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create(); // Create new bundle object
bundle_add(b, "foo_key", "bar_val"); // add a key-val pair
bundle_free(b);
@endcode
*/
-API int bundle_add(bundle *b, const char *key, const char *val);
+API int bundle_add(bundle *b, const char *key, const char *val);
/**
* @brief Gets a value with a given key.
* @pre @a b must be a valid bundle object.
* @see bundle_get_str()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create(); // Create new bundle object
bundle_add_str(b, "foo", "bar"); //add a key-val pair
char *val = bundle_get_val(b, "foo_key"); // val = "bar_val"
val = NULL;
@endcode
*/
-API const char* bundle_get_val(bundle *b, const char *key);
+API const char *bundle_get_val(bundle *b, const char *key);
/**
* @brief Iterates a callback function for each key-value pairs in a given bundle.
* @pre @a b must be a valid bundle object.
@code
#include <stdio.h>
- #include <bundle.h>
+ #include <bundle_internal.h>
void sample_cb(const char *k, const char *v, void *data) {
printf("%s -> %s\n", k, v);
}
}
@endcode
*/
-API void bundle_iterate(bundle *b, bundle_iterate_cb_t callback, void *cb_data);
+API void bundle_iterate(bundle *b, bundle_iterate_cb_t callback, void *cb_data);
/**
* @brief Determines whether the type of a key-value pair is measurable.
* @pre @a r is a valid rawdata generated by bundle_encode().
* @see bundle_encode()
*/
-API int bundle_free_encoded_rawdata(bundle_raw **r);
+API int bundle_free_encoded_rawdata(bundle_raw **r);
/**
* @brief Encodes a bundle to the bundle_raw format.
* @retval BUNDLE_ERROR_OUT_OF_MEMORY Out of memory
* @pre @a b must be a valid bundle object.
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create(); // Create new bundle object
bundle_add_str(b, "foo_key", "bar_val"); // add a key-val pair
bundle_raw *r;
bundle_free(b);
@endcode
*/
-API int bundle_encode_raw(bundle *b, bundle_raw **r, int *len);
+API int bundle_encode_raw(bundle *b, bundle_raw **r, int *len);
/**
* @brief Deserializes bundle_raw and gets a bundle object.
* @exception BUNDLE_ERROR_INVALID_PARAMETER Invalid parameter
* @pre @a b must be a valid bundle object.
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create(); // Create new bundle object
bundle_add_str(b, "foo_key", "bar_val"); // add a key-val pair
bundle_free(b_dup);
@endcode
*/
-API bundle * bundle_decode_raw(const bundle_raw *r, const int len);
+API bundle *bundle_decode_raw(const bundle_raw *r, const int len);
/**
* @brief Exports bundle to @a argv.
* Each item of @a argv points to the string in the bundle object @a b. If @a b is freed, @a argv will have garbage pointers. DO NOT FREE @a b BEFORE ACCESSING @a argv!!
* @see bundle_import_from_argv()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create(); // Create new bundle object
bundle_add_str(b, "foo_key", "bar_val"); // add a key-val pair
bundle_free(b);
@endcode
*/
-API int bundle_export_to_argv(bundle *b, char ***argv);
+API int bundle_export_to_argv(bundle *b, char ***argv);
/**
* @brief Frees the exported @a argv.
bundle_free(b);
@endcode
*/
-API int bundle_free_exported_argv(int argc, char ***argv);
+API int bundle_free_exported_argv(int argc, char ***argv);
/**
* @brief Imports a bundle from @a argv.
* @post The returned bundle @a b must be freed.
* @see bundle_export_to_argv()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
int main(int argc, char **argv) {
bundle *b = bundle_import_from_argv(argc, argv); // import from argc+argv
}
@endcode
*/
-API bundle * bundle_import_from_argv(int argc, char **argv);
+API bundle *bundle_import_from_argv(int argc, char **argv);
/**
* @brief Sets a value of string array elements.
* @see bundle_add_str_array()
* @see bundle_get_str_array()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create();
bundle_add_str_array(b, "foo", NULL, 3); // add a key-val pair
bundle_set_str_array_element(b, "foo", 0, "aaa");
* @see bundle_get_byte_array()
* @see bundle_set_byte_array_element()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create();
bundle_add_byte_array(b, "foo", NULL, 3); // add a byte-array with length 3
* @see bundle_add_byte_array()
* @see bundle_get_byte_array()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create();
bundle_add_byte_array(b, "foo", NULL, 3); // add a key-val pair
* @see bundle_add_byte_array()
* @see bundle_set_byte_array_element()
@code
- #include <bundle.h>
+ #include <bundle_internal.h>
bundle *b = bundle_create();
bundle_add_byte_array(b, "foo", NULL, 3);
bundle_set_byte_array_element(b, "foo", 0, "aaa\0", 4);
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
+#ifndef __BUNDLE_LOG_H__
+#define __BUNDLE_LOG_H__
#include <dlog/dlog.h>
+
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "BUNDLE"
#ifdef _DEBUG_MODE_
-#define BUNDLE_LOG_PRINT(FMT, ARG...) do { printf("%5d", getpid()); printf
- ("%s() : "FMT"\n", __FUNCTION__, ##ARG); } while (false)
-#define BUNDLE_EXCEPTION_PRINT(FMT, ARG...) do { printf("%5d", getpid());
- printf("%s() : "FMT"\n", __FUNCTION__, ##ARG); } while (false)
-#define BUNDLE_ASSERT_PRINT(FMT, ARG...) do { printf("%5d", getpid()); printf
- ("%s() : "FMT"\n", __FUNCTION__, ##ARG); } while (false)
+#define BUNDLE_LOG_PRINT(FMT, ARG...) \
+ do { \
+ printf("%5d", getpid()); \
+ printf("%s() : "FMT"\n", __FUNCTION__, ##ARG); \
+ } while (0)
+
+#define BUNDLE_EXCEPTION_PRINT(FMT, ARG...) \
+ do { \
+ printf("%5d", getpid()); \
+ printf("%s() : "FMT"\n", __FUNCTION__, ##ARG); \
+ } while (0)
+
+#define BUNDLE_ASSERT_PRINT(FMT, ARG...) \
+ do { \
+ printf("%5d", getpid()); \
+ printf("%s() : "FMT"\n", __FUNCTION__, ##ARG); \
+ } while (0)
#else
#define BUNDLE_LOG_PRINT(FMT, ARG...) SLOGD(FMT, ##ARG);
#define BUNDLE_EXCEPTION_PRINT(FMT, ARG...) SLOGW(FMT, ##ARG);
#define BUNDLE_ASSERT_PRINT(FMT, ARG...) SLOGE(FMT, ##ARG);
-#endif
+#endif /* _DEBUG_MODE_ */
+
+#endif /* __BUNDLE_LOG_H__ */
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
#ifndef __KEYVAL_H__
#define __KEYVAL_H__
#include <stddef.h>
-// ADT: object
+/* ADT: object */
typedef struct keyval_t keyval_t;
-// Object methods
+/* Object methods */
typedef struct keyval_method_collection_t keyval_method_collection_t;
typedef void (*keyval_method_free_t)(keyval_t *kv, int do_free_object);
typedef int (*keyval_method_compare_t) (keyval_t *kv1, keyval_t *kv2);
typedef size_t (*keyval_method_get_encoded_size_t)(keyval_t *kv);
-typedef size_t (*keyval_method_encode_t)(keyval_t *, unsigned char **byte, size_t *byte_len);
+typedef size_t (*keyval_method_encode_t)(
+ keyval_t *,
+ unsigned char **byte,
+ size_t *byte_len);
typedef size_t (*keyval_method_decode_t)(unsigned char *byte, keyval_t **kv);
-
-struct keyval_method_collection_t
-{
+struct keyval_method_collection_t {
keyval_method_free_t free;
keyval_method_compare_t compare;
keyval_method_get_encoded_size_t get_encoded_size;
keyval_method_decode_t decode;
};
-struct keyval_t
-{
+struct keyval_t {
int type;
- char *key; // To be freed.
- void *val; // To be freed.
- size_t size; // Size of a single value.
+ char *key; /* To be freed. */
+ void *val; /* To be freed. */
+ size_t size; /* Size of a single value. */
struct keyval_t *next;
-
keyval_method_collection_t *method;
-
};
-
-keyval_t * keyval_new(keyval_t *kv, const char *key, const int type, const void *val, const size_t size);
+keyval_t * keyval_new(keyval_t *kv, const char *key,
+ const int type, const void *val, const size_t size);
void keyval_free(keyval_t *kv, int do_free_object);
int keyval_compare(keyval_t *kv1, keyval_t *kv2);
size_t keyval_get_encoded_size(keyval_t *kv);
int keyval_get_type_from_encoded_byte(unsigned char *byte);
#endif /* __KEYVAL_H__ */
-
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
+#ifndef __KEYVAL_ARRAY_H__
+#define __kEYVAL_ARRAY_H__
/**
* keyval_array.h
#include "keyval.h"
-
-typedef struct keyval_array_t
-{
- struct keyval_t kv; // Inherits keyval_t
-
- unsigned int len; // length of array_val
- size_t *array_element_size; // Array of size of each element
- void **array_val; // Array
-
+typedef struct keyval_array_t {
+ struct keyval_t kv; /* Inherits keyval_t */
+ unsigned int len; /* length of array_val */
+ size_t *array_element_size; /* Array of size of each element */
+ void **array_val; /* Array */
} keyval_array_t;
-
-keyval_array_t *keyval_array_new(keyval_array_t *kva, const char *key, const int type, const void **array_val, const unsigned int len);
+keyval_array_t *keyval_array_new(keyval_array_t *kva, const char *key,
+ const int type, const void **array_val, const unsigned int len);
void keyval_array_free(keyval_array_t *kva, int do_free_object);
int keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2);
size_t keyval_array_get_encoded_size(keyval_array_t *kva);
size_t keyval_array_encode(keyval_array_t *kva, void **byte, size_t *byte_len);
size_t keyval_array_decode(void *byte, keyval_array_t **kva);
-int keyval_array_copy_array(keyval_array_t *kva, void **array_val, unsigned int array_len, size_t (*measure_val_len)(void * val));
-int keyval_array_get_data(keyval_array_t *kva, int *type,void ***array_val, unsigned int *len, size_t **array_element_size);
-int keyval_array_set_element(keyval_array_t *kva, int idx, void *val, size_t size);
+int keyval_array_copy_array(keyval_array_t *kva, void **array_val,
+ unsigned int array_len, size_t (*measure_val_len)(void * val));
+int keyval_array_get_data(keyval_array_t *kva, int *type, void ***array_val,
+ unsigned int *len, size_t **array_element_size);
+int keyval_array_set_element(keyval_array_t *kva,
+ int idx, void *val, size_t size);
int keyval_array_is_idx_valid(keyval_array_t *kva, int idx);
+
+#endif /* __KEYVAL_ARRAY_H__ */
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
#ifndef __KEYVAL_TYPE_H__
#define __KEYVAL_TYPE_H__
* Definitions & short funcs for keyval type
*/
-#include "bundle.h"
#include <stddef.h>
#include <string.h>
-// measure_size function type
+#include "bundle.h"
+
+/* measure_size function type */
typedef size_t (*keyval_type_measure_size_func_t) (void *val);
void _type_init_measure_size_func(void);
int keyval_type_is_measurable(int type);
keyval_type_measure_size_func_t keyval_type_get_measure_size_func(int type);
-
/* Measure functions for each type */
size_t keyval_type_measure_size_str(void *val);
void keyval_type_init(void);
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
-
/**
* bundle.c
*/
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
#include "bundle.h"
#include "bundle_internal.h"
#include "keyval.h"
#include "keyval_array.h"
#include "keyval_type.h"
#include "bundle_log.h"
-#include <glib.h>
-
-#include <stdlib.h> /* calloc, free */
-#include <string.h> /* strdup */
#define CHECKSUM_LENGTH 32
#define TAG_IMPORT_EXPORT_CHECK "`zaybxcwdveuftgsh`"
+
/* ADT */
struct _bundle_t {
keyval_t *kv_head;
};
-
/**
* Find a kv from bundle
*/
-static keyval_t *
-_bundle_find_kv(bundle *b, const char *key)
+static keyval_t *_bundle_find_kv(bundle *b, const char *key)
{
keyval_t *kv;
- if (NULL == b) {
+
+ if (b == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
- if (NULL == key) {
+
+ if (key == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
kv = b->kv_head;
while (kv != NULL) {
- if (0 == strcmp(key, kv->key)) {
+ if (strcmp(key, kv->key) == 0) {
set_last_result(BUNDLE_ERROR_NONE);
return kv;
}
/**
* Append kv into bundle
*/
-static int
-_bundle_append_kv(bundle *b, keyval_t *new_kv)
+static int _bundle_append_kv(bundle *b, keyval_t *new_kv)
{
keyval_t *kv;
- if (NULL == b->kv_head)
+ if (b->kv_head == NULL) {
b->kv_head = new_kv;
- else {
+ } else {
kv = b->kv_head;
- while (NULL != kv->next)
+ while (kv->next)
kv = kv->next;
kv->next = new_kv;
}
+
return BUNDLE_ERROR_NONE;
}
-static int
-_bundle_add_kv(bundle *b, const char *key, const void *val,
+static int _bundle_add_kv(bundle *b, const char *key, const void *val,
const size_t size, const int type, const unsigned int len)
{
+ keyval_t *kv;
+ keyval_t *new_kv;
+ keyval_array_t *kva;
+
/* basic value check */
- if (NULL == b)
+ if (b == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
- if (NULL == key)
+ if (key == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
- if (0 == strlen(key))
+ if (strlen(key) == 0)
return BUNDLE_ERROR_INVALID_PARAMETER;
- keyval_t *kv = _bundle_find_kv(b, key);
- if (kv) { /* Key already exists */
+ kv = _bundle_find_kv(b, key);
+ if (kv) /* Key already exists */
return BUNDLE_ERROR_KEY_EXISTS;
- }
- keyval_t *new_kv = NULL;
if (keyval_type_is_array(type)) {
/* array type */
- keyval_array_t *kva = keyval_array_new(NULL, key, type,
+ kva = keyval_array_new(NULL, key, type,
(const void **) val, len);
new_kv = (keyval_t *)kva;
} else {
/* normal type */
new_kv = keyval_new(NULL, key, type, val, size);
}
+
if (!new_kv)
return BUNDLE_ERROR_OUT_OF_MEMORY;
_bundle_append_kv(b, new_kv);
return BUNDLE_ERROR_NONE;
-
}
-static int
-_bundle_get_val(bundle *b, const char *key, const int type, void **val,
- size_t *size, unsigned int *len, size_t **array_element_size)
+static int _bundle_get_val(bundle *b, const char *key, const int type,
+ void **val, size_t *size, unsigned int *len,
+ size_t **array_element_size)
{
- keyval_t *kv = _bundle_find_kv(b, key);
- if (!kv) /* Key doesn't exist */
+ keyval_t *kv;
+ keyval_array_t *kva;
+
+ kv = _bundle_find_kv(b, key);
+ if (!kv) /* Key doesn't exist */
return get_last_result();
if (BUNDLE_TYPE_ANY != type && type != kv->type)
return BUNDLE_ERROR_INVALID_PARAMETER;
if (keyval_type_is_array(type)) {
- keyval_array_t *kva = (keyval_array_t *)kv;
+ kva = (keyval_array_t *)kv;
keyval_array_get_data(kva, NULL, (void ***)val,
len, array_element_size);
} else {
return BUNDLE_ERROR_NONE;
}
-/** global initialization
- * Run only once.
+/**
+ * global initialization
+ * Run only once.
*/
-static void
-_bundle_global_init(void)
+static void _bundle_global_init(void)
{
static int _is_done;
return;
}
-
/* APIs */
-bundle *
-bundle_create(void)
+bundle *bundle_create(void)
{
bundle *b = NULL;
_bundle_global_init();
b = calloc(1, sizeof(bundle)); /* fill mem with NULL */
- if (NULL == b) {
- BUNDLE_EXCEPTION_PRINT("Unable to allocate memory for bundle\n");
+ if (b == NULL) {
+ BUNDLE_EXCEPTION_PRINT(
+ "Unable to allocate memory for bundle\n");
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
- goto EXCEPTION;
+ goto exception;
}
set_last_result(BUNDLE_ERROR_NONE);
return b;
-EXCEPTION:
+exception:
return NULL;
}
-int
-bundle_free(bundle *b)
+int bundle_free(bundle *b)
{
- keyval_t *kv, *tmp_kv;
+ keyval_t *kv;
+ keyval_t *tmp_kv;
- if (NULL == b) {
+ if (b == NULL) {
BUNDLE_EXCEPTION_PRINT("Bundle is already freed\n");
return BUNDLE_ERROR_INVALID_PARAMETER;
}
/* Free keyval list */
kv = b->kv_head;
- while (kv != NULL) {
+ while (kv) {
tmp_kv = kv;
kv = kv->next;
tmp_kv->method->free(tmp_kv, 1);
return BUNDLE_ERROR_NONE;
}
-int
-bundle_add_str(bundle *b, const char *key, const char *str)
+int bundle_add_str(bundle *b, const char *key, const char *str)
{
if (!str)
return BUNDLE_ERROR_INVALID_PARAMETER;
- return _bundle_add_kv(b, key, str, strlen(str)+1, BUNDLE_TYPE_STR, 1);
+ return _bundle_add_kv(b, key, str, strlen(str) + 1, BUNDLE_TYPE_STR, 1);
}
-int
-bundle_get_str(bundle *b, const char *key, char **str)
+int bundle_get_str(bundle *b, const char *key, char **str)
{
- return _bundle_get_val(b, key, BUNDLE_TYPE_STR, (void **) str,
+ return _bundle_get_val(b, key, BUNDLE_TYPE_STR, (void **)str,
NULL, NULL, NULL);
}
-int
-bundle_add(bundle *b, const char *key, const char *val)
+int bundle_add(bundle *b, const char *key, const char *val)
{
return bundle_add_str(b, key, val);
}
-int
-bundle_del(bundle *b, const char *key)
+int bundle_del(bundle *b, const char *key)
{
- keyval_t *kv = NULL, *prev_kv = NULL;
+ keyval_t *kv;
+ keyval_t *prev_kv = NULL;
/* basic value check */
- if (NULL == b)
+ if (b == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
- if (NULL == key)
+ if (key == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
- if (0 == strlen(key))
+ if (strlen(key) == 0)
return BUNDLE_ERROR_INVALID_PARAMETER;
kv = b->kv_head;
- while (kv != NULL) {
- if (0 == strcmp(key, kv->key))
+ while (kv) {
+ if (strcmp(key, kv->key) == 0)
break;
prev_kv = kv;
kv = kv->next;
}
- if (NULL == kv)
+
+ if (kv == NULL) {
return BUNDLE_ERROR_KEY_NOT_AVAILABLE;
- else {
- if (NULL != prev_kv)
+ } else {
+ if (prev_kv)
prev_kv->next = kv->next;
if (kv == b->kv_head)
b->kv_head = kv->next;
kv->method->free(kv, 1);
}
- return BUNDLE_ERROR_NONE;
+ return BUNDLE_ERROR_NONE;
}
-const char *
-bundle_get_val(bundle *b, const char *key)
+const char *bundle_get_val(bundle *b, const char *key)
{
char *val = NULL;
- int ret = 0;
+ int ret = BUNDLE_ERROR_NONE;
ret = bundle_get_str(b, key, &val);
set_last_result(ret);
return val;
-
}
/**
* @brief used by bundle_get_count() API, to count number of items in a bundle
*/
-static void
-_bundle_get_count_iter(const char *k, const int type,
+static void _bundle_get_count_iter(const char *k, const int type,
const bundle_keyval_t *kv, void *user_data)
{
int *count = (int *)user_data;
*count += 1;
}
-int
-bundle_get_count(bundle *b)
+int bundle_get_count(bundle *b)
{
int count = 0;
- if (NULL == b)
+
+ if (b == NULL)
return count;
bundle_foreach(b, _bundle_get_count_iter, &count);
return count;
}
-void
-bundle_iterate(bundle *b, bundle_iterate_cb_t callback, void *data)
+void bundle_iterate(bundle *b, bundle_iterate_cb_t callback, void *data)
{
keyval_t *kv;
- if (NULL == b || NULL == callback) {
+ if (b == NULL || callback == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return;
}
kv = b->kv_head;
- while (NULL != kv) {
+ while (kv) {
callback(kv->key, kv->val, data);
kv = kv->next;
}
+
set_last_result(BUNDLE_ERROR_NONE);
}
-void
-bundle_foreach(bundle *b, bundle_iterator_t iter, void *user_data)
+void bundle_foreach(bundle *b, bundle_iterator_t iter, void *user_data)
{
- if (NULL == b || NULL == iter) {
+ keyval_t *kv;
+
+ if (b == NULL || iter == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
- return; /*TC_FIX if b=NULL- error handling */
+ return; /* TC_FIX if b = NULL- error handling */
}
- keyval_t *kv = b->kv_head;
- while (NULL != kv) {
+ kv = b->kv_head;
+ while (kv) {
iter(kv->key, kv->type, kv, user_data);
kv = kv->next;
}
+
set_last_result(BUNDLE_ERROR_NONE);
}
/* keyval functions */
-int
-bundle_keyval_get_type(bundle_keyval_t *kv)
+int bundle_keyval_get_type(bundle_keyval_t *kv)
{
- if (NULL == kv) {
+ if (kv == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return -1;
}
return kv->type;
}
-int
-bundle_keyval_type_is_array(bundle_keyval_t *kv)
+int bundle_keyval_type_is_array(bundle_keyval_t *kv)
{
- if (NULL == kv) {
+ if (kv == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return -1;
}
return keyval_type_is_array(kv->type);
}
-int
-bundle_keyval_type_is_measurable(bundle_keyval_t *kv)
+int bundle_keyval_type_is_measurable(bundle_keyval_t *kv)
{
- if (NULL == kv) {
+ if (kv == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return -1;
}
return keyval_type_is_measurable(kv->type);
}
-int
-bundle_keyval_get_basic_val(bundle_keyval_t *kv, void **val, size_t *size)
+int bundle_keyval_get_basic_val(bundle_keyval_t *kv, void **val, size_t *size)
{
return keyval_get_data(kv, NULL, val, size);
}
-int
-bundle_keyval_get_array_val(bundle_keyval_t *kv, void ***array_val,
+int bundle_keyval_get_array_val(bundle_keyval_t *kv, void ***array_val,
unsigned int *array_len, size_t **array_item_size)
{
return keyval_array_get_data((keyval_array_t *)kv, NULL,
array_val, array_len, array_item_size);
}
-
-/*static void
-_iter_do_bundle_dup(const char *key, const void *val, const int type, const size_t size, const unsigned int len, void *user_data)
+bundle *bundle_dup(bundle *b_from)
{
- //int r;
- bundle *b_to = (bundle *)user_data;
-
- _bundle_add_kv(b_to, key, val, size, type, len);
-
-}
-*/
-bundle *
-bundle_dup(bundle *b_from)
-{
- bundle *b_to = NULL;
+ bundle *b_to;
+ keyval_t *kv_from;
+ keyval_t *kv_to;
+ keyval_array_t *kva_from;
int i;
- if (NULL == b_from) {
+ if (b_from == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
+
b_to = bundle_create();
- if (NULL == b_to)
+ if (b_to == NULL)
return NULL;
- keyval_t *kv_from = b_from->kv_head;
- keyval_t *kv_to = NULL;
+ kv_from = b_from->kv_head;
while (kv_from != NULL) {
if (keyval_type_is_array(kv_from->type)) {
- keyval_array_t *kva_from = (keyval_array_t *)kv_from;
- kv_to = (keyval_t *) keyval_array_new(NULL, kv_from->key,
+ kva_from = (keyval_array_t *)kv_from;
+ kv_to = (keyval_t *)keyval_array_new(NULL, kv_from->key,
kv_from->type, NULL, kva_from->len);
if (!kv_to)
- goto ERR_CLEANUP;
+ goto err;
+
for (i = 0; i < kva_from->len; i++) {
if (((keyval_array_t *)kv_from)->array_val[i]) {
- keyval_array_set_element((keyval_array_t *)kv_to, i,
+ keyval_array_set_element(
+ (keyval_array_t *)kv_to, i,
((keyval_array_t *)kv_from)->array_val[i],
((keyval_array_t *)kv_from)->array_element_size[i]);
}
}
+
_bundle_append_kv(b_to, kv_to);
} else {
- if (_bundle_add_kv(b_to, kv_from->key, kv_from->val,
- kv_from->size, kv_from->type, 0))
- goto ERR_CLEANUP;
+ if (_bundle_add_kv(b_to, kv_from->key,
+ kv_from->val, kv_from->size, kv_from->type, 0))
+ goto err;
}
kv_from = kv_from->next;
}
+
return b_to;
-ERR_CLEANUP:
+err:
bundle_free(b_to);
return NULL;
}
-
-int
-bundle_encode(bundle *b, bundle_raw **r, int *len)
+int bundle_encode(bundle *b, bundle_raw **r, int *len)
{
keyval_t *kv;
unsigned char *m;
unsigned char *byte;
size_t byte_len;
gchar *chksum_val;
+ size_t msize = 0;
- if (NULL == b || NULL == r || NULL == len)
+ if (b == NULL || r == NULL || len == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
/* 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))
+ if (unlikely(m == NULL))
return BUNDLE_ERROR_OUT_OF_MEMORY;
- p_m = m + CHECKSUM_LENGTH; /* temporary pointer */
+ p_m = m + CHECKSUM_LENGTH; /* temporary pointer */
kv = b->kv_head;
while (kv != NULL) {
free(byte);
}
- /*compute checksum from the data*/
+ /* compute checksum from the data */
chksum_val = g_compute_checksum_for_string(G_CHECKSUM_MD5,
- (const char *)(m+CHECKSUM_LENGTH), msize);
- /*prefix checksum to the data */
+ (const char *)(m + CHECKSUM_LENGTH), msize);
+ /* prefix checksum to the data */
memcpy(m, chksum_val, CHECKSUM_LENGTH);
- if (NULL != r) {
- /*base64 encode for whole string checksum and data*/
+ if (r) {
+ /* base64 encode for whole string checksum and data */
*r = (unsigned char *)g_base64_encode(m, msize + CHECKSUM_LENGTH);
- if (NULL != len)
+ if (len)
*len = strlen((char *)*r);
}
free(m);
- g_free(chksum_val);/*free checksum string */
+ g_free(chksum_val); /* free checksum string */
return BUNDLE_ERROR_NONE;
}
-int
-bundle_free_encoded_rawdata(bundle_raw **r)
+int bundle_free_encoded_rawdata(bundle_raw **r)
{
if (!*r)
- return BUNDLE_ERROR_INVALID_PARAMETER;
- /*TC_FIX - double free sigabrt handling */
+ return BUNDLE_ERROR_INVALID_PARAMETER; /* TC_FIX - double free sigabrt handling */
free(*r);
*r = NULL;
return BUNDLE_ERROR_NONE;
}
-bundle *
-bundle_decode(const bundle_raw *r, const int data_size)
+bundle *bundle_decode(const bundle_raw *r, const int data_size)
{
bundle *b;
bundle_raw *p_r;
unsigned int d_len;
char *extract_cksum;
gchar *compute_cksum;
+ size_t bytes_read;
+ keyval_t *kv;
+ int type;
- if (NULL == r) {
+ if (r == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
- extract_cksum = calloc(CHECKSUM_LENGTH+1, sizeof(char));
- if (unlikely(NULL == extract_cksum)) {
+ extract_cksum = calloc(CHECKSUM_LENGTH + 1, sizeof(char));
+ if (unlikely(extract_cksum == NULL)) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
- /* base 64 decode of input string
+ /*
+ * base 64 decode of input string
* Since base64 encodes 3 bytes in 4 chars (+3 may be needed in case of non-zero state)
* refer to: https://developer.gnome.org/glib/stable/glib-Base64-Encoding.html#g-base64-decode-step
*/
d_str = malloc((data_size / 4) * 3 + 3);
- if (unlikely(NULL == d_str)) {
+ if (unlikely(d_str == NULL)) {
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
free(extract_cksum);
return NULL;
return NULL;
}
- /*extract checksum from the received string */
+ /* extract checksum from the received string */
strncpy(extract_cksum, (const char *)d_str, CHECKSUM_LENGTH);
/* compute checksum for the data */
compute_cksum = g_compute_checksum_for_string(G_CHECKSUM_MD5,
- (const char *)(d_str+CHECKSUM_LENGTH), d_len_raw-CHECKSUM_LENGTH);
- /* compare checksum values- extracted from the received
+ (const char *)(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) {
}
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);
-
+ 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);
+ bytes_read = keyval_array_decode(p_r,
+ (keyval_array_t **) &kv);
else
bytes_read = keyval_decode(p_r, &kv);
int idx;
};
-int
-bundle_encode_raw(bundle *b, bundle_raw **r, int *len)
+int bundle_encode_raw(bundle *b, bundle_raw **r, int *len)
{
keyval_t *kv = NULL;
unsigned char *m = NULL;
unsigned char *byte = NULL;
size_t byte_len;
gchar *chksum_val = NULL;
+ size_t msize = 0;
- if (NULL == b || NULL == r)
+ if (b == NULL || r == NULL)
return BUNDLE_ERROR_INVALID_PARAMETER;
/* 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))
+ if (unlikely(m == NULL))
return BUNDLE_ERROR_OUT_OF_MEMORY;
p_m = m + CHECKSUM_LENGTH; /* temporary pointer */
free(byte);
}
- /*compute checksum from the data*/
+ /* compute checksum from the data */
chksum_val = g_compute_checksum_for_string(G_CHECKSUM_MD5,
- (const char *)(m+CHECKSUM_LENGTH), msize);
- /*prefix checksum to the data */
+ (const char *)(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 */
+ g_free(chksum_val); /* free checksum string */
return BUNDLE_ERROR_NONE;
}
-bundle *
-bundle_decode_raw(const bundle_raw *r, const int data_size)
+bundle *bundle_decode_raw(const bundle_raw *r, const int data_size)
{
bundle *b = NULL;
bundle_raw *p_r = NULL;
unsigned int d_len_raw;
unsigned char *d_r = NULL;
unsigned int d_len;
- char *extract_cksum = NULL;
+ char *extract_cksum;
gchar *compute_cksum = NULL;
+ size_t bytes_read;
+ keyval_t *kv;
+ int type;
- if (NULL == r) {
+ if (r == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return NULL;
}
extract_cksum = calloc(CHECKSUM_LENGTH + 1, sizeof(char));
- if (unlikely(NULL == extract_cksum)) {
+ if (unlikely(extract_cksum == NULL)) {
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return NULL;
}
strncpy(extract_cksum, (const char *)d_str, CHECKSUM_LENGTH);
/* compute checksum for the data */
compute_cksum = g_compute_checksum_for_string(G_CHECKSUM_MD5,
- (const char *)(d_str+CHECKSUM_LENGTH),
- d_len_raw-CHECKSUM_LENGTH);
- /*compare checksum values- extracted from the received
+ (const char *)(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) {
}
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);
-
+ 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);
+ bytes_read = keyval_array_decode(p_r,
+ (keyval_array_t **) &kv);
else
bytes_read = keyval_decode(p_r, &kv);
free(extract_cksum);
g_free(compute_cksum);
-
set_last_result(BUNDLE_ERROR_NONE);
+
return b;
}
-
-void
-_iter_export_to_argv(const char *key, const int type, const keyval_t *kv,
+void _iter_export_to_argv(const char *key, const int type, const keyval_t *kv,
void *user_data)
{
struct _argv_idx *vi = (struct _argv_idx *)user_data;
-
- vi->argv[vi->idx] = (char *)key;
-
- unsigned char *byte = NULL, *encoded_byte = NULL;
+ unsigned char *byte = NULL;
+ unsigned char *encoded_byte = NULL;
size_t byte_len = 0;
- if (0 == kv->method->encode((struct keyval_t *)kv, &byte, &byte_len)) {
+ vi->argv[vi->idx] = (char *)key;
+ if (kv->method->encode((struct keyval_t *)kv, &byte, &byte_len) == 0) {
/* TODO: encode FAILED! */
- BUNDLE_EXCEPTION_PRINT("bundle: FAILED to encode keyval: %s\n", key);
+ BUNDLE_EXCEPTION_PRINT("bundle: FAILED to encode keyval: %s\n",
+ key);
return;
}
encoded_byte = (unsigned char *)g_base64_encode(byte, byte_len);
- if (NULL == encoded_byte) {
+ if (encoded_byte == NULL) {
BUNDLE_EXCEPTION_PRINT("bundle: failed to encode byte\n");
return;
}
free(byte);
}
-int
-bundle_export_to_argv(bundle *b, char ***argv)
+int bundle_export_to_argv(bundle *b, char ***argv)
{
- int argc, item_count;
+ struct _argv_idx vi;
+ int argc;
+ int item_count;
if (b == NULL || argv == NULL) {
set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
return -1;
}
- struct _argv_idx vi;
vi.argc = argc;
vi.argv = *argv;
vi.idx = 2; /* start from index 2*/
vi.argv[1] = TAG_IMPORT_EXPORT_CHECK; /* set argv[1] as encoded*/
- /*BUNDLE_LOG_PRINT("\nargument 1 is %s",vi.argv[1]);*/
+ /* BUNDLE_LOG_PRINT("\nargument 1 is %s",vi.argv[1]); */
bundle_foreach(b, _iter_export_to_argv, &vi);
int bundle_free_exported_argv(int argc, char ***argv)
{
+ int i;
+
if (argc < 1)
return BUNDLE_ERROR_INVALID_PARAMETER;
if (!*argv || argc < 2)
return BUNDLE_ERROR_INVALID_PARAMETER;
- int i;
- for (i = 3; i < argc; i += 2) {
- free((*argv)[i]);
- /* need to free value from g_base64_encode() */
- }
-
+ for (i = 3; i < argc; i += 2)
+ free((*argv)[i]); /* need to free value from g_base64_encode() */
free(*argv);
*argv = NULL;
+
return BUNDLE_ERROR_NONE;
}
}
if (!argv[1] || strcmp(argv[1], TAG_IMPORT_EXPORT_CHECK)) {
- /*start idx from one as argv[1] is user given argument*/
+ /* start idx from one as argv[1] is user given argument */
for (idx = 1; idx + 1 < argc; idx = idx + 2)
bundle_add(b, argv[idx], argv[idx + 1]);
/* base64_decode */
byte = g_base64_decode(encoded_byte, &byte_size);
- if (NULL == byte) {
+ if (byte == NULL) {
if (b)
set_last_result(bundle_free(b));
return NULL;
type = keyval_get_type_from_encoded_byte(byte);
if (keyval_type_is_array(type)) {
- if (0 == keyval_array_decode(byte, &kva)) {
- /* TODO: error! */
+ if (keyval_array_decode(byte, &kva) == 0) /* TODO: error! */
BUNDLE_EXCEPTION_PRINT("Unable to Decode array\n");
- }
kv = (keyval_t *)kva;
} else {
- if (0 == keyval_decode(byte, &kv)) {
- /* TODO: error! */
+ if (keyval_decode(byte, &kv) == 0) /* TODO: error! */
BUNDLE_EXCEPTION_PRINT("Unable to Decode\n");
- }
}
_bundle_append_kv(b, kv);
return b;
}
-
- int
-bundle_get_type(bundle *b, const char *key)
+int bundle_get_type(bundle *b, const char *key)
{
keyval_t *kv = _bundle_find_kv(b, key);
- if (kv)
+
+ if (kv) {
return kv->type;
- else {
+ } else {
set_last_result(BUNDLE_ERROR_KEY_NOT_AVAILABLE);
return BUNDLE_TYPE_NONE;
}
}
-/** Get length of an array
+/*
+ * Get length of an array
*/
- unsigned int
-bundle_get_array_len(bundle *b, const char *key)
+unsigned int bundle_get_array_len(bundle *b, const char *key)
{
return BUNDLE_ERROR_NONE;
}
-/** Get size of an item in byte, of given pointer
+/*
+ * Get size of an item in byte, of given pointer
*/
- size_t
-bundle_get_array_val_size(bundle *b, const char *key, const void *val_ptr)
+size_t bundle_get_array_val_size(bundle *b, const char *key,
+ const void *val_ptr)
{
return BUNDLE_ERROR_NONE;
}
-static int
-bundle_set_array_val(bundle *b, const char *key, const int type,
+
+static int bundle_set_array_val(bundle *b, const char *key, const int type,
const unsigned int idx, const void *val, const size_t size)
{
- keyval_t *kv = _bundle_find_kv(b, key);
- if (NULL == kv)
+ keyval_t *kv;
+ keyval_array_t *kva;
+
+ kv = _bundle_find_kv(b, key);
+ if (kv == NULL)
return get_last_result();
if (type != kv->type)
if (!keyval_type_is_array(kv->type))
return BUNDLE_ERROR_INVALID_PARAMETER;
- keyval_array_t *kva = (keyval_array_t *)kv;
-
+ kva = (keyval_array_t *)kv;
if (!keyval_array_is_idx_valid(kva, idx))
return BUNDLE_ERROR_INVALID_PARAMETER;
return keyval_array_set_element(kva, idx, (void *)val, size);
}
-
- int
-bundle_add_str_array(bundle *b, const char *key, const char **str_array,
+int bundle_add_str_array(bundle *b, const char *key, const char **str_array,
const int len)
{
return _bundle_add_kv(b, key, str_array, 0, BUNDLE_TYPE_STR_ARRAY, len);
}
-
- int
-bundle_get_val_array(bundle *b, const char *key, char ***str_array, int *len)
+int bundle_get_val_array(bundle *b, const char *key, char ***str_array,
+ int *len)
{
return _bundle_get_val(b, key, BUNDLE_TYPE_STR_ARRAY,
(void **)str_array, NULL, (unsigned int *)len, NULL);
return arr_val;
}
-
- int
-bundle_compare(bundle *b1, bundle *b2)
+int bundle_compare(bundle *b1, bundle *b2)
{
+ keyval_t *kv1;
+ keyval_t *kv2;
+
if (!b1 || !b2)
return -1;
- keyval_t *kv1, *kv2;
-
if (bundle_get_count(b1) != bundle_get_count(b2))
return 1;
+
for (kv1 = b1->kv_head; kv1 != NULL; kv1 = kv1->next) {
kv2 = _bundle_find_kv(b2, kv1->key);
if (!kv2)
if (kv1->method->compare(kv1, kv2))
return 1;
}
+
return 0;
}
-
-
- int
-bundle_set_str_array_element(bundle *b, const char *key,
+int bundle_set_str_array_element(bundle *b, const char *key,
const unsigned int idx, const char *val)
{
if (!val)
return BUNDLE_ERROR_INVALID_PARAMETER;
return bundle_set_array_val(b, key, BUNDLE_TYPE_STR_ARRAY,
- idx, val, strlen(val)+1);
+ idx, val, strlen(val) + 1);
}
-
- int
-bundle_add_byte(bundle *b, const char *key, const void *byte,
+int bundle_add_byte(bundle *b, const char *key, const void *byte,
const size_t size)
{
return _bundle_add_kv(b, key, byte, size, BUNDLE_TYPE_BYTE, 1);
}
- int
-bundle_get_byte(bundle *b, const char *key, void **byte, size_t *size)
+int bundle_get_byte(bundle *b, const char *key, void **byte, size_t *size)
{
- return _bundle_get_val(b, key, BUNDLE_TYPE_BYTE, (void **) byte,
+ return _bundle_get_val(b, key, BUNDLE_TYPE_BYTE, (void **)byte,
size, NULL, NULL);
}
- int
-bundle_add_byte_array(bundle *b, const char *key, void **byte_array,
+int bundle_add_byte_array(bundle *b, const char *key, void **byte_array,
const unsigned int len)
{
- return _bundle_add_kv(b, key, byte_array, 0, BUNDLE_TYPE_BYTE_ARRAY, len);
+ return _bundle_add_kv(b, key, byte_array, 0,
+ BUNDLE_TYPE_BYTE_ARRAY, len);
}
- int
-bundle_get_byte_array(bundle *b, const char *key, void ***byte_array,
+int bundle_get_byte_array(bundle *b, const char *key, void ***byte_array,
unsigned int *len, unsigned int **array_element_size)
{
return _bundle_get_val(b, key, BUNDLE_TYPE_BYTE_ARRAY,
(void **)byte_array, NULL, len, array_element_size);
}
-
- int
-bundle_set_byte_array_element(bundle *b, const char *key,
+int bundle_set_byte_array_element(bundle *b, const char *key,
const unsigned int idx, const void *val, const size_t size)
{
return bundle_set_array_val(b, key, BUNDLE_TYPE_BYTE_ARRAY,
idx, val, size);
}
-
+/*
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
#include <stdlib.h>
#include <string.h>
#include <glib.h>
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
/**
* keyval.c
* Implementation of keyval object
*/
+#include <stdlib.h>
+
#include "keyval_type.h"
#include "keyval.h"
#include "bundle_log.h"
#include "bundle.h"
-#include <stdlib.h>
static keyval_method_collection_t method = {
keyval_free,
keyval_decode
};
-keyval_t *
-keyval_new(keyval_t *kv, const char *key, const int type, const void *val,
- const size_t size)
+keyval_t *keyval_new(keyval_t *kv, const char *key,
+ const int type, const void *val, const size_t size)
{
- int must_free_obj;
- must_free_obj = kv ? 0 : 1;
+ int must_free_obj = kv ? 0 : 1;
if (!kv) {
kv = calloc(1, sizeof(keyval_t));
keyval_free(kv, must_free_obj);
return NULL;
}
+
kv->key = strdup(key);
if (!kv->key) {
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return kv;
}
-void
-keyval_free(keyval_t *kv, int do_free_object)
+void keyval_free(keyval_t *kv, int do_free_object)
{
- if (NULL == kv)
+ if (kv == NULL)
return;
if (kv->key) {
kv->key = NULL;
}
- if (NULL != kv->val) {
+ if (kv->val != NULL) {
free(kv->val);
kv->val = NULL;
}
return;
}
-int
-keyval_get_data(keyval_t *kv, int *type, void **val, size_t *size)
+int keyval_get_data(keyval_t *kv, int *type, void **val, size_t *size)
{
if (!kv)
return BUNDLE_ERROR_INVALID_PARAMETER;
+
if (keyval_type_is_array(kv->type))
return BUNDLE_ERROR_INVALID_PARAMETER;
return 0;
}
-int
-keyval_compare(keyval_t *kv1, keyval_t *kv2)
+int keyval_compare(keyval_t *kv1, keyval_t *kv2)
{
if (!kv1 || !kv2)
return -1;
- if (0 != strcmp(kv1->key, kv2->key))
+ if (strcmp(kv1->key, kv2->key) != 0)
return 1;
if (kv1->type != kv2->type)
return 1;
return 0;
if (kv1->val == NULL || kv2->val == NULL)
return 1;
- if (0 != memcmp(kv1->val, kv2->val, kv1->size))
+ if (memcmp(kv1->val, kv2->val, kv1->size) != 0)
return 1;
return 0;
}
-size_t
-keyval_get_encoded_size(keyval_t *kv)
+size_t keyval_get_encoded_size(keyval_t *kv)
{
+ size_t encoded_size;
+
if (!kv)
return 0;
- size_t encoded_size
- = sizeof(size_t) /* total size */
+ encoded_size = sizeof(size_t) /* total size */
+ sizeof(int) /* type */
+ sizeof(size_t) /* key size */
+ strlen(kv->key) + 1 /* key (+ null byte) */
* @param[out] byte_len
* @return byte_len
*/
-size_t
-keyval_encode(keyval_t *kv, unsigned char **byte, size_t *byte_len)
+size_t keyval_encode(keyval_t *kv, unsigned char **byte, size_t *byte_len)
{
static const size_t sz_type = sizeof(int);
static const size_t sz_keysize = sizeof(size_t);
size_t sz_key = strlen(kv->key) + 1;
static const size_t sz_size = sizeof(size_t);
size_t sz_val = kv->size;
+ unsigned char *p;
*byte_len = keyval_get_encoded_size(kv);
if (!*byte)
return 0;
- unsigned char *p = *byte;
-
- memcpy(p, byte_len, sizeof(size_t)); p += sizeof(size_t);
- memcpy(p, &(kv->type), sz_type); p += sz_type;
- memcpy(p, &sz_key, sz_keysize); p += sz_keysize;
- memcpy(p, kv->key, sz_key); p += sz_key;
- memcpy(p, &(kv->size), sz_size); p += sz_size;
- memcpy(p, kv->val, sz_val); p += sz_val;
+ p = *byte;
+
+ memcpy(p, byte_len, sizeof(size_t));
+ p += sizeof(size_t);
+ memcpy(p, &(kv->type), sz_type);
+ p += sz_type;
+ memcpy(p, &sz_key, sz_keysize);
+ p += sz_keysize;
+ memcpy(p, kv->key, sz_key);
+ p += sz_key;
+ memcpy(p, &(kv->size), sz_size);
+ p += sz_size;
+ memcpy(p, kv->val, sz_val);
+ p += sz_val;
return *byte_len;
}
* If kv is not NULL, given kv is used. (No new kv is created.)
* @return Number of bytes read from byte.
*/
-size_t
-keyval_decode(unsigned char *byte, keyval_t **kv)
+size_t keyval_decode(unsigned char *byte, keyval_t **kv)
{
static const size_t sz_byte_len = sizeof(size_t);
static const size_t sz_type = sizeof(int);
static const size_t sz_keysize = sizeof(size_t);
static const size_t sz_size = sizeof(size_t);
-
+ size_t byte_len;
+ int type;
+ size_t keysize;
+ char *key;
+ size_t size;
+ void *val;
unsigned char *p = byte;
- size_t byte_len = *((size_t *)p); p += sz_byte_len;
- int type = *((int *)p); p += sz_type;
- size_t keysize = *((size_t *)p); p += sz_keysize;
- char *key = (char *)p; p += keysize;
- size_t size = *((size_t *)p); p += sz_size;
- void *val = (void *)p; p += size;
+ byte_len = *((size_t *)p);
+ p += sz_byte_len;
+ type = *((int *)p);
+ p += sz_type;
+ keysize = *((size_t *)p);
+ p += sz_keysize;
+ key = (char *)p;
+ p += keysize;
+ size = *((size_t *)p);
+ p += sz_size;
+ val = (void *)p;
+ p += size;
if (kv)
*kv = keyval_new(*kv, key, type, val, size);
return byte_len;
}
-
-int
-keyval_get_type_from_encoded_byte(unsigned char *byte)
+int keyval_get_type_from_encoded_byte(unsigned char *byte)
{
static const size_t sz_byte_len = sizeof(size_t);
-
unsigned char *p = byte;
+ int type;
+
p += sz_byte_len;
- int type = *((int *)p);
+ type = *((int *)p);
+
return type;
}
-
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
-
/**
* keyval_array.c
* Implementation of keyval_array object
*/
+#include <stdlib.h>
+#include <string.h>
+
#include "keyval_array.h"
#include "keyval.h"
#include "keyval_type.h"
#include "bundle.h"
#include "bundle_log.h"
-#include <stdlib.h>
-#include <string.h>
-
-
static keyval_method_collection_t method = {
(keyval_method_free_t) keyval_array_free,
(keyval_method_compare_t) keyval_array_compare,
(keyval_method_decode_t) keyval_array_decode
};
-keyval_array_t *
-keyval_array_new(keyval_array_t *kva, const char *key, const int type,
- const void **array_val, const unsigned int len)
+keyval_array_t *keyval_array_new(keyval_array_t *kva, const char *key,
+ const int type, const void **array_val, const unsigned int len)
{
- int must_free_obj;
- must_free_obj = kva ? 0 : 1;
+ int must_free_obj = kva ? 0 : 1;
+ keyval_t *kv;
if (!kva) {
kva = calloc(1, sizeof(keyval_array_t));
- if (unlikely(NULL == kva)) {
+ if (unlikely(kva == NULL)) {
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return NULL;
}
}
/* keyval setting */
- keyval_t *kv = keyval_new((keyval_t *)kva, key, type, NULL, 0);
- if (unlikely(NULL == kv)) {
+ kv = keyval_new((keyval_t *)kva, key, type, NULL, 0);
+ if (unlikely(kv == NULL)) {
set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
return NULL;
}
kv->type = kv->type | BUNDLE_TYPE_ARRAY;
-
kva->len = len;
/* Set array value, if exist */
(void **)array_val,
len,
keyval_type_get_measure_size_func(type))
- ) {
+ ) {
keyval_array_free(kva, 1);
return NULL;
}
return kva;
}
-void
-keyval_array_free(keyval_array_t *kva, int do_free_object)
+void keyval_array_free(keyval_array_t *kva, int do_free_object)
{
+ int i;
+
if (!kva)
return;
/* free keyval_array elements */
free(kva->array_element_size);
- int i;
for (i = 0; i < kva->len; i++) {
if (kva->array_val[i])
free(kva->array_val[i]);
free(kva);
}
-int
-keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2)
+int keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2)
{
- keyval_t *kv1, *kv2;
+ keyval_t *kv1;
+ keyval_t *kv2;
+ int i;
+
if (!kva1 || !kva2)
return -1;
kv1 = (keyval_t *)kva1;
kv2 = (keyval_t *)kva2;
- if (0 != strcmp(kv1->key, kv2->key))
+ if (strcmp(kv1->key, kv2->key) != 0)
return 1;
if (kv1->type != kv2->type)
return 1;
if (kva1->len != kva2->len)
return 1;
- int i;
+
for (i = 0; i < kva1->len; i++) {
if (kva1->array_val[i] == NULL && kva2->array_val[i] == NULL)
continue;
if (kva1->array_val[i] == NULL || kva2->array_val[i] == NULL)
return 1;
- if (0 != memcmp(kva1->array_val[i], kva2->array_val[i],
- kva1->array_element_size[i]))
+ if (memcmp(kva1->array_val[i], kva2->array_val[i],
+ kva1->array_element_size[i]) != 0)
return 1;
}
return 0;
}
-int
-keyval_array_copy_array(keyval_array_t *kva, void **array_val,
+int keyval_array_copy_array(keyval_array_t *kva, void **array_val,
unsigned int array_len, size_t (*measure_val_len)(void *val))
{
keyval_t *kv = (keyval_t *)kva;
+ keyval_type_measure_size_func_t measure_size;
int i;
/* Get measure_size function of the value type */
- keyval_type_measure_size_func_t measure_size =
- keyval_type_get_measure_size_func(kv->type);
+ measure_size = keyval_type_get_measure_size_func(kv->type);
if (!measure_size)
return -1;
return -1;
}
-int
-keyval_array_is_idx_valid(keyval_array_t *kva, int idx)
+int keyval_array_is_idx_valid(keyval_array_t *kva, int idx)
{
if (kva && kva->len > idx && 0 <= idx)
return 1;
return 0;
}
-int
-keyval_array_set_element(keyval_array_t *kva, int idx, void *val, size_t size)
+int keyval_array_set_element(keyval_array_t *kva, int idx, void *val, size_t size)
{
/* An element is already exist in the idx! */
if (kva->array_val[idx]) {
return BUNDLE_ERROR_NONE;
}
-int
-keyval_array_get_data(keyval_array_t *kva, int *type,
- void ***array_val, unsigned int *len, size_t **array_element_size)
+int keyval_array_get_data(keyval_array_t *kva, int *type, void ***array_val,
+ unsigned int *len, size_t **array_element_size)
{
+ keyval_t *kv;
+
if (!kva)
return BUNDLE_ERROR_INVALID_PARAMETER;
- keyval_t *kv = (keyval_t *)kva;
+
+ kv = (keyval_t *)kva;
if (!keyval_type_is_array(kv->type))
return BUNDLE_ERROR_INVALID_PARAMETER;
return BUNDLE_ERROR_NONE;
}
-size_t
-keyval_array_get_encoded_size(keyval_array_t *kva)
+size_t keyval_array_get_encoded_size(keyval_array_t *kva)
{
size_t sum_array_element_size = 0;
int i;
+ size_t encoded_size;
+
for (i = 0; i < kva->len; i++)
sum_array_element_size += kva->array_element_size[i];
- size_t encoded_size
- = sizeof(size_t) /* total size */
+ encoded_size = sizeof(size_t) /* total size */
+ sizeof(int) /* type */
+ sizeof(size_t) /* keysize */
+ strlen(((keyval_t *)kva)->key) + 1 /* key (+ null byte) */
+ sizeof(int) /* len */
- + kva->len * sizeof(size_t) /* array_element_size */
+ + kva->len * sizeof(size_t) /* array_element_size */
+ sum_array_element_size;
return encoded_size;
}
-size_t
-keyval_array_encode(keyval_array_t *kva, void **byte, size_t *byte_len)
+size_t keyval_array_encode(keyval_array_t *kva, void **byte, size_t *byte_len)
{
keyval_t *kv = (keyval_t *)kva;
int i;
-
/* Calculate memory size for kva */
static const size_t sz_type = sizeof(int);
static const size_t sz_keysize = sizeof(size_t);
static const unsigned int sz_len = sizeof(int);
size_t sz_array_element_size = kva->len * sizeof(size_t);
size_t sz_array_val = 0;
+ unsigned char *p;
+
for (i = 0; i < kva->len; i++)
sz_array_val += kva->array_element_size[i];
return 0;
/* Copy data */
- unsigned char *p = *byte;
-
- memcpy(p, byte_len, sizeof(size_t)); p += sizeof(size_t);
- memcpy(p, &(kv->type), sz_type); p += sz_type;
- memcpy(p, &sz_key, sz_keysize); p += sz_keysize;
- memcpy(p, kv->key, sz_key); p += sz_key;
- memcpy(p, &(kva->len), sz_len); p += sz_len;
+ p = *byte;
+
+ memcpy(p, byte_len, sizeof(size_t));
+ p += sizeof(size_t);
+ memcpy(p, &(kv->type), sz_type);
+ p += sz_type;
+ memcpy(p, &sz_key, sz_keysize);
+ p += sz_keysize;
+ memcpy(p, kv->key, sz_key);
+ p += sz_key;
+ memcpy(p, &(kva->len), sz_len);
+ p += sz_len;
memcpy(p, kva->array_element_size, sz_array_element_size);
p += sz_array_element_size;
+
for (i = 0; i < kva->len; i++) {
memcpy(p, kva->array_val[i], kva->array_element_size[i]);
p += kva->array_element_size[i];
return *byte_len;
}
-size_t
-keyval_array_decode(void *byte, keyval_array_t **kva)
+size_t keyval_array_decode(void *byte, keyval_array_t **kva)
{
static const size_t sz_byte_len = sizeof(size_t);
static const size_t sz_type = sizeof(int);
static const size_t sz_keysize = sizeof(size_t);
static const int sz_len = sizeof(unsigned int);
-
unsigned char *p = byte;
+ size_t byte_len;
+ int type;
+ size_t keysize;
+ char *key;
+ unsigned int len;
+ size_t *array_element_size;
+ void *array_val;
+ int i;
+ size_t elem_size = 0;
/* Get data */
- size_t byte_len = *((size_t *)p); p += sz_byte_len;
- int type = *((int *)p); p += sz_type;
- size_t keysize = *((size_t *)p); p += sz_keysize;
- char *key = (char *)p; p += keysize;
- unsigned int len = *((unsigned int *)p); p += sz_len;
- size_t *array_element_size = (size_t *) p; p += sizeof(size_t) * len;
- void *array_val = (void *)p;
+ byte_len = *((size_t *)p);
+ p += sz_byte_len;
+ type = *((int *)p);
+ p += sz_type;
+ keysize = *((size_t *)p);
+ p += sz_keysize;
+ key = (char *)p;
+ p += keysize;
+ len = *((unsigned int *)p);
+ p += sz_len;
+ array_element_size = (size_t *)p;
+ p += sizeof(size_t) * len;
+ array_val = (void *)p;
*kva = keyval_array_new(NULL, key, type, NULL, len);
- int i;
- size_t elem_size = 0;
for (i = 0; i < len; i++) {
- elem_size += i ? array_element_size[i-1] : 0;
+ elem_size += i ? array_element_size[i - 1] : 0;
if (keyval_array_set_element(*kva, i,
- (void *)(array_val+elem_size),
+ (void *)(array_val + elem_size),
array_element_size[i])) {
keyval_array_free(*kva, 1);
*kva = NULL;
return byte_len;
}
-
/*
- * bundle
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>
+ * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- *
*/
+#include <stddef.h>
#include "keyval_type.h"
#include "bundle_log.h"
-#include <stddef.h>
-void
-keyval_type_init(void)
+void keyval_type_init(void)
{
static int is_done;
is_done = 1;
}
-int
-keyval_type_is_array(int type)
+int keyval_type_is_array(int type)
{
if (type & BUNDLE_TYPE_ARRAY)
return 1;
return 0;
}
-int
-keyval_type_is_measurable(int type)
+int keyval_type_is_measurable(int type)
{
if (type & BUNDLE_TYPE_MEASURABLE)
return 1;
return 0;
}
-keyval_type_measure_size_func_t
-keyval_type_get_measure_size_func(int type)
+keyval_type_measure_size_func_t keyval_type_get_measure_size_func(int type)
{
switch (type) {
case BUNDLE_TYPE_STR:
return NULL;
}
-size_t
-keyval_type_measure_size_str(void *val)
+size_t keyval_type_measure_size_str(void *val)
{
if (!val)
return 0;
return strlen((char *)val) + 1;
}
-
projects / platform / core / base / bundle.git / commitdiff