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.
19 * Implementation of keyval object
25 #include "keyval_type.h"
27 #include "bundle_log.h"
30 static keyval_method_collection_t method = {
33 keyval_get_encoded_size,
38 keyval_t *keyval_new(keyval_t *kv, const char *key,
39 const int type, const void *val, const size_t size)
41 int must_free_obj = kv ? 0 : 1;
45 kv = calloc(1, sizeof(keyval_t));
47 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
53 keyval_free(kv, must_free_obj);
57 kv->key = strdup(key);
59 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
60 keyval_free(kv, must_free_obj);
68 kv->val = calloc(1, size);
70 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
71 keyval_free(kv, must_free_obj);
75 memcpy(kv->val, val, size);
76 if (type == BUNDLE_TYPE_STR) {
77 str = (char *)kv->val;
78 if (str[size - 1] != '\0')
89 void keyval_free(keyval_t *kv, int do_free_object)
99 if (kv->val != NULL) {
110 int keyval_get_data(keyval_t *kv, int *type, void **val, size_t *size)
113 return BUNDLE_ERROR_INVALID_PARAMETER;
115 if (keyval_type_is_array(kv->type))
116 return BUNDLE_ERROR_INVALID_PARAMETER;
128 /* LCOV_EXCL_START */
129 int keyval_compare(keyval_t *kv1, keyval_t *kv2)
134 if (strcmp(kv1->key, kv2->key) != 0)
136 if (kv1->type != kv2->type)
138 if (kv1->size != kv2->size)
141 if (kv1->val == NULL && kv2->val == NULL)
143 if (kv1->val == NULL || kv2->val == NULL)
145 if (memcmp(kv1->val, kv2->val, kv1->size) != 0)
152 size_t keyval_get_encoded_size(keyval_t *kv)
154 size_t encoded_size = 0;
159 encoded_size += sizeof(size_t); /* total size */
160 encoded_size += sizeof(int); /* type */
161 encoded_size += sizeof(size_t); /* key size */
163 if ((encoded_size + strlen(kv->key) + 1) < encoded_size)
166 encoded_size += strlen(kv->key) + 1; /* key */
168 if ((encoded_size + sizeof(size_t)) < encoded_size)
171 encoded_size += sizeof(size_t); /* size */
173 if ((encoded_size + kv->size) < encoded_size)
176 encoded_size += kv->size; /* val */
182 * encode a keyval to byte
184 * @pre kv must be valid.
185 * @post byte must be freed.
188 * @param[out] byte_len
191 size_t keyval_encode(keyval_t *kv, unsigned char **byte, size_t *byte_len)
193 static const size_t sz_type = sizeof(int);
194 static const size_t sz_keysize = sizeof(size_t);
195 size_t sz_key = strlen(kv->key) + 1;
196 static const size_t sz_size = sizeof(size_t);
197 size_t sz_val = kv->size;
200 *byte_len = keyval_get_encoded_size(kv);
204 *byte = calloc(1, *byte_len);
210 memcpy(p, byte_len, sizeof(size_t));
212 memcpy(p, &(kv->type), sz_type);
214 memcpy(p, &sz_key, sz_keysize);
216 memcpy(p, kv->key, sz_key);
218 memcpy(p, &(kv->size), sz_size);
220 memcpy(p, kv->val, sz_val);
227 * decode a byte stream to a keyval
229 * @param[in] byte byte stream.
230 * @param[in|out] kv keyval.
231 * If kv is NULL, new keyval_t object comes.
232 * If kv is not NULL, given kv is used. (No new kv is created.)
233 * @return Number of bytes read from byte.
235 size_t keyval_decode(unsigned char *byte, keyval_t **kv, size_t byte_size)
237 static const size_t sz_byte_len = sizeof(size_t);
238 static const size_t sz_type = sizeof(int);
239 static const size_t sz_keysize = sizeof(size_t);
240 static const size_t sz_size = sizeof(size_t);
247 unsigned char *p = byte;
250 if (byte_size < sz_byte_len)
253 memcpy(&byte_len, p, sz_byte_len);
254 if (byte_size < byte_len)
257 byte_size -= sz_byte_len;
260 if (byte_size < sz_type)
263 memcpy(&type, p, sz_type);
265 byte_size -= sz_type;
268 if (byte_size < sz_keysize)
271 memcpy(&keysize, p, sz_keysize);
273 byte_size -= sz_keysize;
276 if (byte_size < keysize)
280 if (!key || (strnlen(key, keysize) + 1) != keysize)
283 byte_size -= keysize;
286 if (byte_size < sz_size)
289 memcpy(&size, p, sz_size);
291 encoded_size = sz_byte_len + sz_type + sz_keysize + keysize +
293 if (encoded_size != byte_len)
300 *kv = keyval_new(*kv, key, type, val, size);
305 int keyval_get_type_from_encoded_byte(unsigned char *byte)
307 static const size_t sz_byte_len = sizeof(size_t);
308 unsigned char *p = byte;
312 memcpy(&type, p, sizeof(int));