int ast_ari_bridges_play_parse_body( struct ast_json *body, struct ast_ari_bridges_play_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "media"); if (field) { args->media = ast_json_string_get(field); } field = ast_json_object_get(body, "lang"); if (field) { args->lang = ast_json_string_get(field); } field = ast_json_object_get(body, "offsetms"); if (field) { args->offsetms = ast_json_integer_get(field); } field = ast_json_object_get(body, "skipms"); if (field) { args->skipms = ast_json_integer_get(field); } field = ast_json_object_get(body, "playbackId"); if (field) { args->playback_id = ast_json_string_get(field); } return 0; }
int create_queue(struct ast_json* j_queue) { int ret; char* uuid; struct ast_json* j_tmp; if(j_queue == NULL) { return false; } j_tmp = ast_json_deep_copy(j_queue); uuid = gen_uuid(); ast_json_object_set(j_tmp, "uuid", ast_json_string_create(uuid)); ast_log(LOG_NOTICE, "Create queue. uuid[%s], name[%s]\n", ast_json_string_get(ast_json_object_get(j_tmp, "uuid")), ast_json_string_get(ast_json_object_get(j_tmp, "name")) ); ret = db_insert("queue", j_tmp); AST_JSON_UNREF(j_tmp); if(ret == false) { ast_free(uuid); return false; } // send ami event j_tmp = get_queue(uuid); send_manager_evt_out_queue_create(j_tmp); AST_JSON_UNREF(j_tmp); return true; }
static struct ast_manager_event_blob *varset_to_ami(struct stasis_message *msg) { RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free); struct ast_channel_blob *obj = stasis_message_data(msg); const char *variable = ast_json_string_get(ast_json_object_get(obj->blob, "variable")); const char *value = ast_json_string_get(ast_json_object_get(obj->blob, "value")); if (obj->snapshot) { channel_event_string = ast_manager_build_channel_state_string(obj->snapshot); } else { channel_event_string = ast_str_create(35); ast_str_set(&channel_event_string, 0, "Channel: none\r\n" "Uniqueid: none\r\n"); } if (!channel_event_string) { return NULL; } return ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet", "%s" "Variable: %s\r\n" "Value: %s\r\n", ast_str_buffer(channel_event_string), variable, value); }
static struct ast_manager_event_blob *contactstatus_to_ami(struct stasis_message *msg) { struct ast_endpoint_blob *obj = stasis_message_data(msg); RAII_VAR(struct ast_str *, contactstatus_event_string, ast_str_create(64), ast_free); const char *value; if (!(value = ast_json_string_get(ast_json_object_get(obj->blob, "uri")))) { return NULL; } ast_str_append(&contactstatus_event_string, 0, "URI: %s\r\n", value); if (!(value = ast_json_string_get(ast_json_object_get(obj->blob, "contact_status")))) { return NULL; } ast_str_append(&contactstatus_event_string, 0, "ContactStatus: %s\r\n", value); if (!(value = ast_json_string_get(ast_json_object_get(obj->blob, "aor")))) { return NULL; } ast_str_append(&contactstatus_event_string, 0, "AOR: %s\r\n", value); if (!(value = ast_json_string_get(ast_json_object_get(obj->blob, "endpoint_name")))) { return NULL; } ast_str_append(&contactstatus_event_string, 0, "EndpointName: %s\r\n", value); if ((value = ast_json_string_get(ast_json_object_get(obj->blob, "roundtrip_usec")))) { ast_str_append(&contactstatus_event_string, 0, "RoundtripUsec: %s\r\n", value); } return ast_manager_event_blob_create(EVENT_FLAG_SYSTEM, "ContactStatus", "%s", ast_str_buffer(contactstatus_event_string)); }
static struct ast_json *dtmf_end_to_json( struct stasis_message *message, const struct stasis_message_sanitizer *sanitize) { struct ast_channel_blob *channel_blob = stasis_message_data(message); struct ast_json *blob = channel_blob->blob; struct ast_channel_snapshot *snapshot = channel_blob->snapshot; const char *direction = ast_json_string_get(ast_json_object_get(blob, "direction")); const struct timeval *tv = stasis_message_timestamp(message); struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, sanitize); /* Only present received DTMF end events as JSON */ if (strcasecmp("Received", direction) != 0) { return NULL; } if (!json_channel) { return NULL; } return ast_json_pack("{s: s, s: o, s: O, s: O, s: o}", "type", "ChannelDtmfReceived", "timestamp", ast_json_timeval(*tv, NULL), "digit", ast_json_object_get(blob, "digit"), "duration_ms", ast_json_object_get(blob, "duration_ms"), "channel", json_channel); }
/*! * \brief Callback handler for Stasis application messages. */ static void app_handler(void *data, const char *app_name, struct ast_json *message) { struct event_session *session = data; int res; const char *msg_type = S_OR( ast_json_string_get(ast_json_object_get(message, "type")), ""); const char *msg_application = S_OR( ast_json_string_get(ast_json_object_get(message, "application")), ""); /* Determine if we've been replaced */ if (strcmp(msg_type, "ApplicationReplaced") == 0 && strcmp(msg_application, app_name) == 0) { ao2_find(session->websocket_apps, msg_application, OBJ_UNLINK | OBJ_NODATA); } res = ast_json_object_set(message, "application", ast_json_string_create(app_name)); if(res != 0) { return; } ao2_lock(session); if (session->ws_session) { ast_ari_websocket_session_write(session->ws_session, message); } ao2_unlock(session); }
static struct ast_manager_event_blob *peerstatus_to_ami(struct stasis_message *msg) { struct ast_endpoint_blob *obj = stasis_message_data(msg); RAII_VAR(struct ast_str *, peerstatus_event_string, ast_str_create(64), ast_free); const char *value; /* peer_status is the only *required* thing */ if (!(value = ast_json_string_get(ast_json_object_get(obj->blob, "peer_status")))) { return NULL; } ast_str_append(&peerstatus_event_string, 0, "PeerStatus: %s\r\n", value); if ((value = ast_json_string_get(ast_json_object_get(obj->blob, "cause")))) { ast_str_append(&peerstatus_event_string, 0, "Cause: %s\r\n", value); } if ((value = ast_json_string_get(ast_json_object_get(obj->blob, "address")))) { ast_str_append(&peerstatus_event_string, 0, "Address: %s\r\n", value); } if ((value = ast_json_string_get(ast_json_object_get(obj->blob, "port")))) { ast_str_append(&peerstatus_event_string, 0, "Port: %s\r\n", value); } if ((value = ast_json_string_get(ast_json_object_get(obj->blob, "time")))) { ast_str_append(&peerstatus_event_string, 0, "Time: %s\r\n", value); } return ast_manager_event_blob_create(EVENT_FLAG_SYSTEM, "PeerStatus", "ChannelType: %s\r\n" "Peer: %s/%s\r\n" "%s", obj->snapshot->tech, obj->snapshot->tech, obj->snapshot->resource, ast_str_buffer(peerstatus_event_string)); }
static struct ast_manager_event_blob *system_registry_to_ami(struct stasis_message *message) { struct ast_json_payload *payload = stasis_message_data(message); const char *channeltype; const char *username; const char *domain; const char *status; const char *cause; RAII_VAR(struct ast_str *, cause_string, ast_str_create(32), ast_free); if (!cause_string) { return NULL; } channeltype = ast_json_string_get(ast_json_object_get(payload->json, "channeltype")); username = ast_json_string_get(ast_json_object_get(payload->json, "username")); domain = ast_json_string_get(ast_json_object_get(payload->json, "domain")); status = ast_json_string_get(ast_json_object_get(payload->json, "status")); cause = ast_json_string_get(ast_json_object_get(payload->json, "cause")); if (!ast_strlen_zero(cause)) { ast_str_set(&cause_string, 0, "Cause: %s\r\n", cause); } return ast_manager_event_blob_create(EVENT_FLAG_SYSTEM, "Registry", "ChannelType: %s\r\n" "Username: %s\r\n" "Domain: %s\r\n" "Status: %s\r\n" "%s", channeltype, username, domain, status, ast_str_buffer(cause_string)); }
/*! * \internal * Shared code for all handlers */ static void handler(const char *name, int response_code, struct ast_variable *get_params, struct ast_variable *path_vars, struct ast_variable *headers, struct ast_ari_response *response) { struct ast_json *message = ast_json_pack("{s: s, s: {}, s: {}, s: {}}", "name", name, "get_params", "path_vars", "headers"); struct ast_json *get_params_obj = ast_json_object_get(message, "get_params"); struct ast_json *path_vars_obj = ast_json_object_get(message, "path_vars"); struct ast_json *headers_obj = ast_json_object_get(message, "headers"); for (; get_params != NULL; get_params = get_params->next) { ast_json_object_set(get_params_obj, get_params->name, ast_json_string_create(get_params->value)); } for (; path_vars != NULL; path_vars = path_vars->next) { ast_json_object_set(path_vars_obj, path_vars->name, ast_json_string_create(path_vars->value)); } for (; headers != NULL; headers = headers->next) { ast_json_object_set(headers_obj, headers->name, ast_json_string_create(headers->value)); } ++invocation_count; response->response_code = response_code; response->message = message; }
static struct ast_json *contactstatus_to_json(struct stasis_message *msg, const struct stasis_message_sanitizer *sanitize) { struct ast_endpoint_blob *obj = stasis_message_data(msg); struct ast_json *json_endpoint; struct ast_json *json_final; const struct timeval *tv = stasis_message_timestamp(msg); json_endpoint = ast_endpoint_snapshot_to_json(obj->snapshot, NULL); if (!json_endpoint) { return NULL; } json_final = ast_json_pack("{s: s, s: o, s: o, s: { s: s, s: s, s: s, s: s } } ", "type", "ContactStatusChange", "timestamp", ast_json_timeval(*tv, NULL), "endpoint", json_endpoint, "contact_info", "uri", ast_json_string_get(ast_json_object_get(obj->blob, "uri")), "contact_status", ast_json_string_get(ast_json_object_get(obj->blob, "contact_status")), "aor", ast_json_string_get(ast_json_object_get(obj->blob, "aor")), "roundtrip_usec", ast_json_string_get(ast_json_object_get(obj->blob, "roundtrip_usec"))); if (!json_final) { ast_json_unref(json_endpoint); } return json_final; }
struct ast_json *app_to_json(const struct stasis_app *app) { struct ast_json *json; struct ast_json *channels; struct ast_json *bridges; struct ast_json *endpoints; struct ao2_iterator i; struct app_forwards *forwards; json = ast_json_pack("{s: s, s: [], s: [], s: []}", "name", app->name, "channel_ids", "bridge_ids", "endpoint_ids"); if (!json) { return NULL; } channels = ast_json_object_get(json, "channel_ids"); bridges = ast_json_object_get(json, "bridge_ids"); endpoints = ast_json_object_get(json, "endpoint_ids"); i = ao2_iterator_init(app->forwards, 0); while ((forwards = ao2_iterator_next(&i))) { struct ast_json *array = NULL; int append_res; switch (forwards->forward_type) { case FORWARD_CHANNEL: array = channels; break; case FORWARD_BRIDGE: array = bridges; break; case FORWARD_ENDPOINT: array = endpoints; break; } /* If forward_type value is unexpected this will safely return an error. */ append_res = ast_json_array_append(array, ast_json_string_create(forwards->id)); ao2_ref(forwards, -1); if (append_res != 0) { ast_log(LOG_ERROR, "Error building response\n"); ao2_iterator_destroy(&i); ast_json_unref(json); return NULL; } } ao2_iterator_destroy(&i); return json; }
static struct ast_manager_event_blob *cc_monitorfailed_to_ami(struct stasis_message *message) { struct ast_json_payload *payload = stasis_message_data(message); int core_id; const char *callee; core_id = ast_json_integer_get(ast_json_object_get(payload->json, "core_id")); callee = ast_json_string_get(ast_json_object_get(payload->json, "callee")); return ast_manager_event_blob_create(EVENT_FLAG_CC, "CCMonitorFailed", "CoreID: %d\r\n" "Callee: %s\r\n", core_id, callee); }
static struct ast_manager_event_blob *cc_recallcomplete_to_ami(struct stasis_message *message) { struct ast_json_payload *payload = stasis_message_data(message); int core_id; const char *caller; core_id = ast_json_integer_get(ast_json_object_get(payload->json, "core_id")); caller = ast_json_string_get(ast_json_object_get(payload->json, "caller")); return ast_manager_event_blob_create(EVENT_FLAG_CC, "CCRecallComplete", "CoreID: %d\r\n" "Caller: %s\r\n", core_id, caller); }
struct ast_json *app_to_json(const struct stasis_app *app) { RAII_VAR(struct ast_json *, json, NULL, ast_json_unref); struct ast_json *channels; struct ast_json *bridges; struct ast_json *endpoints; struct ao2_iterator i; void *obj; json = ast_json_pack("{s: s, s: [], s: [], s: []}", "name", app->name, "channel_ids", "bridge_ids", "endpoint_ids"); channels = ast_json_object_get(json, "channel_ids"); bridges = ast_json_object_get(json, "bridge_ids"); endpoints = ast_json_object_get(json, "endpoint_ids"); i = ao2_iterator_init(app->forwards, 0); while ((obj = ao2_iterator_next(&i))) { RAII_VAR(struct app_forwards *, forwards, obj, ao2_cleanup); RAII_VAR(struct ast_json *, id, NULL, ast_json_unref); int append_res = -1; id = ast_json_string_create(forwards->id); switch (forwards->forward_type) { case FORWARD_CHANNEL: append_res = ast_json_array_append(channels, ast_json_ref(id)); break; case FORWARD_BRIDGE: append_res = ast_json_array_append(bridges, ast_json_ref(id)); break; case FORWARD_ENDPOINT: append_res = ast_json_array_append(endpoints, ast_json_ref(id)); break; } if (append_res != 0) { ast_log(LOG_ERROR, "Error building response\n"); ao2_iterator_destroy(&i); return NULL; } } ao2_iterator_destroy(&i); return ast_json_ref(json); }
int ast_ari_sounds_list_parse_body( struct ast_json *body, struct ast_ari_sounds_list_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "lang"); if (field) { args->lang = ast_json_string_get(field); } field = ast_json_object_get(body, "format"); if (field) { args->format = ast_json_string_get(field); } return 0; }
static void security_event_stasis_cb(struct ast_json *json) { struct ast_str *str; struct ast_json *event_type_json; enum ast_security_event_type event_type; event_type_json = ast_json_object_get(json, "SecurityEvent"); event_type = ast_json_integer_get(event_type_json); ast_assert(event_type >= 0 && event_type < AST_SECURITY_EVENT_NUM_TYPES); if (!(str = ast_str_thread_get(&security_event_buf, SECURITY_EVENT_BUF_INIT_LEN))) { return; } ast_str_set(&str, 0, "SecurityEvent=\"%s\"", ast_security_event_get_name(event_type)); append_json(&str, json, ast_security_event_get_required_ies(event_type), REQUIRED); append_json(&str, json, ast_security_event_get_optional_ies(event_type), NOT_REQUIRED); ast_log_dynamic_level(LOG_SECURITY, "%s\n", ast_str_buffer(str)); }
/*! * \brief Send a message to the given application. * \param app App to send the message to. * \param message Message to send. */ void app_send(struct stasis_app *app, struct ast_json *message) { stasis_app_cb handler; char eid[20]; RAII_VAR(void *, data, NULL, ao2_cleanup); if (ast_json_object_set(message, "asterisk_id", ast_json_string_create( ast_eid_to_str(eid, sizeof(eid), &ast_eid_default)))) { ast_log(AST_LOG_WARNING, "Failed to append EID to outgoing event %s\n", ast_json_string_get(ast_json_object_get(message, "type"))); } /* Copy off mutable state with lock held */ { SCOPED_AO2LOCK(lock, app); handler = app->handler; if (app->data) { ao2_ref(app->data, +1); data = app->data; } /* Name is immutable; no need to copy */ } if (!handler) { ast_verb(3, "Inactive Stasis app '%s' missed message\n", app->name); return; } handler(data, app->name, message); }
static void confbridge_publish_manager_event( struct stasis_message *message, const char *event, struct ast_str *extra_text) { struct ast_bridge_blob *blob = stasis_message_data(message); const char *conference_name; RAII_VAR(struct ast_str *, bridge_text, NULL, ast_free); RAII_VAR(struct ast_str *, channel_text, NULL, ast_free); ast_assert(blob != NULL); ast_assert(event != NULL); bridge_text = ast_manager_build_bridge_state_string(blob->bridge); if (!bridge_text) { return; } conference_name = ast_json_string_get(ast_json_object_get(blob->blob, "conference")); ast_assert(conference_name != NULL); if (blob->channel) { channel_text = ast_manager_build_channel_state_string(blob->channel); } manager_event(EVENT_FLAG_CALL, event, "Conference: %s\r\n" "%s" "%s" "%s", conference_name, ast_str_buffer(bridge_text), S_COR(channel_text, ast_str_buffer(channel_text), ""), S_COR(extra_text, ast_str_buffer(extra_text), "")); }
static void channel_enter_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message) { static const char *swap_name = "SwapUniqueid: "; struct ast_bridge_blob *blob = stasis_message_data(message); RAII_VAR(struct ast_str *, bridge_text, NULL, ast_free); RAII_VAR(struct ast_str *, channel_text, NULL, ast_free); const char *swap_id; bridge_text = ast_manager_build_bridge_state_string(blob->bridge); channel_text = ast_manager_build_channel_state_string(blob->channel); if (!bridge_text || !channel_text) { return; } swap_id = ast_json_string_get(ast_json_object_get(blob->blob, "swap")); manager_event(EVENT_FLAG_CALL, "BridgeEnter", "%s" "%s" "%s%s%s", ast_str_buffer(bridge_text), ast_str_buffer(channel_text), swap_id ? swap_name : "", S_OR(swap_id, ""), swap_id ? "\r\n" : ""); }
/*! \brief Generic MWI event callback used for one-off events from voicemail modules */ static void mwi_app_event_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message) { struct ast_mwi_blob *payload = stasis_message_data(message); RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free); RAII_VAR(struct ast_str *, event_buffer, NULL, ast_free); struct ast_json *event_json = ast_json_object_get(payload->blob, "Event"); if (!event_json) { return; } if (payload->mwi_state && payload->mwi_state->snapshot) { channel_event_string = ast_manager_build_channel_state_string(payload->mwi_state->snapshot); } event_buffer = ast_manager_str_from_json_object(payload->blob, exclude_event_cb); if (!event_buffer) { ast_log(AST_LOG_WARNING, "Failed to create payload for event %s\n", ast_json_string_get(event_json)); return; } manager_event(EVENT_FLAG_CALL, ast_json_string_get(event_json), "Mailbox: %s\r\n" "%s" "%s", payload->mwi_state ? payload->mwi_state->uniqueid : "Unknown", ast_str_buffer(event_buffer), channel_event_string ? ast_str_buffer(channel_event_string) : ""); }
int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other) { #if JANSSON_VERSION_HEX >= 0x020300 return json_object_update_missing((json_t *)object, (json_t *)other); #else struct ast_json_iter *iter = ast_json_object_iter(other); int ret = 0; if (object == NULL || other == NULL) { return -1; } while (iter != NULL && ret == 0) { const char *key = ast_json_object_iter_key(iter); if (ast_json_object_get(object, key) == NULL) { struct ast_json *value = ast_json_object_iter_value(iter); if (!value || ast_json_object_set(object, key, ast_json_ref(value))) { ret = -1; } } iter = ast_json_object_iter_next(other, iter); } return ret; #endif }
int ast_ari_asterisk_set_global_var_parse_body( struct ast_json *body, struct ast_ari_asterisk_set_global_var_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "variable"); if (field) { args->variable = ast_json_string_get(field); } field = ast_json_object_get(body, "value"); if (field) { args->value = ast_json_string_get(field); } return 0; }
int ast_ari_endpoints_send_message_to_endpoint_parse_body( struct ast_json *body, struct ast_ari_endpoints_send_message_to_endpoint_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "from"); if (field) { args->from = ast_json_string_get(field); } field = ast_json_object_get(body, "body"); if (field) { args->body = ast_json_string_get(field); } return 0; }
int ast_ari_mailboxes_update_parse_body( struct ast_json *body, struct ast_ari_mailboxes_update_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "oldMessages"); if (field) { args->old_messages = ast_json_integer_get(field); } field = ast_json_object_get(body, "newMessages"); if (field) { args->new_messages = ast_json_integer_get(field); } return 0; }
int ast_ari_bridges_create_with_id_parse_body( struct ast_json *body, struct ast_ari_bridges_create_with_id_args *args) { struct ast_json *field; /* Parse query parameters out of it */ field = ast_json_object_get(body, "type"); if (field) { args->type = ast_json_string_get(field); } field = ast_json_object_get(body, "name"); if (field) { args->name = ast_json_string_get(field); } return 0; }
/*! * \brief Send a message to the given application. * \param app App to send the message to. * \param message Message to send. */ void app_send(struct stasis_app *app, struct ast_json *message) { stasis_app_cb handler; char eid[20]; void *data; if (ast_json_object_set(message, "asterisk_id", ast_json_string_create( ast_eid_to_str(eid, sizeof(eid), &ast_eid_default)))) { ast_log(AST_LOG_WARNING, "Failed to append EID to outgoing event %s\n", ast_json_string_get(ast_json_object_get(message, "type"))); } /* Copy off mutable state with lock held */ ao2_lock(app); handler = app->handler; data = ao2_bump(app->data); ao2_unlock(app); /* Name is immutable; no need to copy */ if (handler) { handler(data, app->name, message); } else { ast_verb(3, "Inactive Stasis app '%s' missed message\n", app->name); } ao2_cleanup(data); }
static struct ast_manager_event_blob *cc_available_to_ami(struct stasis_message *message) { struct ast_json_payload *payload = stasis_message_data(message); int core_id; const char *callee; const char *service; core_id = ast_json_integer_get(ast_json_object_get(payload->json, "core_id")); callee = ast_json_string_get(ast_json_object_get(payload->json, "callee")); service = ast_json_string_get(ast_json_object_get(payload->json, "service")); return ast_manager_event_blob_create(EVENT_FLAG_CC, "CCAvailable", "CoreID: %d\r\n" "Callee: %s\r\n" "Service: %s\r\n", core_id, callee, service); }
static struct ast_manager_event_blob *cc_offertimerstart_to_ami(struct stasis_message *message) { struct ast_json_payload *payload = stasis_message_data(message); int core_id; const char *caller; unsigned int expires; core_id = ast_json_integer_get(ast_json_object_get(payload->json, "core_id")); caller = ast_json_string_get(ast_json_object_get(payload->json, "caller")); expires = ast_json_integer_get(ast_json_object_get(payload->json, "expires")); return ast_manager_event_blob_create(EVENT_FLAG_CC, "CCOfferTimerStart", "CoreID: %d\r\n" "Caller: %s\r\n" "Expires: %u\r\n", core_id, caller, expires); }
/** * Create plan. * @param j_plan * @return */ bool create_plan(const struct ast_json* j_plan) { int ret; char* uuid; struct ast_json* j_tmp; char* tmp; if(j_plan == NULL) { return false; } j_tmp = ast_json_deep_copy(j_plan); uuid = gen_uuid(); ast_json_object_set(j_tmp, "uuid", ast_json_string_create(uuid)); tmp = get_utc_timestamp(); ast_json_object_set(j_tmp, "tm_create", ast_json_string_create(tmp)); ast_free(tmp); ast_log(LOG_NOTICE, "Create plan. uuid[%s], name[%s]\n", ast_json_string_get(ast_json_object_get(j_tmp, "uuid")), ast_json_string_get(ast_json_object_get(j_tmp, "name"))? : "<unknown>" ); ret = db_insert("plan", j_tmp); AST_JSON_UNREF(j_tmp); if(ret == false) { ast_free(uuid); return false; } ast_log(LOG_VERBOSE, "Finished insert.\n"); // send ami event j_tmp = get_plan(uuid); ast_log(LOG_VERBOSE, "Check plan info. uuid[%s]\n", ast_json_string_get(ast_json_object_get(j_tmp, "uuid")) ); ast_free(uuid); if(j_tmp == NULL) { ast_log(LOG_ERROR, "Could not get created plan info."); return false; } send_manager_evt_out_plan_create(j_tmp); AST_JSON_UNREF(j_tmp); return true; }
static struct ast_manager_event_blob *agent_logoff_to_ami(struct stasis_message *msg) { RAII_VAR(struct ast_str *, channel_string, NULL, ast_free); struct ast_channel_blob *obj = stasis_message_data(msg); const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent")); long logintime = ast_json_integer_get(ast_json_object_get(obj->blob, "logintime")); channel_string = ast_manager_build_channel_state_string(obj->snapshot); if (!channel_string) { return NULL; } return ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogoff", "%s" "Agent: %s\r\n" "Logintime: %ld\r\n", ast_str_buffer(channel_string), agent, logintime); }