static void event_handler(switch_event_t *event) { const char *sig = switch_event_get_header(event, "Trapped-Signal"); switch_hash_index_t *hi; void *val; const void *var; logfile_profile_t *profile; if (sig && !strcmp(sig, "HUP")) { if (globals.rotate) { for (hi = switch_core_hash_first(profile_hash); hi; hi = switch_core_hash_next(&hi)) { switch_core_hash_this(hi, &var, NULL, &val); profile = val; mod_logfile_rotate(profile); } } else { switch_mutex_lock(globals.mutex); for (hi = switch_core_hash_first(profile_hash); hi; hi = switch_core_hash_next(&hi)) { switch_core_hash_this(hi, &var, NULL, &val); profile = val; switch_file_close(profile->log_afd); if (mod_logfile_openlogfile(profile, SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error Re-opening Log!\n"); } } switch_mutex_unlock(globals.mutex); } } }
static void check_timeouts(void) { switch_hash_index_t *hi; const void *var; void *val; time_t now; valet_lot_t *lot; switch_console_callback_match_t *matches = NULL; switch_console_callback_match_node_t *m; switch_hash_index_t *i_hi; const void *i_var; void *i_val; char *i_ext; valet_token_t *token; now = switch_epoch_time_now(NULL); switch_mutex_lock(globals.mutex); if (now - globals.last_timeout_check < TOKEN_FREQ) { switch_mutex_unlock(globals.mutex); return; } globals.last_timeout_check = now; for (hi = switch_core_hash_first( globals.hash); hi; hi = switch_core_hash_next(hi)) { switch_core_hash_this(hi, &var, NULL, &val); switch_console_push_match(&matches, (const char *) var); } switch_mutex_unlock(globals.mutex); if (matches) { for (m = matches->head; m; m = m->next) { lot = valet_find_lot(m->val, SWITCH_FALSE); switch_mutex_lock(lot->mutex); top: for (i_hi = switch_core_hash_first( lot->hash); i_hi; i_hi = switch_core_hash_next(i_hi)) { switch_core_hash_this(i_hi, &i_var, NULL, &i_val); i_ext = (char *) i_var; token = (valet_token_t *) i_val; if (token->timeout > 0 && (token->timeout < now || token->timeout == 1)) { switch_core_hash_delete(lot->hash, i_ext); switch_safe_free(token); goto top; } } switch_mutex_unlock(lot->mutex); } switch_console_free_matches(&matches); } }
static switch_status_t skinny_api_list_profiles(const char *line, const char *cursor, switch_console_callback_match_t **matches) { switch_console_callback_match_t *my_matches = NULL; switch_status_t status = SWITCH_STATUS_FALSE; switch_hash_index_t *hi; void *val; skinny_profile_t *profile; /* walk profiles */ switch_mutex_lock(globals.mutex); for (hi = switch_core_hash_first( globals.profile_hash); hi; hi = switch_core_hash_next(hi)) { switch_core_hash_this(hi, NULL, NULL, &val); profile = (skinny_profile_t *) val; switch_console_push_match(&my_matches, profile->name); } switch_mutex_unlock(globals.mutex); if (my_matches) { *matches = my_matches; status = SWITCH_STATUS_SUCCESS; } return status; }
static int find_longest(valet_lot_t *lot, int min, int max) { switch_hash_index_t *i_hi; const void *i_var; void *i_val; valet_token_t *token; int longest_ext = 0; time_t longest = 0, cur = 0; time_t now = switch_epoch_time_now(NULL); switch_mutex_lock(lot->mutex); for (i_hi = switch_core_hash_first( lot->hash); i_hi; i_hi = switch_core_hash_next(i_hi)) { int i; switch_core_hash_this(i_hi, &i_var, NULL, &i_val); token = (valet_token_t *) i_val; cur = (now - token->start_time); i = atoi(token->ext); if (cur > longest && i >= min && i <= max) { longest = cur; longest_ext = i; } } switch_mutex_unlock(lot->mutex); return longest_ext; }
/** * Execute function for each subscriber */ static void subscriber_execute(const char *uuid, const char *signal_type, subscriber_execute_fn callback, void *user_data) { switch_event_t *subscriber_list = NULL; switch_event_header_t *subscriber = NULL; /* fetch list of subscribers */ char *key = switch_mprintf("%s:%s", uuid, signal_type); switch_event_create_subclass(&subscriber_list, SWITCH_EVENT_CLONE, NULL); switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "Subscriber execute %s\n", signal_type); switch_mutex_lock(globals.subscribers_mutex); { switch_hash_index_t *hi = NULL; switch_hash_t *signal_subscribers = switch_core_hash_find(globals.subscribers, key); if (signal_subscribers) { for (hi = switch_core_hash_first(signal_subscribers); hi; hi = switch_core_hash_next(hi)) { const void *jid; void *dont_care; switch_core_hash_this(hi, &jid, NULL, &dont_care); switch_event_add_header_string(subscriber_list, SWITCH_STACK_BOTTOM, "execute", (const char *)jid); } } else { switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "No subscribers for %s\n", signal_type); } } switch_mutex_unlock(globals.subscribers_mutex); switch_safe_free(key); /* execute function for each subscriber */ for (subscriber = subscriber_list->headers; subscriber; subscriber = subscriber->next) { callback(subscriber->value, user_data); } switch_event_destroy(&subscriber_list); }
SWITCH_DECLARE(switch_status_t) switch_core_hash_delete_multi(switch_hash_t *hash, switch_hash_delete_callback_t callback, void *pData) { switch_hash_index_t *hi = NULL; switch_event_t *event = NULL; switch_event_header_t *header = NULL; switch_status_t status = SWITCH_STATUS_GENERR; switch_event_create_subclass(&event, SWITCH_EVENT_CLONE, NULL); switch_assert(event); /* iterate through the hash, call callback, if callback returns NULL or true, put the key on the list (event) When done, iterate through the list deleting hash entries */ for (hi = switch_core_hash_first(hash); hi; hi = switch_core_hash_next(&hi)) { const void *key; void *val; switch_core_hash_this(hi, &key, NULL, &val); if (!callback || callback(key, val, pData)) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delete", (const char *) key); } } /* now delete them */ for (header = event->headers; header; header = header->next) { if (switch_core_hash_delete(hash, header->value)) { status = SWITCH_STATUS_SUCCESS; } } switch_event_destroy(&event); return status; }
static void event_handler(switch_event_t *event) { const char *sig = switch_event_get_header(event, "Trapped-Signal"); switch_hash_index_t *hi; void *val; cdr_fd_t *fd; if (globals.shutdown) { return; } if (sig && !strcmp(sig, "HUP")) { for (hi = switch_core_hash_first(globals.fd_hash); hi; hi = switch_core_hash_next(&hi)) { switch_core_hash_this(hi, NULL, NULL, &val); fd = (cdr_fd_t *) val; switch_mutex_lock(fd->mutex); do_rotate(fd); switch_mutex_unlock(fd->mutex); } if (globals.db_online) { PQfinish(globals.db_connection); globals.db_online = 0; } } }
static switch_status_t process_node(const switch_log_node_t *node, switch_log_level_t level) { switch_hash_index_t *hi; void *val; const void *var; logfile_profile_t *profile; for (hi = switch_core_hash_first(profile_hash); hi; hi = switch_core_hash_next(&hi)) { size_t mask = 0; size_t ok = 0; switch_core_hash_this(hi, &var, NULL, &val); profile = val; ok = switch_log_check_mask(profile->all_level, level); if (!ok) { mask = (size_t) switch_core_hash_find(profile->log_hash, node->file); ok = switch_log_check_mask(mask, level); } if (!ok) { mask = (size_t) switch_core_hash_find(profile->log_hash, node->func); ok = switch_log_check_mask(mask, level); } if (!ok) { char tmp[256] = ""; switch_snprintf(tmp, sizeof(tmp), "%s:%s", node->file, node->func); mask = (size_t) switch_core_hash_find(profile->log_hash, tmp); ok = switch_log_check_mask(mask, level); } if (ok) { if (profile->log_uuid && !zstr(node->userdata)) { char buf[2048]; char *dup = strdup(node->data); char *lines[100]; int argc, i; argc = switch_split(dup, '\n', lines); for (i = 0; i < argc; i++) { switch_snprintf(buf, sizeof(buf), "%s %s\n", node->userdata, lines[i]); mod_logfile_raw_write(profile, buf); } free(dup); } else { mod_logfile_raw_write(profile, node->data); } } } return SWITCH_STATUS_SUCCESS; }
/** * Stop all CPA detectors */ static void stop_cpa_detectors(struct cpa_component *cpa) { if (cpa->signals) { switch_hash_index_t *hi = NULL; for (hi = switch_core_hash_first(cpa->signals); hi; hi = switch_core_hash_next(hi)) { const void *signal_type; void *cpa_signal = NULL; switch_core_hash_this(hi, &signal_type, NULL, &cpa_signal); if (cpa_signal) { rayo_cpa_detector_stop(RAYO_COMPONENT(cpa)->parent->id, ((struct cpa_signal *)cpa_signal)->name); unsubscribe(RAYO_COMPONENT(cpa)->parent->id, ((struct cpa_signal *)cpa_signal)->name, RAYO_JID(cpa)); } } switch_core_hash_destroy(&cpa->signals); cpa->signals = NULL; } unsubscribe(RAYO_COMPONENT(cpa)->parent->id, "hangup", RAYO_JID(cpa)); }
/** * Search for best voice based on attributes * @param cur_node the desired voice attributes * @param map the map to search * @param type "say" or "tts" * @param lang_required if true, language must match * @return the voice or NULL */ static struct voice *find_voice(struct ssml_node *cur_node, switch_hash_t *map, char *type, int lang_required) { switch_hash_index_t *hi = NULL; struct voice *voice = (struct voice *)switch_core_hash_find(map, cur_node->name); char *lang_name_gender = NULL; int best_score = 0; /* check cache */ lang_name_gender = switch_mprintf("%s-%s-%s-%s", type, cur_node->language, cur_node->name, cur_node->gender); voice = (struct voice *)switch_core_hash_find(globals.voice_cache, lang_name_gender); if (voice) { /* that was easy! */ goto done; } /* find best language, name, gender match */ for (hi = switch_core_hash_first( map); hi; hi = switch_core_hash_next(hi)) { const void *key; void *val; struct voice *candidate; int candidate_score = 0; switch_core_hash_this(hi, &key, NULL, &val); candidate = (struct voice *)val; candidate_score = score_voice(candidate, cur_node, lang_required); if (candidate_score > 0 && candidate_score > best_score) { voice = candidate; best_score = candidate_score; } } /* remember for next time */ if (voice) { switch_core_hash_insert(globals.voice_cache, lang_name_gender, voice); } done: switch_safe_free(lang_name_gender); return voice; }
static int valet_lot_count(valet_lot_t *lot) { switch_hash_index_t *i_hi; const void *i_var; void *i_val; valet_token_t *token; int count = 0; time_t now; now = switch_epoch_time_now(NULL); switch_mutex_lock(lot->mutex); for (i_hi = switch_core_hash_first( lot->hash); i_hi; i_hi = switch_core_hash_next(i_hi)) { switch_core_hash_this(i_hi, &i_var, NULL, &i_val); token = (valet_token_t *) i_val; if (token->timeout > 0 && (token->timeout < now || token->timeout == 1)) { continue; } count++; } switch_mutex_unlock(lot->mutex); return count; }
static void pres_event_handler(switch_event_t *event) { char *to = switch_event_get_header(event, "to"); char *dup_to = NULL, *lot_name, *dup_lot_name = NULL, *domain_name; valet_lot_t *lot; int found = 0; if (!to || strncasecmp(to, "park+", 5) || !strchr(to, '@')) { return; } if (!(dup_to = strdup(to))) { return; } lot_name = dup_to + 5; if ((domain_name = strchr(lot_name, '@'))) { *domain_name++ = '\0'; } dup_lot_name = switch_mprintf("%q@%q", lot_name, domain_name); if ((lot = valet_find_lot(lot_name, SWITCH_FALSE)) || (dup_lot_name && (lot = valet_find_lot(dup_lot_name, SWITCH_FALSE)))) { int count = valet_lot_count(lot); if (count) { if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", VALET_PROTO); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", lot_name); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", lot_name, domain_name); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "force-status", "Active (%d caller%s)", count, count == 1 ? "" : "s"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "active"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", lot_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "confirmed"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", "inbound"); switch_event_fire(&event); } found++; } else { if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", VALET_PROTO); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", lot_name, domain_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "force-status", "Empty"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "unknown"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", lot_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_HANGUP"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "terminated"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", "inbound"); switch_event_fire(&event); } } } else { switch_console_callback_match_t *matches = NULL; switch_console_callback_match_node_t *m; switch_hash_index_t *hi; const void *var; void *val; const char *nvar; switch_mutex_lock(globals.mutex); for (hi = switch_core_hash_first( globals.hash); hi; hi = switch_core_hash_next(hi)) { switch_core_hash_this(hi, &var, NULL, &val); nvar = (const char *) var; if (!strchr(nvar, '@') || switch_stristr(domain_name, nvar)) { switch_console_push_match(&matches, nvar); } } switch_mutex_unlock(globals.mutex); if (matches) { valet_token_t *token; for (m = matches->head; !found && m; m = m->next) { lot = valet_find_lot(m->val, SWITCH_FALSE); switch_mutex_lock(lot->mutex); if ((token = (valet_token_t *) switch_core_hash_find(lot->hash, lot_name)) && !token->timeout) { found++; if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", VALET_PROTO); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", lot_name); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", lot_name, domain_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "force-status", token->bridged == 0 ? "Holding" : "Active"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", lot_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", token->bridged == 0 ? "early" : "confirmed"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", token->bridged == 0 ? "outbound" : "inbound"); switch_event_fire(&event); } } switch_mutex_unlock(lot->mutex); } switch_console_free_matches(&matches); } } if (!found && switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", VALET_PROTO); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", lot_name); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", lot_name, domain_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "force-status", "Empty"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", "unknown"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", EC++); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", lot_name); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_HANGUP"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "terminated"); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-direction", "inbound"); switch_event_fire(&event); } switch_safe_free(dup_to); switch_safe_free(dup_lot_name); }
/* Deprecated */ SWITCH_DECLARE(switch_hash_index_t *) switch_hash_next(switch_hash_index_t *hi) { return switch_core_hash_next(hi); }
static switch_status_t api_erlang_event_filter(switch_stream_handle_t *stream) { switch_hash_index_t *hi = NULL; int column = 0; for (hi = (switch_hash_index_t *)switch_core_hash_first_iter(globals.event_filter, hi); hi; hi = switch_core_hash_next(&hi)) { const void *key; void *val; switch_core_hash_this(hi, &key, NULL, &val); stream->write_function(stream, "%-50s", (char *)key); if (++column > 2) { stream->write_function(stream, "\n"); column = 0; } } if (++column > 2) { stream->write_function(stream, "\n"); column = 0; } stream->write_function(stream, "%-50s", globals.kazoo_var_prefix); return SWITCH_STATUS_SUCCESS; }
void conference_event_mod_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id) { cJSON *data, *addobj = NULL; const char *action = NULL; char *value = NULL; cJSON *jid = 0; char *conference_name = strdup(event_channel + 15); char cid[32] = ""; char *p; switch_stream_handle_t stream = { 0 }; char *exec = NULL; cJSON *msg, *jdata, *jvalue; char *argv[10] = {0}; int argc = 0; if (conference_name && (p = strchr(conference_name, '@'))) { *p = '\0'; } if ((data = cJSON_GetObjectItem(json, "data"))) { action = cJSON_GetObjectCstr(data, "command"); if ((jid = cJSON_GetObjectItem(data, "id"))) { if (jid->valueint) { switch_snprintf(cid, sizeof(cid), "%d", jid->valueint); } else if (!zstr(jid->valuestring)) { switch_snprintf(cid, sizeof(cid), "%s", jid->valuestring); } } if ((jvalue = cJSON_GetObjectItem(data, "value"))) { if (jvalue->type == cJSON_Array) { int i; argc = cJSON_GetArraySize(jvalue); if (argc > 10) argc = 10; for (i = 0; i < argc; i++) { cJSON *str = cJSON_GetArrayItem(jvalue, i); if (str->type == cJSON_String) { argv[i] = str->valuestring; } } } else if (jvalue->type == cJSON_String) { value = jvalue->valuestring; argv[argc++] = value; } } } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "conf %s CMD %s [%s] %s\n", conference_name, key, action, cid); if (zstr(action)) { goto end; } SWITCH_STANDARD_STREAM(stream); if (!strcasecmp(action, "kick")) { exec = switch_mprintf("%s %s %s", conference_name, action, cid); } else if (!strcasecmp(action, "mute") || !strcasecmp(action, "unmute") || !strcasecmp(action, "tmute") || !strcasecmp(action, "vmute") || !strcasecmp(action, "unvmute") || !strcasecmp(action, "tvmute")) { if (argv[0]) { exec = switch_mprintf("%s %s %s %s", conference_name, action, cid, argv[0]); } else { exec = switch_mprintf("%s %s %s", conference_name, action, cid); } } else if (!strcasecmp(action, "volume_in") || !strcasecmp(action, "volume_out") || !strcasecmp(action, "vid-res-id") || !strcasecmp(action, "vid-floor") || !strcasecmp(action, "vid-layer") || !strcasecmp(action, "vid-canvas") || !strcasecmp(action, "vid-watching-canvas") || !strcasecmp(action, "vid-banner")) { exec = switch_mprintf("%s %s %s %s", conference_name, action, cid, argv[0]); } else if (!strcasecmp(action, "play") || !strcasecmp(action, "stop")) { exec = switch_mprintf("%s %s %s", conference_name, action, argv[0]); } else if (!strcasecmp(action, "recording") || !strcasecmp(action, "vid-layout") || !strcasecmp(action, "vid-write-png")) { if (!argv[1]) { argv[1] = "all"; } exec = switch_mprintf("%s %s %s %s", conference_name, action, argv[0], argv[1]); } else if (!strcasecmp(action, "transfer")) { conference_member_t *member; conference_obj_t *conference; if (cid[0] == '\0') { stream.write_function(&stream, "-ERR Call transfer requires id"); goto end; } exec = switch_mprintf("%s %s %s", argv[0], switch_str_nil(argv[1]), switch_str_nil(argv[2])); stream.write_function(&stream, "+OK Call transferred to %s", argv[0]); if ((conference = conference_find(conference_name, NULL))) { if ((member = conference_member_get(conference, atoi(cid)))) { switch_ivr_session_transfer(member->session, argv[0], argv[1], argv[2]); switch_thread_rwlock_unlock(member->rwlock); } switch_thread_rwlock_unlock(conference->rwlock); } goto end; } else if (!strcasecmp(action, "list-videoLayouts")) { switch_hash_index_t *hi; void *val; const void *vvar; cJSON *array = cJSON_CreateArray(); conference_obj_t *conference = NULL; if ((conference = conference_find(conference_name, NULL))) { switch_mutex_lock(conference_globals.setup_mutex); if (conference->layout_hash) { for (hi = switch_core_hash_first(conference->layout_hash); hi; hi = switch_core_hash_next(&hi)) { switch_core_hash_this(hi, &vvar, NULL, &val); cJSON_AddItemToArray(array, cJSON_CreateString((char *)vvar)); } } if (conference->layout_group_hash) { for (hi = switch_core_hash_first(conference->layout_group_hash); hi; hi = switch_core_hash_next(&hi)) { char *name; switch_core_hash_this(hi, &vvar, NULL, &val); name = switch_mprintf("group:%s", (char *)vvar); cJSON_AddItemToArray(array, cJSON_CreateString(name)); free(name); } } switch_mutex_unlock(conference_globals.setup_mutex); switch_thread_rwlock_unlock(conference->rwlock); } addobj = array; } if (exec) { conference_api_main_real(exec, NULL, &stream); } end: msg = cJSON_CreateObject(); jdata = json_add_child_obj(msg, "data", NULL); cJSON_AddItemToObject(msg, "eventChannel", cJSON_CreateString(event_channel)); cJSON_AddItemToObject(jdata, "action", cJSON_CreateString("response")); if (addobj) { cJSON_AddItemToObject(jdata, "conf-command", cJSON_CreateString(action)); cJSON_AddItemToObject(jdata, "response", cJSON_CreateString("OK")); cJSON_AddItemToObject(jdata, "responseData", addobj); } else if (exec) { cJSON_AddItemToObject(jdata, "conf-command", cJSON_CreateString(exec)); cJSON_AddItemToObject(jdata, "response", cJSON_CreateString((char *)stream.data)); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ALERT,"RES [%s][%s]\n", exec, (char *)stream.data); } else { cJSON_AddItemToObject(jdata, "error", cJSON_CreateString("Invalid Command")); } switch_event_channel_broadcast(event_channel, &msg, __FILE__, conference_globals.event_channel_id); switch_safe_free(stream.data); switch_safe_free(exec); switch_safe_free(conference_name); }
switch_status_t mod_amqp_logging_recv(const switch_log_node_t *node, switch_log_level_t level) { switch_hash_index_t *hi = NULL; mod_amqp_message_t *msg = NULL; mod_amqp_logging_profile_t *logging = NULL; char *json = NULL; if (!strcmp(node->file, "mod_amqp_logging.c")) { return SWITCH_STATUS_SUCCESS; } /* 1. Loop through logging hash of profiles. Check for a profile that accepts this logging level, and file regex. 2. If event not already parsed/created, then create it now 3. Queue copy of event into logging profile send queue 4. Destroy local event copy */ for (hi = switch_core_hash_first(globals.logging_hash); hi; hi = switch_core_hash_next(&hi)) { switch_core_hash_this(hi, NULL, NULL, (void **)&logging); if ( logging && switch_log_check_mask(logging->log_level_mask, level) ) { char file[128] = {0}; if ( !json ) { cJSON *body = NULL; char date[80] = ""; switch_time_exp_t tm; switch_time_exp_lt(&tm, node->timestamp); switch_snprintf(date, sizeof(date), "%0.4d-%0.2d-%0.2d %0.2d:%0.2d:%0.2d.%0.6d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_usec); /* Create cJSON body */ body = cJSON_CreateObject(); cJSON_AddItemToObject(body, "file", cJSON_CreateString((const char *) node->file)); cJSON_AddItemToObject(body, "function", cJSON_CreateString((const char *) node->func)); cJSON_AddItemToObject(body, "line", cJSON_CreateNumber((double) node->line)); cJSON_AddItemToObject(body, "level", cJSON_CreateString(switch_log_level2str(node->level))); cJSON_AddItemToObject(body, "timestamp", cJSON_CreateString((const char *)date)); cJSON_AddItemToObject(body, "timestamp_epoch", cJSON_CreateNumber((double) node->timestamp / 1000000)); cJSON_AddItemToObject(body, "content", cJSON_CreateString(node->content )); json = cJSON_Print(body); cJSON_Delete(body); } /* Create message */ switch_malloc(msg, sizeof(mod_amqp_message_t)); msg->pjson = strdup(json); strcpy(file, node->file); switch_replace_char(file, '.', '_', 0); snprintf(msg->routing_key, sizeof(msg->routing_key), "%s.%s.%s.%s", switch_core_get_hostname(), node->userdata, switch_log_level2str(node->level), file); if (switch_queue_trypush(logging->send_queue, msg) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "AMQP logging message queue full. Messages will be dropped!\n"); return SWITCH_STATUS_SUCCESS; } } } switch_safe_free(json); return SWITCH_STATUS_SUCCESS; }