src/keyval_array.c

   1 /*
   2  * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 /**
  18  * keyval_array.c
  19  * Implementation of keyval_array object
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "keyval_array.h"
  27 #include "keyval.h"
  28 #include "keyval_type.h"
  29 #include "bundle.h"
  30 #include "bundle_log.h"
  31
  32 static keyval_method_collection_t method = {
  33         (keyval_method_free_t) keyval_array_free,
  34         (keyval_method_compare_t) keyval_array_compare,
  35         (keyval_method_get_encoded_size_t) keyval_array_get_encoded_size,
  36         (keyval_method_encode_t) keyval_array_encode,
  37         (keyval_method_decode_t) keyval_array_decode
  38 };
  39
  40 keyval_array_t *keyval_array_new(keyval_array_t *kva, const char *key,
  41                 const int type, const void **array_val, const unsigned int len)
  42 {
  43         int must_free_obj = kva ? 0 : 1;
  44         keyval_t *kv;
  45
  46         if (!kva) {
  47                 kva = calloc(1, sizeof(keyval_array_t));
  48                 if (unlikely(kva == NULL)) {
  49                         set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
  50                         return NULL;
  51                 }
  52         }
  53
  54         /* keyval setting */
  55         kv = keyval_new((keyval_t *)kva, key, type, NULL, 0);
  56         if (unlikely(kv == NULL)) {
  57                         set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
  58                         return NULL;
  59         }
  60
  61         kv->type = kv->type | BUNDLE_TYPE_ARRAY;
  62         kva->len = len;
  63
  64         /* Set array value, if exist */
  65         if (kva->array_val) {
  66                 set_last_result(BUNDLE_ERROR_INVALID_PARAMETER);
  67                 if (must_free_obj)
  68                         keyval_array_free(kva, 1);
  69                 return NULL;
  70         }
  71         kva->array_val = calloc(len, sizeof(void *));
  72         if (!(kva->array_val)) {
  73                 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
  74                 keyval_array_free(kva, 1);
  75                 return NULL;
  76         }
  77         /* array_element_size */
  78         kva->array_element_size = calloc(len, sizeof(size_t));
  79         if (!(kva->array_element_size)) {
  80                 set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
  81                 keyval_array_free(kva, 1);
  82                 return NULL;
  83         }
  84         /* If available, copy array val */
  85         if (array_val
  86                 && keyval_type_is_measurable(type)
  87                 && keyval_type_get_measure_size_func(type)) {
  88                 /* array_val have original data array. copy it! */
  89
  90                 if (keyval_array_copy_array((keyval_array_t *)kv,
  91                                         (void **)array_val,
  92                                         len,
  93                                         keyval_type_get_measure_size_func(type))
  94                                         ) {
  95                         keyval_array_free(kva, 1);
  96                         return NULL;
  97                 }
  98         }
  99
 100         /* Set methods */
 101         kv->method = &method;
 102
 103         return kva;
 104 }
 105
 106 void keyval_array_free(keyval_array_t *kva, int do_free_object)
 107 {
 108         int i;
 109
 110         if (!kva)
 111                 return;
 112
 113         /* free keyval_array elements */
 114         free(kva->array_element_size);
 115         for (i = 0; i < kva->len; i++) {
 116                 if (kva->array_val[i])
 117                         free(kva->array_val[i]);
 118         }
 119         free(kva->array_val);
 120
 121         /* free parent */
 122         keyval_free((keyval_t *)kva, 0);
 123
 124         /* free object */
 125         if (do_free_object)
 126                 free(kva);
 127 }
 128
 129 /* LCOV_EXCL_START */
 130 int keyval_array_compare(keyval_array_t *kva1, keyval_array_t *kva2)
 131 {
 132         keyval_t *kv1;
 133         keyval_t *kv2;
 134         int i;
 135
 136         if (!kva1 || !kva2)
 137                 return -1;
 138
 139         kv1 = (keyval_t *)kva1;
 140         kv2 = (keyval_t *)kva2;
 141
 142         if (strcmp(kv1->key, kv2->key) != 0)
 143                 return 1;
 144         if (kv1->type != kv2->type)
 145                 return 1;
 146         if (kva1->len != kva2->len)
 147                 return 1;
 148
 149         for (i = 0; i < kva1->len; i++) {
 150                 if (kva1->array_val[i] == NULL && kva2->array_val[i] == NULL)
 151                         continue;
 152                 if (kva1->array_val[i] == NULL || kva2->array_val[i] == NULL)
 153                         return 1;
 154                 if (memcmp(kva1->array_val[i], kva2->array_val[i],
 155                                         kva1->array_element_size[i]) != 0)
 156                         return 1;
 157         }
 158
 159         return 0;
 160 }
 161 /* LCOV_EXCL_STOP */
 162
 163 int keyval_array_copy_array(keyval_array_t *kva, void **array_val,
 164                 unsigned int array_len, size_t (*measure_val_len)(void *val))
 165 {
 166         keyval_t *kv = (keyval_t *)kva;
 167         keyval_type_measure_size_func_t measure_size;
 168         int i;
 169
 170         /* Get measure_size function of the value type */
 171         measure_size = keyval_type_get_measure_size_func(kv->type);
 172         if (!measure_size)
 173                 return -1;
 174
 175         /* Copy each array item */
 176         for (i = 0; i < array_len; i++) {
 177                 kva->array_val[i] = malloc(measure_size(array_val[i]));
 178                 if (!(kva->array_val[i])) {
 179                         set_last_result(BUNDLE_ERROR_OUT_OF_MEMORY);
 180                         goto cleanup_exit;
 181                 }
 182                 memcpy(kva->array_val[i], array_val[i],
 183                                 measure_size(array_val[i]));
 184                 kva->array_element_size[i] = measure_size(array_val[i]);
 185         }
 186         return 0;
 187
 188 cleanup_exit:
 189         for (i = 0; i < array_len; i++) {
 190                 if (kva->array_val[i]) {
 191                         free(kva->array_val[i]);
 192                         kva->array_val[i] = NULL;
 193                 }
 194         }
 195         return -1;
 196 }
 197
 198 int keyval_array_is_idx_valid(keyval_array_t *kva, int idx)
 199 {
 200         if (kva && kva->len > idx && 0 <= idx)
 201                 return 1;
 202         return 0;
 203 }
 204
 205 int keyval_array_set_element(keyval_array_t *kva, int idx, void *val, size_t size)
 206 {
 207         /* An element is already exist in the idx! */
 208         if (kva->array_val[idx]) {
 209                 /* val==NULL means 'Free this element!' */
 210                 if (!val) {
 211                         free(kva->array_val[idx]);
 212                         kva->array_val[idx] = NULL;
 213                         kva->array_element_size[idx] = 0;
 214                 } else {
 215                         /* Error case! */
 216                         return BUNDLE_ERROR_INVALID_PARAMETER;
 217                 }
 218         } else {
 219                 /* Normal case. Copy value into the array. */
 220                 kva->array_val[idx] = malloc(size);
 221                 if (!(kva->array_val[idx]))
 222                         return BUNDLE_ERROR_OUT_OF_MEMORY;
 223                 if (val) {
 224                         memcpy(kva->array_val[idx], val, size);
 225                         kva->array_element_size[idx] = size;
 226                 }
 227         }
 228
 229         return BUNDLE_ERROR_NONE;
 230 }
 231
 232 int keyval_array_get_data(keyval_array_t *kva, int *type, void ***array_val,
 233                 unsigned int *len, size_t **array_element_size)
 234 {
 235         keyval_t *kv;
 236
 237         if (!kva)
 238                 return BUNDLE_ERROR_INVALID_PARAMETER;
 239
 240         kv = (keyval_t *)kva;
 241         if (!keyval_type_is_array(kv->type))
 242                 return BUNDLE_ERROR_INVALID_PARAMETER;
 243
 244         /* Return values */
 245         if (type)
 246                 *type = kv->type;
 247         if (array_val)
 248                 *array_val = kva->array_val;
 249         if (len)
 250                 *len = kva->len;
 251         if (array_element_size)
 252                 *array_element_size = kva->array_element_size;
 253
 254         return BUNDLE_ERROR_NONE;
 255 }
 256
 257 size_t keyval_array_get_encoded_size(keyval_array_t *kva)
 258 {
 259         size_t sum_array_element_size = 0;
 260         int i;
 261         size_t encoded_size;
 262
 263         for (i = 0; i < kva->len; i++)
 264                 sum_array_element_size += kva->array_element_size[i];
 265
 266         encoded_size = sizeof(size_t) /* total size */
 267                 + sizeof(int)    /* type */
 268                 + sizeof(size_t) /* keysize */
 269                 + strlen(((keyval_t *)kva)->key) + 1 /* key (+ null byte) */
 270                 + sizeof(int)    /* len */
 271                 + kva->len * sizeof(size_t)     /* array_element_size */
 272                 + sum_array_element_size;
 273
 274         return encoded_size;
 275 }
 276
 277 size_t keyval_array_encode(keyval_array_t *kva, void **byte, size_t *byte_len)
 278 {
 279         keyval_t *kv = (keyval_t *)kva;
 280         int i;
 281         /* Calculate memory size for kva */
 282         static const size_t sz_type = sizeof(int);
 283         static const size_t sz_keysize = sizeof(size_t);
 284         size_t sz_key = strlen(kv->key) + 1;
 285         static const unsigned int sz_len = sizeof(int);
 286         size_t sz_array_element_size = kva->len * sizeof(size_t);
 287         size_t sz_array_val = 0;
 288         unsigned char *p;
 289
 290         for (i = 0; i < kva->len; i++)
 291                 sz_array_val += kva->array_element_size[i];
 292
 293         /* Allocate memory */
 294         *byte_len = keyval_array_get_encoded_size(kva);
 295         *byte = calloc(1, *byte_len);
 296         if (!*byte)
 297                 return 0;
 298
 299         /* Copy data */
 300         p = *byte;
 301
 302         memcpy(p, byte_len, sizeof(size_t));
 303         p += sizeof(size_t);
 304         memcpy(p, &(kv->type), sz_type);
 305         p += sz_type;
 306         memcpy(p, &sz_key, sz_keysize);
 307         p += sz_keysize;
 308         memcpy(p, kv->key, sz_key);
 309         p += sz_key;
 310         memcpy(p, &(kva->len), sz_len);
 311         p += sz_len;
 312         memcpy(p, kva->array_element_size, sz_array_element_size);
 313         p += sz_array_element_size;
 314
 315         for (i = 0; i < kva->len; i++) {
 316                 memcpy(p, kva->array_val[i], kva->array_element_size[i]);
 317                 p += kva->array_element_size[i];
 318         }
 319
 320         return *byte_len;
 321 }
 322
 323 size_t keyval_array_decode(void *byte, keyval_array_t **kva, size_t byte_size)
 324 {
 325         static const size_t sz_byte_len = sizeof(size_t);
 326         static const size_t sz_type = sizeof(int);
 327         static const size_t sz_keysize = sizeof(size_t);
 328         static const int sz_len = sizeof(unsigned int);
 329         unsigned char *p = byte;
 330         size_t byte_len;
 331         int type;
 332         size_t keysize;
 333         char *key;
 334         unsigned int len;
 335         size_t *array_element_size;
 336         void *array_val;
 337         int i;
 338         size_t elem_size = 0;
 339         size_t sum_array_element_size = 0;
 340         size_t encoded_size;
 341
 342         /* Get data */
 343         byte_len = *((size_t *)p);
 344
 345         if (byte_size < sz_byte_len)
 346                 return 0;
 347
 348         byte_size -= sz_byte_len;
 349         p += sz_byte_len;
 350         type = *((int *)p);
 351
 352         if (byte_size < sz_type)
 353                 return 0;
 354
 355         byte_size -= sz_type;
 356         p += sz_type;
 357         keysize = *((size_t *)p);
 358
 359         if (byte_size < sz_keysize)
 360                 return 0;
 361
 362         byte_size -= sz_keysize;
 363         p += sz_keysize;
 364         key = (char *)p;
 365
 366         if (byte_size < keysize)
 367                 return 0;
 368
 369         if (!key || (strnlen(key, keysize) + 1) != keysize)
 370                 return 0;
 371
 372         byte_size -= keysize;
 373         p += keysize;
 374         len = *((unsigned int *)p);
 375
 376         if (byte_size < sz_len)
 377                 return 0;
 378
 379         byte_size -= sz_len;
 380         p += sz_len;
 381         array_element_size = (size_t *)p;
 382
 383         if (byte_size < (sizeof(size_t) * len))
 384                 return 0;
 385
 386         p += sizeof(size_t) * len;
 387         array_val = (void *)p;
 388
 389         for (i = 0; i < len; ++i)
 390                 sum_array_element_size += array_element_size[i];
 391
 392         encoded_size = sz_byte_len + sz_type + sz_keysize + keysize +
 393                 sz_len + (sizeof(size_t) * len) + sum_array_element_size;
 394         if (encoded_size != byte_len)
 395                 return 0;
 396
 397         *kva = keyval_array_new(NULL, key, type, NULL, len);
 398         for (i = 0; i < len; i++) {
 399                 elem_size += i ? array_element_size[i - 1] : 0;
 400                 if (keyval_array_set_element(*kva, i,
 401                                         (void *)(array_val + elem_size),
 402                                         array_element_size[i])) {
 403                         keyval_array_free(*kva, 1);
 404                         *kva = NULL;
 405                         return 0;
 406                 }
 407         }
 408
 409         return byte_len;
 410 }