Merge "res_calendar: Specialized calendars depend on symbols of general calendar."
[asterisk/asterisk.git] / main / optional_api.c
index f48fe11..9b9a1a0 100644 (file)
@@ -18,8 +18,6 @@
 
 #include "asterisk.h"
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
-
 #include "asterisk/optional_api.h"
 #include "asterisk/utils.h"
 
@@ -76,7 +74,7 @@ struct optional_api {
 static void optional_api_user_destroy(struct optional_api_user *user)
 {
        *user->optional_ref = user->stub;
-       free(user);
+       ast_std_free(user);
 }
 
 /*!
@@ -95,7 +93,7 @@ static struct optional_api_user *optional_api_user_create(
        struct optional_api_user *user;
        size_t size = sizeof(*user) + strlen(module) + 1;
 
-       user = calloc(1, size);
+       user = ast_std_calloc(1, size);
        if (!user) {
                return NULL;
        }
@@ -117,10 +115,10 @@ static void optional_api_destroy(struct optional_api *api)
        while (api->users_len--) {
                optional_api_user_destroy(api->users[api->users_len]);
        }
-       free(api->users);
+       ast_std_free(api->users);
        api->users = NULL;
        api->users_maxlen = 0;
-       free(api);
+       ast_std_free(api);
 }
 
 /*!
@@ -135,9 +133,8 @@ static struct optional_api *optional_api_create(const char *symname)
        struct optional_api *api;
        size_t size;
 
-       ast_verb(6, "%s: building api object\n", symname);
        size = sizeof(*api) + strlen(symname) + 1;
-       api = calloc(1, size);
+       api = ast_std_calloc(1, size);
        if (!api) {
                ast_log(LOG_ERROR, "Failed to allocate api\n");
                return NULL;
@@ -158,18 +155,8 @@ struct {
        size_t len;
 } apis;
 
-void optional_api_cleanup(void)
-{
-       while (apis.len--) {
-               optional_api_destroy(apis.list[apis.len]);
-       }
-       free(apis.list);
-       apis.list = NULL;
-       apis.maxlen = 0;
-}
-
 /*!
- * \brief Gets (or creates) the \ref optional_api for the give function.
+ * \brief Gets (or creates) the \ref optional_api for the given function.
  *
  * \param sysname Name of the function to look up.
  * \return Corresponding \ref optional_api.
@@ -181,21 +168,26 @@ static struct optional_api *get_api(const char *symname)
        size_t i;
 
        /* Find one, if we already have it */
-       for (i = 0; i < apis.len; ++i) {
-               if (strcmp(symname, apis.list[i]->symname) == 0) {
-                       return apis.list[i];
+       if (apis.list) {
+               for (i = 0; i < apis.len; ++i) {
+                       if (strcmp(symname, apis.list[i]->symname) == 0) {
+                               return apis.list[i];
+                       }
                }
        }
 
        /* API not found. Build one */
        api = optional_api_create(symname);
+       if (!api) {
+               return NULL;
+       }
 
        /* Grow the list, if needed */
        if (apis.len + 1 > apis.maxlen) {
                size_t new_maxlen = apis.maxlen ? 2 * apis.maxlen : 1;
-               struct optional_api **new_list =
-                       realloc(apis.list, new_maxlen * sizeof(*new_list));
+               struct optional_api **new_list;
 
+               new_list = ast_std_realloc(apis.list, new_maxlen * sizeof(*new_list));
                if (!new_list) {
                        optional_api_destroy(api);
                        ast_log(LOG_ERROR, "Failed to allocate api list\n");
@@ -224,11 +216,8 @@ static void optional_api_user_relink(struct optional_api_user *user,
        struct optional_api *api)
 {
        if (api->impl && *user->optional_ref != api->impl) {
-               ast_verb(4, "%s: linking for %s\n", api->symname, user->module);
                *user->optional_ref = api->impl;
        } else if (!api->impl && *user->optional_ref != user->stub) {
-               ast_verb(4, "%s: stubbing for %s\n", api->symname,
-                       user->module);
                *user->optional_ref = user->stub;
        }
 }
@@ -257,8 +246,6 @@ void ast_optional_api_provide(const char *symname, ast_optional_fn impl)
 {
        struct optional_api *api;
 
-       ast_verb(4, "%s: providing\n", symname);
-
        api = get_api(symname);
        if (!api) {
                ast_log(LOG_ERROR, "%s: Allocation failed\n", symname);
@@ -273,8 +260,6 @@ void ast_optional_api_unprovide(const char *symname, ast_optional_fn impl)
 {
        struct optional_api *api;
 
-       ast_verb(4, "%s: un-providing\n", symname);
-
        api = get_api(symname);
        if (!api) {
                ast_log(LOG_ERROR, "%s: Could not find api\n", symname);
@@ -308,11 +293,10 @@ void ast_optional_api_use(const char *symname, ast_optional_fn *optional_ref,
 
        /* Add user to the API */
        if (api->users_len + 1 > api->users_maxlen) {
-               size_t new_maxlen = api->users_maxlen ?
-                       2 * api->users_maxlen : 1;
-               struct optional_api_user **new_list =
-                       realloc(api->users, new_maxlen * sizeof(*new_list));
+               size_t new_maxlen = api->users_maxlen ? 2 * api->users_maxlen : 1;
+               struct optional_api_user **new_list;
 
+               new_list = ast_std_realloc(api->users, new_maxlen * sizeof(*new_list));
                if (!new_list) {
                        optional_api_user_destroy(user);
                        ast_log(LOG_ERROR, "Failed to allocate api list\n");
@@ -344,10 +328,9 @@ void ast_optional_api_unuse(const char *symname, ast_optional_fn *optional_ref,
 
        for (i = 0; i < api->users_len; ++i) {
                struct optional_api_user *user = api->users[i];
+
                if (user->optional_ref == optional_ref) {
                        if (*user->optional_ref != user->stub) {
-                               ast_verb(4, "%s: stubbing for %s\n", symname,
-                                       module);
                                *user->optional_ref = user->stub;
                        }