main/sorcery.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2012 - 2013, Digium, Inc.
   5  *
   6  * Joshua Colp <jcolp@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Sorcery Data Access Layer API
  22  *
  23  * \author Joshua Colp <jcolp@digium.com>
  24  */
  25
  26 /*** MODULEINFO
  27         <support_level>core</support_level>
  28  ***/
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  33
  34 #include "asterisk/logger.h"
  35 #include "asterisk/sorcery.h"
  36 #include "asterisk/astobj2.h"
  37 #include "asterisk/strings.h"
  38 #include "asterisk/config_options.h"
  39 #include "asterisk/netsock2.h"
  40 #include "asterisk/module.h"
  41
  42 /* To prevent DEBUG_FD_LEAKS from interfering with things we undef open and close */
  43 #undef open
  44 #undef close
  45
  46 /*! \brief Number of buckets for wizards (should be prime for performance reasons) */
  47 #define WIZARD_BUCKETS 7
  48
  49 /*! \brief Number of buckets for types (should be prime for performance reasons) */
  50 #define TYPE_BUCKETS 53
  51
  52 /*! \brief Maximum length of an object field name */
  53 #define MAX_OBJECT_FIELD 128
  54
  55 /*! \brief Structure for registered object type */
  56 struct ast_sorcery_object_type {
  57         /*! \brief Unique name of the object type */
  58         char name[MAX_OBJECT_TYPE];
  59
  60         /*! \brief Optional transformation callback */
  61         sorcery_transform_handler transform;
  62
  63         /*! \brief Optional object set apply callback */
  64         sorcery_apply_handler apply;
  65
  66         /*! \brief Optional object copy callback */
  67         sorcery_copy_handler copy;
  68
  69         /*! \brief Optional object diff callback */
  70         sorcery_diff_handler diff;
  71
  72         /*! \brief Wizard instances */
  73         struct ao2_container *wizards;
  74
  75         /*! \brief Object fields */
  76         struct ao2_container *fields;
  77
  78         /*! \brief Configuration framework general information */
  79         struct aco_info *info;
  80
  81         /*! \brief Configuration framework file information */
  82         struct aco_file *file;
  83
  84         /*! \brief Type details */
  85         struct aco_type type;
  86 };
  87
  88 /*! \brief Structure for registered object field */
  89 struct ast_sorcery_object_field {
  90         /*! \brief Name of the field */
  91         char name[MAX_OBJECT_FIELD];
  92
  93         /*! \brief Callback function for translation of a single value */
  94         sorcery_field_handler handler;
  95
  96         /*! \brief Callback function for translation of multiple values */
  97         sorcery_fields_handler multiple_handler;
  98
  99         /*! \brief Position of the field */
 100         intptr_t args[];
 101 };
 102
 103 /*! \brief Structure for a wizard instance which operates on objects */
 104 struct ast_sorcery_object_wizard {
 105         /*! \brief Wizard interface itself */
 106         struct ast_sorcery_wizard *wizard;
 107
 108         /*! \brief Unique data for the wizard */
 109         void *data;
 110
 111         /*! \brief Wizard is acting as an object cache */
 112         unsigned int caching:1;
 113 };
 114
 115 /*! \brief Full structure for sorcery */
 116 struct ast_sorcery {
 117         /*! \brief Container for known object types */
 118         struct ao2_container *types;
 119 };
 120
 121 /*! \brief Structure for passing load/reload details */
 122 struct sorcery_load_details {
 123         /*! \brief Sorcery structure in use */
 124         const struct ast_sorcery *sorcery;
 125
 126         /*! \brief Type of object being loaded */
 127         const char *type;
 128
 129         /*! \brief Whether this is a reload or not */
 130         unsigned int reload:1;
 131 };
 132
 133 /*! \brief Registered sorcery wizards */
 134 struct ao2_container *wizards;
 135
 136 static int int_handler_fn(const void *obj, const intptr_t *args, char **buf)
 137 {
 138         int *field = (int *)(obj + args[0]);
 139         return (ast_asprintf(buf, "%d", *field) < 0) ? -1 : 0;
 140 }
 141
 142 static int uint_handler_fn(const void *obj, const intptr_t *args, char **buf)
 143 {
 144         unsigned int *field = (unsigned int *)(obj + args[0]);
 145         return (ast_asprintf(buf, "%u", *field) < 0) ? -1 : 0;
 146 }
 147
 148 static int double_handler_fn(const void *obj, const intptr_t *args, char **buf)
 149 {
 150         double *field = (double *)(obj + args[0]);
 151         return (ast_asprintf(buf, "%f", *field) < 0) ? -1 : 0;
 152 }
 153
 154 static int stringfield_handler_fn(const void *obj, const intptr_t *args, char **buf)
 155 {
 156         ast_string_field *field = (const char **)(obj + args[0]);
 157         return !(*buf = ast_strdup(*field)) ? -1 : 0;
 158 }
 159
 160 static int bool_handler_fn(const void *obj, const intptr_t *args, char **buf)
 161 {
 162         unsigned int *field = (unsigned int *)(obj + args[0]);
 163         return !(*buf = ast_strdup(*field ? "true" : "false")) ? -1 : 0;
 164 }
 165
 166 static int sockaddr_handler_fn(const void *obj, const intptr_t *args, char **buf)
 167 {
 168         struct ast_sockaddr *field = (struct ast_sockaddr *)(obj + args[0]);
 169         return !(*buf = ast_strdup(ast_sockaddr_stringify(field))) ? -1 : 0;
 170 }
 171
 172 static int chararray_handler_fn(const void *obj, const intptr_t *args, char **buf)
 173 {
 174         char *field = (char *)(obj + args[0]);
 175         return !(*buf = ast_strdup(field)) ? -1 : 0;
 176 }
 177
 178 static sorcery_field_handler sorcery_field_default_handler(enum aco_option_type type)
 179 {
 180         switch(type) {
 181         case OPT_BOOL_T: return bool_handler_fn;
 182         case OPT_CHAR_ARRAY_T: return chararray_handler_fn;
 183         case OPT_DOUBLE_T: return double_handler_fn;
 184         case OPT_INT_T: return int_handler_fn;
 185         case OPT_SOCKADDR_T: return sockaddr_handler_fn;
 186         case OPT_STRINGFIELD_T: return stringfield_handler_fn;
 187         case OPT_UINT_T: return uint_handler_fn;
 188
 189         default:
 190         case OPT_CUSTOM_T: return NULL;
 191         }
 192
 193         return NULL;
 194 }
 195
 196 /*! \brief Hashing function for sorcery wizards */
 197 static int sorcery_wizard_hash(const void *obj, const int flags)
 198 {
 199         const struct ast_sorcery_wizard *wizard = obj;
 200         const char *name = obj;
 201
 202         return ast_str_hash(flags & OBJ_KEY ? name : wizard->name);
 203 }
 204
 205 /*! \brief Comparator function for sorcery wizards */
 206 static int sorcery_wizard_cmp(void *obj, void *arg, int flags)
 207 {
 208         struct ast_sorcery_wizard *wizard1 = obj, *wizard2 = arg;
 209         const char *name = arg;
 210
 211         return !strcmp(wizard1->name, flags & OBJ_KEY ? name : wizard2->name) ? CMP_MATCH | CMP_STOP : 0;
 212 }
 213
 214 int ast_sorcery_init(void)
 215 {
 216         ast_assert(wizards == NULL);
 217
 218         if (!(wizards = ao2_container_alloc(WIZARD_BUCKETS, sorcery_wizard_hash, sorcery_wizard_cmp))) {
 219                 return -1;
 220         }
 221
 222         return 0;
 223 }
 224
 225 int __ast_sorcery_wizard_register(const struct ast_sorcery_wizard *interface, struct ast_module *module)
 226 {
 227         struct ast_sorcery_wizard *wizard;
 228         int res = -1;
 229
 230         ast_assert(!ast_strlen_zero(interface->name));
 231
 232         ao2_lock(wizards);
 233
 234         if ((wizard = ao2_find(wizards, interface->name, OBJ_KEY | OBJ_NOLOCK))) {
 235                 ast_log(LOG_WARNING, "Attempted to register sorcery wizard '%s' twice\n",
 236                         interface->name);
 237                 goto done;
 238         }
 239
 240         if (!(wizard = ao2_alloc(sizeof(*wizard), NULL))) {
 241                 goto done;
 242         }
 243
 244         *wizard = *interface;
 245         wizard->module = module;
 246
 247         ao2_link_flags(wizards, wizard, OBJ_NOLOCK);
 248         res = 0;
 249
 250         ast_verb(2, "Sorcery registered wizard '%s'\n", interface->name);
 251
 252 done:
 253         ao2_cleanup(wizard);
 254         ao2_unlock(wizards);
 255
 256         return res;
 257 }
 258
 259 int ast_sorcery_wizard_unregister(const struct ast_sorcery_wizard *interface)
 260 {
 261         RAII_VAR(struct ast_sorcery_wizard *, wizard, ao2_find(wizards, interface->name, OBJ_KEY | OBJ_UNLINK), ao2_cleanup);
 262
 263         if (wizard) {
 264                 ast_verb(2, "Sorcery unregistered wizard '%s'\n", interface->name);
 265                 return 0;
 266         } else {
 267                 return -1;
 268         }
 269 }
 270
 271 /*! \brief Destructor called when sorcery structure is destroyed */
 272 static void sorcery_destructor(void *obj)
 273 {
 274         struct ast_sorcery *sorcery = obj;
 275
 276         ao2_cleanup(sorcery->types);
 277 }
 278
 279 /*! \brief Hashing function for sorcery types */
 280 static int sorcery_type_hash(const void *obj, const int flags)
 281 {
 282         const struct ast_sorcery_object_type *type = obj;
 283         const char *name = obj;
 284
 285         return ast_str_hash(flags & OBJ_KEY ? name : type->name);
 286 }
 287
 288 /*! \brief Comparator function for sorcery types */
 289 static int sorcery_type_cmp(void *obj, void *arg, int flags)
 290 {
 291         struct ast_sorcery_object_type *type1 = obj, *type2 = arg;
 292         const char *name = arg;
 293
 294         return !strcmp(type1->name, flags & OBJ_KEY ? name : type2->name) ? CMP_MATCH | CMP_STOP : 0;
 295 }
 296
 297 struct ast_sorcery *ast_sorcery_open(void)
 298 {
 299         struct ast_sorcery *sorcery;
 300
 301         if (!(sorcery = ao2_alloc(sizeof(*sorcery), sorcery_destructor))) {
 302                 return NULL;
 303         }
 304
 305         if (!(sorcery->types = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_RWLOCK, TYPE_BUCKETS, sorcery_type_hash, sorcery_type_cmp))) {
 306                 ao2_ref(sorcery, -1);
 307                 sorcery = NULL;
 308         }
 309
 310         return sorcery;
 311 }
 312
 313 /*! \brief Destructor function for object types */
 314 static void sorcery_object_type_destructor(void *obj)
 315 {
 316         struct ast_sorcery_object_type *object_type = obj;
 317
 318         ao2_cleanup(object_type->wizards);
 319         ao2_cleanup(object_type->fields);
 320
 321         if (object_type->info) {
 322                 aco_info_destroy(object_type->info);
 323                 ast_free(object_type->info);
 324         }
 325
 326         ast_free(object_type->file);
 327 }
 328
 329 /*! \brief Internal function which allocates an object type structure */
 330 static struct ast_sorcery_object_type *sorcery_object_type_alloc(const char *type, const char *module)
 331 {
 332         struct ast_sorcery_object_type *object_type;
 333
 334         if (!(object_type = ao2_alloc(sizeof(*object_type), sorcery_object_type_destructor))) {
 335                 return NULL;
 336         }
 337
 338         /* Order matters for object wizards */
 339         if (!(object_type->wizards = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
 340                 ao2_ref(object_type, -1);
 341                 return NULL;
 342         }
 343
 344         if (!(object_type->fields = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
 345                 ao2_ref(object_type, -1);
 346                 return NULL;
 347         }
 348
 349         if (!(object_type->info = ast_calloc(1, sizeof(*object_type->info) + 2 * sizeof(object_type->info->files[0])))) {
 350                 ao2_ref(object_type, -1);
 351                 return NULL;
 352         }
 353
 354         if (!(object_type->file = ast_calloc(1, sizeof(*object_type->file) + 2 * sizeof(object_type->file->types[0])))) {
 355                 ao2_ref(object_type, -1);
 356                 return NULL;
 357         }
 358
 359         object_type->info->files[0] = object_type->file;
 360         object_type->info->files[1] = NULL;
 361         object_type->info->module = module;
 362
 363         ast_copy_string(object_type->name, type, sizeof(object_type->name));
 364
 365         return object_type;
 366 }
 367
 368 /*! \brief Object wizard destructor */
 369 static void sorcery_object_wizard_destructor(void *obj)
 370 {
 371         struct ast_sorcery_object_wizard *object_wizard = obj;
 372
 373         if (object_wizard->data) {
 374                 object_wizard->wizard->close(object_wizard->data);
 375         }
 376
 377         if (object_wizard->wizard) {
 378                 ast_module_unref(object_wizard->wizard->module);
 379         }
 380 }
 381
 382 /*! \brief Internal function which creates an object type and adds a wizard mapping */
 383 static int sorcery_apply_wizard_mapping(struct ast_sorcery *sorcery, const char *type, const char *module, const char *name, const char *data, unsigned int caching)
 384 {
 385         RAII_VAR(struct ast_sorcery_object_type *, object_type,  ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 386         RAII_VAR(struct ast_sorcery_wizard *, wizard, ao2_find(wizards, name, OBJ_KEY), ao2_cleanup);
 387         RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, ao2_alloc(sizeof(*object_wizard), sorcery_object_wizard_destructor), ao2_cleanup);
 388         int created = 0;
 389
 390         if (!wizard || !object_wizard) {
 391                 return -1;
 392         }
 393
 394         if (!object_type) {
 395                 if (!(object_type = sorcery_object_type_alloc(type, module))) {
 396                         return -1;
 397                 }
 398                 created = 1;
 399         }
 400
 401         if (wizard->open && !(object_wizard->data = wizard->open(data))) {
 402                 return -1;
 403         }
 404
 405         ast_module_ref(wizard->module);
 406
 407         object_wizard->wizard = wizard;
 408         object_wizard->caching = caching;
 409
 410         ao2_link(object_type->wizards, object_wizard);
 411
 412         if (created) {
 413                 ao2_link(sorcery->types, object_type);
 414         }
 415
 416         return 0;
 417 }
 418
 419 int __ast_sorcery_apply_config(struct ast_sorcery *sorcery, const char *name, const char *module)
 420 {
 421         struct ast_flags flags = { 0 };
 422         struct ast_config *config = ast_config_load2("sorcery.conf", "sorcery", flags);
 423         struct ast_variable *mapping;
 424         int res = 0;
 425
 426         if (!config || (config == CONFIG_STATUS_FILEMISSING) || (config == CONFIG_STATUS_FILEINVALID)) {
 427                 return -1;
 428         }
 429
 430         for (mapping = ast_variable_browse(config, name); mapping; mapping = mapping->next) {
 431                 RAII_VAR(char *, mapping_name, ast_strdup(mapping->name), ast_free);
 432                 RAII_VAR(char *, mapping_value, ast_strdup(mapping->value), ast_free);
 433                 char *options = mapping_name, *name = strsep(&options, "/");
 434                 char *data = mapping_value, *wizard = strsep(&data, ",");
 435                 unsigned int caching = 0;
 436
 437                 /* If no wizard exists just skip, nothing we can do */
 438                 if (ast_strlen_zero(wizard)) {
 439                         continue;
 440                 }
 441
 442                 /* If the wizard is configured as a cache treat it as such */
 443                 if (!ast_strlen_zero(options) && strstr(options, "cache")) {
 444                         caching = 1;
 445                 }
 446
 447                 /* Any error immediately causes us to stop */
 448                 if ((res = sorcery_apply_wizard_mapping(sorcery, name, module, wizard, data, caching))) {
 449                         break;
 450                 }
 451         }
 452
 453         ast_config_destroy(config);
 454
 455         return res;
 456 }
 457
 458 int __ast_sorcery_apply_default(struct ast_sorcery *sorcery, const char *type, const char *module, const char *name, const char *data)
 459 {
 460         RAII_VAR(struct ast_sorcery_object_type *, object_type,  ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 461
 462         /* Defaults can not be added if any existing mapping exists */
 463         if (object_type) {
 464                 return -1;
 465         }
 466
 467         return sorcery_apply_wizard_mapping(sorcery, type, module, name, data, 0);
 468 }
 469
 470 int ast_sorcery_object_register(struct ast_sorcery *sorcery, const char *type, aco_type_item_alloc alloc, sorcery_transform_handler transform, sorcery_apply_handler apply)
 471 {
 472         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 473
 474         if (!object_type || object_type->type.item_alloc) {
 475                 return -1;
 476         }
 477
 478         object_type->type.name = object_type->name;
 479         object_type->type.type = ACO_ITEM;
 480         object_type->type.category = "";
 481         object_type->type.item_alloc = alloc;
 482
 483         object_type->transform = transform;
 484         object_type->apply = apply;
 485         object_type->file->types[0] = &object_type->type;
 486         object_type->file->types[1] = NULL;
 487
 488         if (aco_info_init(object_type->info)) {
 489                 return -1;
 490         }
 491
 492         return 0;
 493 }
 494
 495 void ast_sorcery_object_set_copy_handler(struct ast_sorcery *sorcery, const char *type, sorcery_copy_handler copy)
 496 {
 497         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 498
 499         if (!object_type) {
 500                 return;
 501         }
 502
 503         object_type->copy = copy;
 504 }
 505
 506 void ast_sorcery_object_set_diff_handler(struct ast_sorcery *sorcery, const char *type, sorcery_diff_handler diff)
 507 {
 508         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 509
 510         if (!object_type) {
 511                 return;
 512         }
 513
 514         object_type->diff = diff;
 515 }
 516
 517 int ast_sorcery_object_fields_register(struct ast_sorcery *sorcery, const char *type, const char *regex, aco_option_handler config_handler, sorcery_fields_handler sorcery_handler)
 518 {
 519         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 520         RAII_VAR(struct ast_sorcery_object_field *, object_field, NULL, ao2_cleanup);
 521
 522         if (!object_type || !object_type->type.item_alloc || !config_handler || !(object_field = ao2_alloc(sizeof(*object_field), NULL))) {
 523                 return -1;
 524         }
 525
 526         ast_copy_string(object_field->name, regex, sizeof(object_field->name));
 527         object_field->multiple_handler = sorcery_handler;
 528
 529         ao2_link(object_type->fields, object_field);
 530         __aco_option_register(object_type->info, regex, ACO_REGEX, object_type->file->types, "", OPT_CUSTOM_T, config_handler, 0, 0);
 531
 532         return 0;
 533 }
 534
 535 int __ast_sorcery_object_field_register(struct ast_sorcery *sorcery, const char *type, const char *name, const char *default_val, enum aco_option_type opt_type,
 536                                         aco_option_handler config_handler, sorcery_field_handler sorcery_handler, unsigned int flags, size_t argc, ...)
 537 {
 538         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 539         RAII_VAR(struct ast_sorcery_object_field *, object_field, NULL, ao2_cleanup);
 540         int pos;
 541         va_list args;
 542
 543         if (!object_type || !object_type->type.item_alloc) {
 544                 return -1;
 545         }
 546
 547         if (!sorcery_handler) {
 548                 sorcery_handler = sorcery_field_default_handler(opt_type);
 549         }
 550
 551         if (!(object_field = ao2_alloc(sizeof(*object_field) + argc * sizeof(object_field->args[0]), NULL))) {
 552                 return -1;
 553         }
 554
 555         ast_copy_string(object_field->name, name, sizeof(object_field->name));
 556         object_field->handler = sorcery_handler;
 557
 558         va_start(args, argc);
 559         for (pos = 0; pos < argc; pos++) {
 560                 object_field->args[pos] = va_arg(args, size_t);
 561         }
 562         va_end(args);
 563
 564         ao2_link(object_type->fields, object_field);
 565
 566         /* TODO: Improve this hack */
 567         if (!argc) {
 568                 __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc);
 569         } else if (argc == 1) {
 570                 __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
 571                                       object_field->args[0]);
 572         } else if (argc == 2) {
 573                 __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
 574                                       object_field->args[0], object_field->args[1]);
 575         } else if (argc == 3) {
 576                 __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
 577                                       object_field->args[0], object_field->args[1], object_field->args[2]);
 578         } else {
 579                 ast_assert(0); /* The hack... she does us no good for this */
 580         }
 581
 582         return 0;
 583 }
 584
 585 static int sorcery_wizard_load(void *obj, void *arg, int flags)
 586 {
 587         struct ast_sorcery_object_wizard *wizard = obj;
 588         struct sorcery_load_details *details = arg;
 589         void (*load)(void *data, const struct ast_sorcery *sorcery, const char *type);
 590
 591         load = !details->reload ? wizard->wizard->load : wizard->wizard->reload;
 592
 593         if (load) {
 594                 load(wizard->data, details->sorcery, details->type);
 595         }
 596
 597         return 0;
 598 }
 599
 600 static int sorcery_object_load(void *obj, void *arg, int flags)
 601 {
 602         struct ast_sorcery_object_type *type = obj;
 603         struct sorcery_load_details *details = arg;
 604
 605         details->type = type->name;
 606         ao2_callback(type->wizards, OBJ_NODATA, sorcery_wizard_load, details);
 607
 608         return 0;
 609 }
 610
 611 void ast_sorcery_load(const struct ast_sorcery *sorcery)
 612 {
 613         struct sorcery_load_details details = {
 614                 .sorcery = sorcery,
 615                 .reload = 0,
 616         };
 617
 618         ao2_callback(sorcery->types, OBJ_NODATA, sorcery_object_load, &details);
 619 }
 620
 621 void ast_sorcery_load_object(const struct ast_sorcery *sorcery, const char *type)
 622 {
 623         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 624         struct sorcery_load_details details = {
 625                 .sorcery = sorcery,
 626                 .reload = 0,
 627         };
 628
 629         if (!object_type) {
 630                 return;
 631         }
 632
 633         sorcery_object_load(object_type, &details, 0);
 634 }
 635
 636 void ast_sorcery_reload(const struct ast_sorcery *sorcery)
 637 {
 638         struct sorcery_load_details details = {
 639                 .sorcery = sorcery,
 640                 .reload = 1,
 641         };
 642
 643         ao2_callback(sorcery->types, OBJ_NODATA, sorcery_object_load, &details);
 644 }
 645
 646 void ast_sorcery_reload_object(const struct ast_sorcery *sorcery, const char *type)
 647 {
 648         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 649         struct sorcery_load_details details = {
 650                 .sorcery = sorcery,
 651                 .reload = 1,
 652         };
 653
 654         if (!object_type) {
 655                 return;
 656         }
 657
 658         sorcery_object_load(object_type, &details, 0);
 659 }
 660
 661 void ast_sorcery_ref(struct ast_sorcery *sorcery)
 662 {
 663         ao2_ref(sorcery, +1);
 664 }
 665
 666 struct ast_variable *ast_sorcery_objectset_create(const struct ast_sorcery *sorcery, const void *object)
 667 {
 668         const struct ast_sorcery_object_details *details = object;
 669         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
 670         struct ao2_iterator i;
 671         struct ast_sorcery_object_field *object_field;
 672         struct ast_variable *fields = NULL;
 673         int res = 0;
 674
 675         if (!object_type) {
 676                 return NULL;
 677         }
 678
 679         i = ao2_iterator_init(object_type->fields, 0);
 680
 681         for (; (object_field = ao2_iterator_next(&i)) && !res; ao2_ref(object_field, -1)) {
 682                 struct ast_variable *tmp = NULL;
 683
 684                 if (object_field->multiple_handler) {
 685                         if ((res = object_field->multiple_handler(object, &tmp))) {
 686                                 ast_variables_destroy(tmp);
 687                         }
 688                 } else if (object_field->handler) {
 689                         char *buf = NULL;
 690
 691                         if ((res = object_field->handler(object, object_field->args, &buf)) ||
 692                                 !(tmp = ast_variable_new(object_field->name, S_OR(buf, ""), ""))) {
 693                                 res = -1;
 694                         }
 695
 696                         ast_free(buf);
 697                 } else {
 698                         continue;
 699                 }
 700
 701                 if (!res) {
 702                         tmp->next = fields;
 703                         fields = tmp;
 704                 }
 705         }
 706
 707         ao2_iterator_destroy(&i);
 708
 709         /* If any error occurs we destroy all fields handled before so a partial objectset is not returned */
 710         if (res) {
 711                 ast_variables_destroy(fields);
 712                 fields = NULL;
 713         }
 714
 715         return fields;
 716 }
 717
 718 int ast_sorcery_objectset_apply(const struct ast_sorcery *sorcery, void *object, struct ast_variable *objectset)
 719 {
 720         const struct ast_sorcery_object_details *details = object;
 721         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
 722         RAII_VAR(struct ast_variable *, transformed, NULL, ast_variables_destroy);
 723         struct ast_variable *field;
 724         int res = 0;
 725
 726         if (!object_type) {
 727                 return -1;
 728         }
 729
 730         if (object_type->transform && (transformed = object_type->transform(objectset))) {
 731                 field = transformed;
 732         } else {
 733                 field = objectset;
 734         }
 735
 736         for (; field; field = field->next) {
 737                 if ((res = aco_process_var(&object_type->type, details->id, field, object))) {
 738                         break;
 739                 }
 740         }
 741
 742         if (!res && object_type->apply) {
 743                 object_type->apply(sorcery, object);
 744         }
 745
 746         return res;
 747 }
 748
 749 static const struct ast_variable *sorcery_find_field(const struct ast_variable *fields, const char *name)
 750 {
 751         const struct ast_variable *field;
 752
 753         /* Search the linked list of fields to find the correct one */
 754         for (field = fields; field; field = field->next) {
 755                 if (!strcmp(field->name, name)) {
 756                         return field;
 757                 }
 758         }
 759
 760         return NULL;
 761 }
 762
 763 int ast_sorcery_changeset_create(const struct ast_variable *original, const struct ast_variable *modified, struct ast_variable **changes)
 764 {
 765         const struct ast_variable *field;
 766         int res = 0;
 767
 768         *changes = NULL;
 769
 770         /* Unless the ast_variable list changes when examined... it can't differ from itself */
 771         if (original == modified) {
 772                 return 0;
 773         }
 774
 775         for (field = modified; field; field = field->next) {
 776                 const struct ast_variable *old = sorcery_find_field(original, field->name);
 777
 778                 if (!old || strcmp(old->value, field->value)) {
 779                         struct ast_variable *tmp;
 780
 781                         if (!(tmp = ast_variable_new(field->name, field->value, ""))) {
 782                                 res = -1;
 783                                 break;
 784                         }
 785
 786                         tmp->next = *changes;
 787                         *changes = tmp;
 788                 }
 789         }
 790
 791         /* If an error occurred do not return a partial changeset */
 792         if (res) {
 793                 ast_variables_destroy(*changes);
 794                 *changes = NULL;
 795         }
 796
 797         return res;
 798 }
 799
 800 void *ast_sorcery_alloc(const struct ast_sorcery *sorcery, const char *type, const char *id)
 801 {
 802         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 803         struct ast_sorcery_object_details *details;
 804
 805         if (!object_type || !object_type->type.item_alloc ||
 806             !(details = object_type->type.item_alloc(""))) {
 807                 return NULL;
 808         }
 809
 810         if (ast_strlen_zero(id)) {
 811                 ast_uuid_generate_str(details->id, sizeof(details->id));
 812         } else {
 813                 ast_copy_string(details->id, id, sizeof(details->id));
 814         }
 815
 816         ast_copy_string(details->type, type, sizeof(details->type));
 817
 818         if (aco_set_defaults(&object_type->type, id, details)) {
 819                 ao2_ref(details, -1);
 820                 return NULL;
 821         }
 822
 823         return details;
 824 }
 825
 826 void *ast_sorcery_copy(const struct ast_sorcery *sorcery, const void *object)
 827 {
 828         const struct ast_sorcery_object_details *details = object;
 829         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
 830         struct ast_sorcery_object_details *copy = ast_sorcery_alloc(sorcery, details->type, details->id);
 831         RAII_VAR(struct ast_variable *, objectset, NULL, ast_variables_destroy);
 832         int res = 0;
 833
 834         if (!copy) {
 835                 return NULL;
 836         } else if (object_type->copy) {
 837                 res = object_type->copy(object, copy);
 838         } else if ((objectset = ast_sorcery_objectset_create(sorcery, object))) {
 839                 res = ast_sorcery_objectset_apply(sorcery, copy, objectset);
 840         } else {
 841                 /* No native copy available and could not create an objectset, this copy has failed */
 842                 res = -1;
 843         }
 844
 845         if (res) {
 846                 ao2_cleanup(copy);
 847                 copy = NULL;
 848         }
 849
 850         return copy;
 851 }
 852
 853 int ast_sorcery_diff(const struct ast_sorcery *sorcery, const void *original, const void *modified, struct ast_variable **changes)
 854 {
 855         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, ast_sorcery_object_get_type(original), OBJ_KEY), ao2_cleanup);
 856
 857         *changes = NULL;
 858
 859         if (strcmp(ast_sorcery_object_get_type(original), ast_sorcery_object_get_type(modified))) {
 860                 return -1;
 861         }
 862
 863         if (original == modified) {
 864                 return 0;
 865         } else if (!object_type->diff) {
 866                 RAII_VAR(struct ast_variable *, objectset1, NULL, ast_variables_destroy);
 867                 RAII_VAR(struct ast_variable *, objectset2, NULL, ast_variables_destroy);
 868
 869                 objectset1 = ast_sorcery_objectset_create(sorcery, original);
 870                 objectset2 = ast_sorcery_objectset_create(sorcery, modified);
 871
 872                 return ast_sorcery_changeset_create(objectset1, objectset2, changes);
 873         } else {
 874                 return object_type->diff(original, modified, changes);
 875         }
 876 }
 877
 878 /*! \brief Structure used when calling create, update, or delete */
 879 struct sorcery_details {
 880         /*! \brief Pointer to the sorcery instance */
 881         const struct ast_sorcery *sorcery;
 882         /*! \brief Pointer to the object itself */
 883         void *obj;
 884 };
 885
 886 /*! \brief Internal function used to create an object in caching wizards */
 887 static int sorcery_cache_create(void *obj, void *arg, int flags)
 888 {
 889         const struct ast_sorcery_object_wizard *object_wizard = obj;
 890         const struct sorcery_details *details = arg;
 891
 892         if (!object_wizard->caching || !object_wizard->wizard->create) {
 893                 return 0;
 894         }
 895
 896         object_wizard->wizard->create(details->sorcery, object_wizard->data, details->obj);
 897
 898         return 0;
 899 }
 900
 901 void *ast_sorcery_retrieve_by_id(const struct ast_sorcery *sorcery, const char *type, const char *id)
 902 {
 903         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 904         void *object = NULL;
 905         struct ao2_iterator i;
 906         struct ast_sorcery_object_wizard *wizard;
 907         unsigned int cached = 0;
 908
 909         if (!object_type || ast_strlen_zero(id)) {
 910                 return NULL;
 911         }
 912
 913         i = ao2_iterator_init(object_type->wizards, 0);
 914         for (; (wizard = ao2_iterator_next(&i)); ao2_ref(wizard, -1)) {
 915                 if (wizard->wizard->retrieve_id &&
 916                     !(object = wizard->wizard->retrieve_id(sorcery, wizard->data, object_type->name, id))) {
 917                         continue;
 918                 }
 919
 920                 cached = wizard->caching;
 921
 922                 ao2_ref(wizard, -1);
 923                 break;
 924         }
 925         ao2_iterator_destroy(&i);
 926
 927         if (!cached && object) {
 928                 ao2_callback(object_type->wizards, 0, sorcery_cache_create, object);
 929         }
 930
 931         return object;
 932 }
 933
 934 void *ast_sorcery_retrieve_by_fields(const struct ast_sorcery *sorcery, const char *type, unsigned int flags, struct ast_variable *fields)
 935 {
 936         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 937         void *object = NULL;
 938         struct ao2_iterator i;
 939         struct ast_sorcery_object_wizard *wizard;
 940         unsigned int cached = 0;
 941
 942         if (!object_type) {
 943                 return NULL;
 944         }
 945
 946         /* If returning multiple objects create a container to store them in */
 947         if ((flags & AST_RETRIEVE_FLAG_MULTIPLE)) {
 948                 if (!(object = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
 949                         return NULL;
 950                 }
 951         }
 952
 953         /* Inquire with the available wizards for retrieval */
 954         i = ao2_iterator_init(object_type->wizards, 0);
 955         for (; (wizard = ao2_iterator_next(&i)); ao2_ref(wizard, -1)) {
 956                 if ((flags & AST_RETRIEVE_FLAG_MULTIPLE)) {
 957                         if (wizard->wizard->retrieve_multiple) {
 958                                 wizard->wizard->retrieve_multiple(sorcery, wizard->data, object_type->name, object, fields);
 959                         }
 960                 } else if (fields && wizard->wizard->retrieve_fields) {
 961                         if (wizard->wizard->retrieve_fields) {
 962                                 object = wizard->wizard->retrieve_fields(sorcery, wizard->data, object_type->name, fields);
 963                         }
 964                 }
 965
 966                 if ((flags & AST_RETRIEVE_FLAG_MULTIPLE) || !object) {
 967                         continue;
 968                 }
 969
 970                 cached = wizard->caching;
 971
 972                 ao2_ref(wizard, -1);
 973                 break;
 974         }
 975         ao2_iterator_destroy(&i);
 976
 977         /* If we are returning a single object and it came from a non-cache source create it in any caches */
 978         if (!(flags & AST_RETRIEVE_FLAG_MULTIPLE) && !cached && object) {
 979                 ao2_callback(object_type->wizards, 0, sorcery_cache_create, object);
 980         }
 981
 982         return object;
 983 }
 984
 985 struct ao2_container *ast_sorcery_retrieve_by_regex(const struct ast_sorcery *sorcery, const char *type, const char *regex)
 986 {
 987         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
 988         struct ao2_container *objects;
 989         struct ao2_iterator i;
 990         struct ast_sorcery_object_wizard *wizard;
 991
 992         if (!object_type || !(objects = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
 993                 return NULL;
 994         }
 995
 996         i = ao2_iterator_init(object_type->wizards, 0);
 997         for (; (wizard = ao2_iterator_next(&i)); ao2_ref(wizard, -1)) {
 998                 if (!wizard->wizard->retrieve_regex) {
 999                         continue;
1000                 }
1001
1002                 wizard->wizard->retrieve_regex(sorcery, wizard->data, object_type->name, objects, regex);
1003         }
1004         ao2_iterator_destroy(&i);
1005
1006         return objects;
1007 }
1008
1009 /*! \brief Internal function which returns if the wizard has created the object */
1010 static int sorcery_wizard_create(void *obj, void *arg, int flags)
1011 {
1012         const struct ast_sorcery_object_wizard *object_wizard = obj;
1013         const struct sorcery_details *details = arg;
1014
1015         return (!object_wizard->caching && !object_wizard->wizard->create(details->sorcery, object_wizard->data, details->obj)) ? CMP_MATCH | CMP_STOP : 0;
1016 }
1017
1018 int ast_sorcery_create(const struct ast_sorcery *sorcery, void *object)
1019 {
1020         const struct ast_sorcery_object_details *details = object;
1021         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
1022         RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
1023         struct sorcery_details sdetails = {
1024                 .sorcery = sorcery,
1025                 .obj = object,
1026         };
1027
1028         if (!object_type) {
1029                 return -1;
1030         }
1031
1032         object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_create, &sdetails);
1033
1034         return object_wizard ? 0 : -1;
1035 }
1036
1037 /*! \brief Internal function which returns if a wizard has updated the object */
1038 static int sorcery_wizard_update(void *obj, void *arg, int flags)
1039 {
1040         const struct ast_sorcery_object_wizard *object_wizard = obj;
1041         const struct sorcery_details *details = arg;
1042
1043         return (object_wizard->wizard->update && !object_wizard->wizard->update(details->sorcery, object_wizard->data, details->obj) &&
1044                 !object_wizard->caching) ? CMP_MATCH | CMP_STOP : 0;
1045 }
1046
1047 int ast_sorcery_update(const struct ast_sorcery *sorcery, void *object)
1048 {
1049         const struct ast_sorcery_object_details *details = object;
1050         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
1051         RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
1052         struct sorcery_details sdetails = {
1053                 .sorcery = sorcery,
1054                 .obj = object,
1055         };
1056
1057         if (!object_type) {
1058                 return -1;
1059         }
1060
1061         object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_update, &sdetails);
1062
1063         return object_wizard ? 0 : -1;
1064 }
1065
1066 /*! \brief Internal function which returns if a wizard has deleted the object */
1067 static int sorcery_wizard_delete(void *obj, void *arg, int flags)
1068 {
1069         const struct ast_sorcery_object_wizard *object_wizard = obj;
1070         const struct sorcery_details *details = arg;
1071
1072         return (object_wizard->wizard->delete && !object_wizard->wizard->delete(details->sorcery, object_wizard->data, details->obj) &&
1073                 !object_wizard->caching) ? CMP_MATCH | CMP_STOP : 0;
1074 }
1075
1076 int ast_sorcery_delete(const struct ast_sorcery *sorcery, void *object)
1077 {
1078         const struct ast_sorcery_object_details *details = object;
1079         RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
1080         RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
1081         struct sorcery_details sdetails = {
1082                 .sorcery = sorcery,
1083                 .obj = object,
1084         };
1085
1086         if (!object_type) {
1087                 return -1;
1088         }
1089
1090         object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_delete, &sdetails);
1091
1092         return object_wizard ? 0 : -1;
1093 }
1094
1095 void ast_sorcery_unref(struct ast_sorcery *sorcery)
1096 {
1097         ao2_cleanup(sorcery);
1098 }
1099
1100 const char *ast_sorcery_object_get_id(const void *object)
1101 {
1102         const struct ast_sorcery_object_details *details = object;
1103         return details->id;
1104 }
1105
1106 const char *ast_sorcery_object_get_type(const void *object)
1107 {
1108         const struct ast_sorcery_object_details *details = object;
1109         return details->type;
1110 }