loader: Correct overly strict startup checks.
[asterisk/asterisk.git] / main / ccss.c
index c1b3372..ed0bba7 100644 (file)
@@ -36,8 +36,6 @@
 
 #include "asterisk.h"
 
-ASTERISK_REGISTER_FILE()
-
 #include "asterisk/astobj2.h"
 #include "asterisk/strings.h"
 #include "asterisk/ccss.h"
@@ -682,11 +680,7 @@ void ast_cc_default_config_params(struct ast_cc_config_params *params)
 
 struct ast_cc_config_params *__ast_cc_config_params_init(const char *file, int line, const char *function)
 {
-#if defined(__AST_DEBUG_MALLOC)
        struct ast_cc_config_params *params = __ast_malloc(sizeof(*params), file, line, function);
-#else
-       struct ast_cc_config_params *params = ast_malloc(sizeof(*params));
-#endif
 
        if (!params) {
                return NULL;
@@ -1028,9 +1022,9 @@ void ast_set_cc_callback_sub(struct ast_cc_config_params *config, const char * c
 
 static int cc_publish(struct stasis_message_type *message_type, int core_id, struct ast_json *extras)
 {
-       RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
-       RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
-       RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
+       struct ast_json *blob;
+       struct ast_json_payload *payload;
+       struct stasis_message *message;
 
        if (!message_type) {
                return -1;
@@ -1046,121 +1040,138 @@ static int cc_publish(struct stasis_message_type *message_type, int core_id, str
                ast_json_object_update(blob, extras);
        }
 
-       if (!(payload = ast_json_payload_create(blob))) {
+       payload = ast_json_payload_create(blob);
+       ast_json_unref(blob);
+
+       if (!payload) {
                return -1;
        }
 
-       if (!(message = stasis_message_create(message_type, payload))) {
+       message = stasis_message_create(message_type, payload);
+       ao2_ref(payload, -1);
+
+       if (!message) {
                return -1;
        }
 
        stasis_publish(ast_system_topic(), message);
+       ao2_ref(message, -1);
 
        return 0;
 }
 
 static void cc_publish_available(int core_id, const char *callee, const char *service)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s, s: s}",
                "callee", callee,
                "service", service);
 
        cc_publish(ast_cc_available_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_offertimerstart(int core_id, const char *caller, unsigned int expires)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s, s: i}",
                "caller", caller,
                "expires", expires);
 
        cc_publish(ast_cc_offertimerstart_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_requested(int core_id, const char *caller, const char *callee)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s, s: s}",
                "caller", caller,
                "callee", callee);
 
        cc_publish(ast_cc_requested_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_requestacknowledged(int core_id, const char *caller)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "caller", caller);
 
        cc_publish(ast_cc_requestacknowledged_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_callerstopmonitoring(int core_id, const char *caller)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "caller", caller);
 
        cc_publish(ast_cc_callerstopmonitoring_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_callerstartmonitoring(int core_id, const char *caller)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "caller", caller);
 
        cc_publish(ast_cc_callerstartmonitoring_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_callerrecalling(int core_id, const char *caller)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "caller", caller);
 
        cc_publish(ast_cc_callerrecalling_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_recallcomplete(int core_id, const char *caller)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "caller", caller);
 
        cc_publish(ast_cc_recallcomplete_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_failure(int core_id, const char *caller, const char *reason)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s, s: s}",
                "caller", caller,
                "reason", reason);
 
        cc_publish(ast_cc_failure_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 static void cc_publish_monitorfailed(int core_id, const char *callee)
 {
-       RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
+       struct ast_json *extras;
 
        extras = ast_json_pack("{s: s}",
                "callee", callee);
 
        cc_publish(ast_cc_monitorfailed_type(), core_id, extras);
+       ast_json_unref(extras);
 }
 
 struct cc_monitor_backend {
@@ -1369,19 +1380,8 @@ struct generic_monitor_pvt {
        int core_id;
 };
 
-static int generic_monitor_hash_fn(const void *obj, const int flags)
-{
-       const struct generic_monitor_instance_list *generic_list = obj;
-       return ast_str_hash(generic_list->device_name);
-}
-
-static int generic_monitor_cmp_fn(void *obj, void *arg, int flags)
-{
-       const struct generic_monitor_instance_list *generic_list1 = obj;
-       const struct generic_monitor_instance_list *generic_list2 = arg;
-
-       return !strcmp(generic_list1->device_name, generic_list2->device_name) ? CMP_MATCH | CMP_STOP : 0;
-}
+AO2_STRING_FIELD_HASH_FN(generic_monitor_instance_list, device_name)
+AO2_STRING_FIELD_CMP_FN(generic_monitor_instance_list, device_name)
 
 static struct generic_monitor_instance_list *find_generic_monitor_instance_list(const char * const device_name)
 {
@@ -2237,9 +2237,7 @@ static void call_destructor_with_no_monitor(const char * const monitor_type, voi
  * Note that it is not necessarily erroneous to add the same
  * device to the tree twice. If the same device is called by
  * two different extension during the same call, then
- * that is a legitimate situation. Of course, I'm pretty sure
- * the dialed_interfaces global datastore will not allow that
- * to happen anyway.
+ * that is a legitimate situation.
  *
  * \param device_name The name of the device being added to the tree
  * \param dialstring The dialstring used to dial the device being added
@@ -2844,7 +2842,7 @@ static void *generic_recall(void *data)
                return NULL;
        }
        ao2_ref(tmp_cap, -1);
-       
+
        /* We have a channel. It's time now to set up the datastore of recalled CC interfaces.
         * This will be a common task for all recall functions. If it were possible, I'd have
         * the core do it automatically, but alas I cannot. Instead, I will provide a public
@@ -3554,7 +3552,7 @@ struct ast_cc_monitor *ast_cc_get_monitor_by_recall_core_id(const int core_id, c
  */
 static void cc_unique_append(struct ast_str **str, const char *dialstring)
 {
-       char dialstring_search[AST_CHANNEL_NAME];
+       char dialstring_search[AST_CHANNEL_NAME + 1];
 
        if (ast_strlen_zero(dialstring)) {
                /* No dialstring to append. */
@@ -4574,11 +4572,9 @@ static char *complete_core_id(const char *line, const char *word, int pos, int s
 
 static char *handle_cc_kill(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
-       static const char * const option[] = { "core", "all", NULL };
-
        switch (cmd) {
        case CLI_INIT:
-               e->command = "cc cancel";
+               e->command = "cc cancel [core|all]";
                e->usage =
                        "Usage: cc cancel can be used in two ways.\n"
                        "       1. 'cc cancel core [core ID]' will cancel the CC transaction with\n"
@@ -4586,10 +4582,7 @@ static char *handle_cc_kill(struct ast_cli_entry *e, int cmd, struct ast_cli_arg
                        "       2. 'cc cancel all' will cancel all active CC transactions.\n";
                return NULL;
        case CLI_GENERATE:
-               if (a->pos == 2) {
-                       return ast_cli_complete(a->word, option, a->n);
-               }
-               if (a->pos == 3) {
+               if (a->pos == 3 && !strcasecmp(a->argv[2], "core")) {
                        return complete_core_id(a->line, a->word, a->pos, a->n);
                }
                return NULL;
@@ -4661,11 +4654,11 @@ int ast_cc_init(void)
                return -1;
        }
        if (!(generic_monitors = ao2_t_container_alloc(CC_CORE_INSTANCES_BUCKETS,
-                                       generic_monitor_hash_fn, generic_monitor_cmp_fn,
-                                       "Create generic monitor container"))) {
+                       generic_monitor_instance_list_hash_fn, generic_monitor_instance_list_cmp_fn,
+                       "Create generic monitor container"))) {
                return -1;
        }
-       if (!(cc_core_taskprocessor = ast_taskprocessor_get("CCSS core", TPS_REF_DEFAULT))) {
+       if (!(cc_core_taskprocessor = ast_taskprocessor_get("CCSS_core", TPS_REF_DEFAULT))) {
                return -1;
        }
        if (!(cc_sched_context = ast_sched_context_create())) {