lib/ecoli_node.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <stdint.h>
   8 #include <string.h>
   9 #include <assert.h>
  10 #include <errno.h>
  11
  12 #include <ecoli_malloc.h>
  13 #include <ecoli_string.h>
  14 #include <ecoli_strvec.h>
  15 #include <ecoli_keyval.h>
  16 #include <ecoli_log.h>
  17 #include <ecoli_test.h>
  18 #include <ecoli_node.h>
  19
  20 #include <ecoli_node_str.h>
  21 #include <ecoli_node_seq.h>
  22
  23 EC_LOG_TYPE_REGISTER(node);
  24
  25 static struct ec_node_type_list node_type_list =
  26         TAILQ_HEAD_INITIALIZER(node_type_list);
  27
  28 const struct ec_node_type *
  29 ec_node_type_lookup(const char *name)
  30 {
  31         struct ec_node_type *type;
  32
  33         TAILQ_FOREACH(type, &node_type_list, next) {
  34                 if (!strcmp(name, type->name))
  35                         return type;
  36         }
  37
  38         errno = ENOENT;
  39         return NULL;
  40 }
  41
  42 int ec_node_type_register(struct ec_node_type *type)
  43 {
  44         EC_CHECK_ARG(type->size >= sizeof(struct ec_node), -1, EINVAL);
  45
  46         if (ec_node_type_lookup(type->name) != NULL) {
  47                 errno = EEXIST;
  48                 return -1;
  49         }
  50
  51         TAILQ_INSERT_TAIL(&node_type_list, type, next);
  52
  53         return 0;
  54 }
  55
  56 void ec_node_type_dump(FILE *out)
  57 {
  58         struct ec_node_type *type;
  59
  60         TAILQ_FOREACH(type, &node_type_list, next)
  61                 fprintf(out, "%s\n", type->name);
  62 }
  63
  64 struct ec_node *__ec_node(const struct ec_node_type *type, const char *id)
  65 {
  66         struct ec_node *node = NULL;
  67
  68         EC_LOG(EC_LOG_DEBUG, "create node type=%s id=%s\n",
  69                 type->name, id);
  70         if (id == NULL) {
  71                 errno = EINVAL;
  72                 goto fail;
  73         }
  74
  75         node = ec_calloc(1, type->size);
  76         if (node == NULL)
  77                 goto fail;
  78
  79         node->type = type;
  80         node->refcnt = 1;
  81
  82         node->id = ec_strdup(id);
  83         if (node->id == NULL)
  84                 goto fail;
  85
  86         if (ec_asprintf(&node->desc, "<%s>", type->name) < 0)
  87                 goto fail;
  88
  89         node->attrs = ec_keyval();
  90         if (node->attrs == NULL)
  91                 goto fail;
  92
  93         if (type->init_priv != NULL) {
  94                 if (type->init_priv(node) < 0)
  95                         goto fail;
  96         }
  97
  98         return node;
  99
 100  fail:
 101         if (node != NULL) {
 102                 ec_keyval_free(node->attrs);
 103                 ec_free(node->desc);
 104                 ec_free(node->id);
 105         }
 106         ec_free(node);
 107
 108         return NULL;
 109 }
 110
 111 struct ec_node *ec_node(const char *typename, const char *id)
 112 {
 113         const struct ec_node_type *type;
 114
 115         type = ec_node_type_lookup(typename);
 116         if (type == NULL) {
 117                 EC_LOG(EC_LOG_ERR, "type=%s does not exist\n",
 118                         typename);
 119                 return NULL;
 120         }
 121
 122         return __ec_node(type, id);
 123 }
 124
 125 void ec_node_free(struct ec_node *node)
 126 {
 127         if (node == NULL)
 128                 return;
 129
 130         assert(node->refcnt > 0);
 131
 132         if (--node->refcnt > 0)
 133                 return;
 134
 135         if (node->type != NULL && node->type->free_priv != NULL)
 136                 node->type->free_priv(node);
 137         ec_free(node->children);
 138         ec_free(node->id);
 139         ec_free(node->desc);
 140         ec_keyval_free(node->attrs);
 141         ec_free(node);
 142 }
 143
 144 struct ec_node *ec_node_clone(struct ec_node *node)
 145 {
 146         if (node != NULL)
 147                 node->refcnt++;
 148         return node;
 149 }
 150
 151 size_t ec_node_get_children_count(const struct ec_node *node)
 152 {
 153         return node->n_children;
 154 }
 155
 156 struct ec_node *
 157 ec_node_get_child(const struct ec_node *node, size_t i)
 158 {
 159         if (i >= ec_node_get_children_count(node))
 160                 return NULL;
 161         return node->children[i];
 162 }
 163
 164 int ec_node_add_child(struct ec_node *node, struct ec_node *child)
 165 {
 166         struct ec_node **children = NULL;
 167         size_t n;
 168
 169         if (node == NULL || child == NULL) {
 170                 errno = EINVAL;
 171                 goto fail;
 172         }
 173
 174         n = node->n_children;
 175         children = ec_realloc(node->children,
 176                         (n + 1) * sizeof(child));
 177         if (children == NULL)
 178                 goto fail;
 179
 180         children[n] = child;
 181         node->children = children;
 182         node->n_children = n + 1;
 183
 184         return 0;
 185
 186 fail:
 187         ec_free(children);
 188         assert(errno != 0);
 189         return -1;
 190 }
 191
 192 #if 0 /* later */
 193 int ec_node_del_child(struct ec_node *node, struct ec_node *child)
 194 {
 195         size_t i, n;
 196
 197         if (node == NULL || child == NULL)
 198                 goto fail;
 199
 200         n = node->n_children;
 201         for (i = 0; i < n; i++) {
 202                 if (node->children[i] != child)
 203                         continue;
 204                 memcpy(&node->children[i], &node->children[i+1],
 205                         (n - i - 1) * sizeof(child));
 206                 return 0;
 207         }
 208
 209 fail:
 210         errno = EINVAL;
 211         return -1;
 212 }
 213 #endif
 214
 215 struct ec_node *ec_node_find(struct ec_node *node, const char *id)
 216 {
 217         struct ec_node *child, *ret;
 218         const char *node_id = ec_node_id(node);
 219         size_t i, n;
 220
 221         if (id != NULL && node_id != NULL && !strcmp(node_id, id))
 222                 return node;
 223
 224         n = node->n_children;
 225         for (i = 0; i < n; i++) {
 226                 child = node->children[i];
 227                 ret = ec_node_find(child, id);
 228                 if (ret != NULL)
 229                         return ret;
 230         }
 231
 232         return NULL;
 233 }
 234
 235 const struct ec_node_type *ec_node_type(const struct ec_node *node)
 236 {
 237         return node->type;
 238 }
 239
 240 struct ec_keyval *ec_node_attrs(const struct ec_node *node)
 241 {
 242         return node->attrs;
 243 }
 244
 245 const char *ec_node_id(const struct ec_node *node)
 246 {
 247         return node->id;
 248 }
 249
 250 static void __ec_node_dump(FILE *out,
 251         const struct ec_node *node, size_t indent)
 252 {
 253         const char *id, *typename;
 254         struct ec_node *child;
 255         size_t i, n;
 256
 257         id = ec_node_id(node);
 258         typename = node->type->name;
 259
 260         fprintf(out, "%*s" "type=%s id=%s %p\n",
 261                 (int)indent * 4, "", typename, id, node);
 262         n = node->n_children;
 263         for (i = 0; i < n; i++) {
 264                 child = node->children[i];
 265                 __ec_node_dump(out, child, indent + 1);
 266         }
 267 }
 268
 269 void ec_node_dump(FILE *out, const struct ec_node *node)
 270 {
 271         fprintf(out, "------------------- node dump:\n");
 272
 273         if (node == NULL) {
 274                 fprintf(out, "node is NULL\n");
 275                 return;
 276         }
 277
 278         __ec_node_dump(out, node, 0);
 279 }
 280
 281 const char *ec_node_desc(const struct ec_node *node)
 282 {
 283         if (node->type->desc != NULL)
 284                 return node->type->desc(node);
 285
 286         return node->desc;
 287 }
 288
 289 int ec_node_check_type(const struct ec_node *node,
 290                 const struct ec_node_type *type)
 291 {
 292         if (strcmp(node->type->name, type->name)) {
 293                 errno = EINVAL;
 294                 return -1;
 295         }
 296
 297         return 0;
 298 }
 299
 300 /* LCOV_EXCL_START */
 301 static int ec_node_testcase(void)
 302 {
 303         struct ec_node *node = NULL;
 304         const struct ec_node *child;
 305         const struct ec_node_type *type;
 306         FILE *f = NULL;
 307         char *buf = NULL;
 308         size_t buflen = 0;
 309         int testres = 0;
 310         int ret;
 311
 312         node = EC_NODE_SEQ(EC_NO_ID,
 313                         ec_node_str("id_x", "x"),
 314                         ec_node_str("id_y", "y"));
 315         if (node == NULL)
 316                 goto fail;
 317
 318         ec_node_clone(node);
 319         ec_node_free(node);
 320
 321         f = open_memstream(&buf, &buflen);
 322         if (f == NULL)
 323                 goto fail;
 324         ec_node_dump(f, node);
 325         ec_node_type_dump(f);
 326         ec_node_dump(f, NULL);
 327         fclose(f);
 328         f = NULL;
 329
 330         testres |= EC_TEST_CHECK(
 331                 strstr(buf, "type=seq id=no-id"), "bad dump\n");
 332         testres |= EC_TEST_CHECK(
 333                 strstr(buf, "type=str id=id_x") &&
 334                 strstr(strstr(buf, "type=str id=id_x") + 1,
 335                         "type=str id=id_y"),
 336                 "bad dump\n");
 337         free(buf);
 338         buf = NULL;
 339
 340         testres |= EC_TEST_CHECK(
 341                 !strcmp(ec_node_type(node)->name, "seq") &&
 342                 !strcmp(ec_node_id(node), EC_NO_ID) &&
 343                 !strcmp(ec_node_desc(node), "<seq>"),
 344                 "bad child 0");
 345
 346         testres |= EC_TEST_CHECK(
 347                 ec_node_get_children_count(node) == 2,
 348                 "bad children count\n");
 349         child = ec_node_get_child(node, 0);
 350         testres |= EC_TEST_CHECK(child != NULL &&
 351                 !strcmp(ec_node_type(child)->name, "str") &&
 352                 !strcmp(ec_node_id(child), "id_x"),
 353                 "bad child 0");
 354         child = ec_node_get_child(node, 1);
 355         testres |= EC_TEST_CHECK(child != NULL &&
 356                 !strcmp(ec_node_type(child)->name, "str") &&
 357                 !strcmp(ec_node_id(child), "id_y"),
 358                 "bad child 1");
 359         child = ec_node_get_child(node, 2);
 360         testres |= EC_TEST_CHECK(child == NULL,
 361                 "child 2 should be NULL");
 362
 363         child = ec_node_find(node, "id_x");
 364         testres |= EC_TEST_CHECK(child != NULL &&
 365                 !strcmp(ec_node_type(child)->name, "str") &&
 366                 !strcmp(ec_node_id(child), "id_x") &&
 367                 !strcmp(ec_node_desc(child), "x"),
 368                 "bad child id_x");
 369         child = ec_node_find(node, "id_dezdex");
 370         testres |= EC_TEST_CHECK(child == NULL,
 371                 "child with wrong id should be NULL");
 372
 373         ret = ec_keyval_set(ec_node_attrs(node), "key", "val", NULL);
 374         testres |= EC_TEST_CHECK(ret == 0,
 375                 "cannot set node attribute\n");
 376
 377         type = ec_node_type_lookup("seq");
 378         testres |= EC_TEST_CHECK(type != NULL &&
 379                 ec_node_check_type(node, type) == 0,
 380                 "cannot get seq node type");
 381         type = ec_node_type_lookup("str");
 382         testres |= EC_TEST_CHECK(type != NULL &&
 383                 ec_node_check_type(node, type) < 0,
 384                 "node type should not be str");
 385
 386         ec_node_free(node);
 387         node = NULL;
 388
 389         node = ec_node("deznuindez", EC_NO_ID);
 390         testres |= EC_TEST_CHECK(node == NULL,
 391                         "should not be able to create node\n");
 392
 393         return testres;
 394
 395 fail:
 396         ec_node_free(node);
 397         if (f != NULL)
 398                 fclose(f);
 399         free(buf);
 400
 401         assert(errno != 0);
 402         return -1;
 403 }
 404 /* LCOV_EXCL_STOP */
 405
 406 static struct ec_test ec_node_test = {
 407         .name = "node",
 408         .test = ec_node_testcase,
 409 };
 410
 411 EC_TEST_REGISTER(ec_node_test);