/* Compute the usage sum of a resource on remote boxes */ static limit_hash_item_t get_remote_usage(const char *key) { limit_hash_item_t usage = { 0 }; switch_hash_index_t *hi; switch_thread_rwlock_rdlock(globals.remote_hash_rwlock); for (hi = switch_hash_first(NULL, globals.remote_hash); hi; hi = switch_hash_next(hi)) { void *val; const void *hashkey; switch_ssize_t keylen; limit_remote_t *remote; limit_hash_item_t *item; switch_hash_this(hi, &hashkey, &keylen, &val); remote = (limit_remote_t *)val; if (remote->state != REMOTE_UP) { continue; } switch_thread_rwlock_rdlock(remote->rwlock); if ((item = switch_core_hash_find(remote->index, key))) { usage.total_usage += item->total_usage; usage.rate_usage += item->rate_usage; if (!usage.last_check) { usage.last_check = item->last_check; } } switch_thread_rwlock_unlock(remote->rwlock); } switch_thread_rwlock_unlock(globals.remote_hash_rwlock); return usage; }
limit_remote_t *limit_remote_create(const char *name, const char *host, uint16_t port, const char *username, const char *password, int interval) { limit_remote_t *r; switch_memory_pool_t *pool; switch_thread_rwlock_rdlock(globals.remote_hash_rwlock); if (switch_core_hash_find(globals.remote_hash, name)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Already have a remote instance named %s\n", name); switch_thread_rwlock_unlock(globals.remote_hash_rwlock); return NULL; } switch_thread_rwlock_unlock(globals.remote_hash_rwlock); if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { return NULL; } r = switch_core_alloc(pool, sizeof(limit_remote_t)); r->pool = pool; r->name = switch_core_strdup(r->pool, name); r->host = switch_core_strdup(r->pool, host); r->port = port; r->username = switch_core_strdup(r->pool, username); r->password = switch_core_strdup(r->pool, password); r->interval = interval; switch_thread_rwlock_create(&r->rwlock, pool); switch_core_hash_init(&r->index, pool); switch_thread_rwlock_rdlock(globals.remote_hash_rwlock); switch_core_hash_insert(globals.remote_hash, name, r); switch_thread_rwlock_unlock(globals.remote_hash_rwlock); return r; }
static switch_status_t remove_xml_client(ei_node_t *ei_node, switch_xml_binding_t *binding) { ei_xml_agent_t *agent; ei_xml_client_t *client, *prev = NULL; int found = 0; agent = (ei_xml_agent_t *)switch_xml_get_binding_user_data(binding); /* write-lock the agent */ switch_thread_rwlock_wrlock(agent->lock); client = agent->clients; while (client != NULL) { if (client->ei_node == ei_node) { found = 1; break; } prev = client; client = client->next; } if (found) { fetch_handler_t *fetch_handler; if (!prev) { agent->clients = client->next; } else { prev->next = client->next; } /* the mutex lock is not required since we have the write lock * but hey its fun and safe so do it anyway */ switch_mutex_lock(agent->current_client_mutex); if (agent->current_client == client) { agent->current_client = agent->clients; } switch_mutex_unlock(agent->current_client_mutex); fetch_handler = client->fetch_handlers; while(fetch_handler != NULL) { fetch_handler_t *tmp_fetch_handler = fetch_handler; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Removed %s XML handler %s <%d.%d.%d>\n" ,xml_section_to_string(agent->section) ,fetch_handler->pid.node ,fetch_handler->pid.creation ,fetch_handler->pid.num ,fetch_handler->pid.serial); fetch_handler = fetch_handler->next; switch_safe_free(tmp_fetch_handler); } switch_safe_free(client); } switch_thread_rwlock_unlock(agent->lock); return SWITCH_STATUS_SUCCESS; }
static switch_status_t handle_api_command_stream(ei_node_t *ei_node, switch_stream_handle_t *stream, switch_xml_binding_t *binding) { ei_xml_agent_t *agent; ei_xml_client_t *client; if (!binding) { return SWITCH_STATUS_GENERR; } agent = (ei_xml_agent_t *)switch_xml_get_binding_user_data(binding); /* read-lock the agent */ switch_thread_rwlock_rdlock(agent->lock); client = agent->clients; while (client != NULL) { if (client->ei_node == ei_node) { fetch_handler_t *fetch_handler; fetch_handler = client->fetch_handlers; while (fetch_handler != NULL) { stream->write_function(stream, "XML %s handler <%d.%d.%d>\n" ,xml_section_to_string(agent->section) ,fetch_handler->pid.creation ,fetch_handler->pid.num ,fetch_handler->pid.serial); fetch_handler = fetch_handler->next; } break; } client = client->next; } switch_thread_rwlock_unlock(agent->lock); return SWITCH_STATUS_SUCCESS; }
void limit_remote_destroy(limit_remote_t **r) { if (r && *r) { switch_hash_index_t *hi; (*r)->state = REMOTE_OFF; if ((*r)->thread) { switch_status_t retval; switch_thread_join(&retval, (*r)->thread); } switch_thread_rwlock_wrlock((*r)->rwlock); /* Free hashtable data */ for (hi = switch_hash_first(NULL, (*r)->index); hi; hi = switch_hash_next(hi)) { void *val; const void *key; switch_ssize_t keylen; switch_hash_this(hi, &key, &keylen, &val); free(val); } switch_thread_rwlock_unlock((*r)->rwlock); switch_thread_rwlock_destroy((*r)->rwlock); switch_core_destroy_memory_pool(&((*r)->pool)); *r = NULL; } }
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_enumerate(switch_core_session_t *session, switch_stream_handle_t *stream) { switch_media_bug_t *bp; stream->write_function(stream, "<media-bugs>\n"); if (session->bugs) { switch_thread_rwlock_rdlock(session->bug_rwlock); for (bp = session->bugs; bp; bp = bp->next) { int thread_locked = (bp->thread_id && bp->thread_id == switch_thread_self()); stream->write_function(stream, " <media-bug>\n" " <function>%s</function>\n" " <target>%s</target>\n" " <thread-locked>%d</thread-locked>\n" " </media-bug>\n", bp->function, bp->target, thread_locked); } switch_thread_rwlock_unlock(session->bug_rwlock); } stream->write_function(stream, "</media-bugs>\n"); return SWITCH_STATUS_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_remove(switch_core_session_t *session, switch_media_bug_t **bug) { switch_media_bug_t *bp = NULL, *last = NULL; switch_status_t status = SWITCH_STATUS_FALSE; switch_thread_rwlock_wrlock(session->bug_rwlock); if (session->bugs) { for (bp = session->bugs; bp; bp = bp->next) { if ((!bp->thread_id || bp->thread_id == switch_thread_self()) && bp->ready && bp == *bug) { if (last) { last->next = bp->next; } else { session->bugs = bp->next; } break; } last = bp; } } if (!session->bugs && switch_core_codec_ready(&session->bug_codec)) { switch_core_codec_destroy(&session->bug_codec); } switch_thread_rwlock_unlock(session->bug_rwlock); if (bp) { status = switch_core_media_bug_close(&bp); } return status; }
static switch_status_t local_stream_file_close(switch_file_handle_t *handle) { local_stream_context_t *cp, *last = NULL, *context = handle->private_info; context->ready = 0; switch_mutex_lock(context->source->mutex); for (cp = context->source->context_list; cp; cp = cp->next) { if (cp == context) { if (last) { last->next = cp->next; } else { context->source->context_list = cp->next; } break; } last = cp; } if (context->video_q) { flush_video_queue(context->video_q); switch_queue_trypush(context->video_q, NULL); switch_queue_interrupt_all(context->video_q); flush_video_queue(context->video_q); } switch_img_free(&context->banner_img); context->source->total--; switch_mutex_unlock(context->source->mutex); switch_buffer_destroy(&context->audio_buffer); switch_thread_rwlock_unlock(context->source->rwlock); return SWITCH_STATUS_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_remove_all_function(switch_core_session_t *session, const char *function) { switch_media_bug_t *bp; switch_status_t status = SWITCH_STATUS_FALSE; if (session->bugs) { switch_thread_rwlock_wrlock(session->bug_rwlock); for (bp = session->bugs; bp; bp = bp->next) { if ((bp->thread_id && bp->thread_id != switch_thread_self()) || switch_test_flag(bp, SMBF_LOCK)) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "BUG is thread locked skipping.\n"); continue; } if (!zstr(function) && strcmp(bp->function, function)) { continue; } if (bp->callback) { bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_CLOSE); } switch_core_media_bug_destroy(bp); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Removing BUG from %s\n", switch_channel_get_name(session->channel)); } session->bugs = NULL; switch_thread_rwlock_unlock(session->bug_rwlock); status = SWITCH_STATUS_SUCCESS; } if (switch_core_codec_ready(&session->bug_codec)) { switch_core_codec_destroy(&session->bug_codec); } return status; }
/** * Thread to prefetch URLs * @param thread the thread * @param obj started flag * @return NULL */ static void *SWITCH_THREAD_FUNC prefetch_thread(switch_thread_t *thread, void *obj) { int *started = obj; void *url = NULL; switch_thread_rwlock_rdlock(gcache.shutdown_lock); *started = 1; // process prefetch requests while (!gcache.shutdown) { if (switch_queue_pop(gcache.prefetch_queue, &url) == SWITCH_STATUS_SUCCESS) { switch_stream_handle_t stream = { 0 }; SWITCH_STANDARD_STREAM(stream); switch_api_execute("http_get", url, NULL, &stream); switch_safe_free(stream.data); switch_safe_free(url); } url = NULL; } // shutting down- clear the queue while (switch_queue_trypop(gcache.prefetch_queue, &url) == SWITCH_STATUS_SUCCESS) { switch_safe_free(url); url = NULL; } switch_thread_rwlock_unlock(gcache.shutdown_lock); return NULL; }
static switch_status_t spy_on_hangup(switch_core_session_t *session) { switch_channel_t *channel = switch_core_session_get_channel(session); const char *data = switch_channel_get_private(channel, "_userspy_"); const char *uuid = switch_core_session_get_uuid(session); spy_t *spy = NULL, *p = NULL, *prev = NULL; switch_thread_rwlock_wrlock(globals.spy_hash_lock); spy = switch_core_hash_find(globals.spy_hash, data); for (p = spy; p; p = p->next) { if (p->uuid == uuid) { if (prev) { prev->next = p->next; } else { spy = p->next; } globals.spy_count--; break; } prev = p; } switch_core_hash_insert(globals.spy_hash, data, spy); switch_thread_rwlock_unlock(globals.spy_hash_lock); return SWITCH_STATUS_SUCCESS; }
static void *SWITCH_THREAD_FUNC read_stream_thread(switch_thread_t *thread, void *obj) { CURL *curl_handle = NULL; CURLcode cc; shout_context_t *context = (shout_context_t *) obj; switch_thread_rwlock_rdlock(context->rwlock); curl_handle = curl_easy_init(); curl_easy_setopt(curl_handle, CURLOPT_URL, context->stream_url); curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1); curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 10); curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, stream_callback); curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) context); curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "FreeSWITCH(mod_shout)/1.0"); curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 30); /* eventually timeout connect */ curl_easy_setopt(curl_handle, CURLOPT_LOW_SPEED_LIMIT, 100); /* handle trickle connections */ curl_easy_setopt(curl_handle, CURLOPT_LOW_SPEED_TIME, 30); curl_easy_setopt(curl_handle, CURLOPT_ERRORBUFFER, context->curl_error_buff); cc = curl_easy_perform(curl_handle); if (cc && cc != CURLE_WRITE_ERROR) { /* write error is ok, we just exited from callback early */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "CURL returned error:[%d] %s : %s [%s]\n", cc, curl_easy_strerror(cc), context->curl_error_buff, context->stream_url); } curl_easy_cleanup(curl_handle); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Read Thread Done\n"); context->eof++; context->thread_running = 0; switch_thread_rwlock_unlock(context->rwlock); return NULL; }
static switch_status_t remove_fetch_handler(ei_node_t *ei_node, erlang_pid *from, switch_xml_binding_t *binding) { ei_xml_agent_t *agent; ei_xml_client_t *client; fetch_handler_t *fetch_handler, *prev = NULL; int found = 0; agent = (ei_xml_agent_t *)switch_xml_get_binding_user_data(binding); /* write-lock the agent */ switch_thread_rwlock_wrlock(agent->lock); if (!(client = find_xml_client(ei_node, agent))) { switch_thread_rwlock_unlock(agent->lock); return SWITCH_STATUS_SUCCESS; } fetch_handler = client->fetch_handlers; while (fetch_handler != NULL) { if (ei_compare_pids(&fetch_handler->pid, from) == SWITCH_STATUS_SUCCESS) { found = 1; break; } prev = fetch_handler; fetch_handler = fetch_handler->next; } if (found) { if (!prev) { client->fetch_handlers = fetch_handler->next; } else { prev->next = fetch_handler->next; } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Removed %s XML handler %s <%d.%d.%d>\n" ,xml_section_to_string(agent->section) ,fetch_handler->pid.node ,fetch_handler->pid.creation ,fetch_handler->pid.num ,fetch_handler->pid.serial); switch_safe_free(fetch_handler); } switch_thread_rwlock_unlock(agent->lock); return SWITCH_STATUS_SUCCESS; }
switch_status_t add_fetch_handler(ei_node_t *ei_node, erlang_pid *from, switch_xml_binding_t *binding) { ei_xml_agent_t *agent; ei_xml_client_t *client; fetch_handler_t *fetch_handler; agent = (ei_xml_agent_t *)switch_xml_get_binding_user_data(binding); /* write-lock the agent */ switch_thread_rwlock_wrlock(agent->lock); if (!(client = find_xml_client(ei_node, agent))) { client = add_xml_client(ei_node, agent); } fetch_handler = client->fetch_handlers; while (fetch_handler != NULL) { if (ei_compare_pids(&fetch_handler->pid, from) == SWITCH_STATUS_SUCCESS) { switch_thread_rwlock_unlock(agent->lock); return SWITCH_STATUS_SUCCESS; } fetch_handler = fetch_handler->next; } switch_malloc(fetch_handler, sizeof(*fetch_handler)); memcpy(&fetch_handler->pid, from, sizeof(erlang_pid));; fetch_handler->next = NULL; if (client->fetch_handlers) { fetch_handler->next = client->fetch_handlers; } client->fetch_handlers = fetch_handler; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Added %s XML handler %s <%d.%d.%d>\n" ,xml_section_to_string(agent->section) ,fetch_handler->pid.node ,fetch_handler->pid.creation ,fetch_handler->pid.num ,fetch_handler->pid.serial); switch_thread_rwlock_unlock(agent->lock); ei_link(ei_node, ei_self(&globals.ei_cnode), from); return SWITCH_STATUS_SUCCESS; }
static switch_status_t process_event(switch_event_t *event) { switch_core_session_t *session = NULL; switch_channel_t *channel; char *username[3] = { 0 }; char *domain[3] = { 0 }; char key[512]; char *uuid = NULL, *my_uuid = NULL; int i; switch_thread_rwlock_rdlock(globals.spy_hash_lock); if (!globals.spy_count) { goto done; } username[0] = switch_event_get_header(event, "Caller-Username"); domain[0] = switch_event_get_header(event, "variable_domain_name"); domain[1] = switch_event_get_header(event, "variable_dialed_domain"); username[1] = switch_event_get_header(event, "variable_dialed_user"); username[2] = switch_event_get_header(event, "variable_user_name"); domain[2] = switch_event_get_header(event, "variable_domain_name"); for (i = 0; i < 3; i++) { if (username[i] && domain[i]) { switch_snprintf(key, sizeof(key), "%s@%s", username[i], domain[i]); if ((uuid = switch_core_hash_find(globals.spy_hash, key))) { break; } } } done: switch_thread_rwlock_unlock(globals.spy_hash_lock); if (!uuid) { return SWITCH_STATUS_FALSE; } session = switch_core_session_locate(uuid); channel = switch_core_session_get_channel(session); switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "UserSpy retrieved uuid %s for key %s, activating eavesdrop \n", uuid, key); my_uuid = switch_event_get_header(event, "Unique-ID"); switch_channel_set_variable(channel, "spy_uuid", my_uuid); switch_channel_set_state(channel, CS_EXCHANGE_MEDIA); switch_channel_set_flag(channel, CF_BREAK); switch_core_session_rwunlock(session); return SWITCH_STATUS_SUCCESS; }
static void do_config(switch_bool_t reload) { switch_xml_t xml = NULL, x_lists = NULL, x_list = NULL, cfg = NULL; if ((xml = switch_xml_open_cfg("hash.conf", &cfg, NULL))) { if ((x_lists = switch_xml_child(cfg, "remotes"))) { for (x_list = switch_xml_child(x_lists, "remote"); x_list; x_list = x_list->next) { const char *name = switch_xml_attr(x_list, "name"); const char *host = switch_xml_attr(x_list, "host"); const char *szport = switch_xml_attr(x_list, "port"); const char *username = switch_xml_attr(x_list, "username"); const char *password = switch_xml_attr(x_list, "password"); const char *szinterval = switch_xml_attr(x_list, "interval"); uint16_t port = 0; int interval = 0; limit_remote_t *remote; switch_threadattr_t *thd_attr = NULL; if (reload) { switch_thread_rwlock_rdlock(globals.remote_hash_rwlock); if (switch_core_hash_find(globals.remote_hash, name)) { switch_thread_rwlock_unlock(globals.remote_hash_rwlock); continue; } switch_thread_rwlock_unlock(globals.remote_hash_rwlock); } if (!zstr(szport)) { port = (uint16_t)atoi(szport); } if (!zstr(szinterval)) { interval = atoi(szinterval); } remote = limit_remote_create(name, host, port, username, password, interval); remote->state = REMOTE_DOWN; switch_threadattr_create(&thd_attr, remote->pool); switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); switch_thread_create(&remote->thread, thd_attr, limit_remote_thread, remote, remote->pool); } } switch_xml_free(xml); } }
static void profile_rwunlock(dir_profile_t *profile) { switch_thread_rwlock_unlock(profile->rwlock); if (switch_test_flag(profile, PFLAG_DESTROY)) { if (switch_thread_rwlock_tryrdlock(profile->rwlock) == SWITCH_STATUS_SUCCESS) { free_profile(profile); } } }
static switch_status_t handle_msg_session_event(listener_t *listener, erlang_msg *msg, int arity, ei_x_buff * buf, ei_x_buff * rbuf) { char atom[MAXATOMLEN]; if (arity == 1) { ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "badarg"); } else { session_elem_t *session; if ((session = find_session_elem_by_pid(listener, &msg->from))) { int custom = 0; switch_event_types_t type; int i = 0; switch_thread_rwlock_wrlock(session->event_rwlock); for (i = 1; i < arity; i++) { if (!ei_decode_atom(buf->buff, &buf->index, atom)) { if (custom) { switch_core_hash_insert(session->event_hash, atom, MARKER); } else if (switch_name_event(atom, &type) == SWITCH_STATUS_SUCCESS) { if (type == SWITCH_EVENT_ALL) { uint32_t x = 0; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "ALL events enabled for %s\n", session->uuid_str); for (x = 0; x < SWITCH_EVENT_ALL; x++) { session->event_list[x] = 1; } } if (type <= SWITCH_EVENT_ALL) { session->event_list[type] = 1; } if (type == SWITCH_EVENT_CUSTOM) { custom++; } } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "enable event %s for session %s\n", atom, session->uuid_str); } } switch_thread_rwlock_unlock(session->event_rwlock); ei_x_encode_atom(rbuf, "ok"); } else { ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "notlistening"); } } return SWITCH_STATUS_SUCCESS; }
static switch_status_t handle_msg_session_nixevent(listener_t *listener, erlang_msg *msg, int arity, ei_x_buff * buf, ei_x_buff * rbuf) { char atom[MAXATOMLEN]; if (arity == 1) { ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "badarg"); } else { session_elem_t *session; if ((session = find_session_elem_by_pid(listener, &msg->from))) { int custom = 0; int i = 0; switch_event_types_t type; switch_thread_rwlock_wrlock(session->event_rwlock); for (i = 1; i < arity; i++) { if (!ei_decode_atom(buf->buff, &buf->index, atom)) { if (custom) { switch_core_hash_delete(session->event_hash, atom); } else if (switch_name_event(atom, &type) == SWITCH_STATUS_SUCCESS) { uint32_t x = 0; if (type == SWITCH_EVENT_CUSTOM) { custom++; } else if (type == SWITCH_EVENT_ALL) { for (x = 0; x <= SWITCH_EVENT_ALL; x++) { session->event_list[x] = 0; } } else { if (session->event_list[SWITCH_EVENT_ALL]) { session->event_list[SWITCH_EVENT_ALL] = 0; for (x = 0; x < SWITCH_EVENT_ALL; x++) { session->event_list[x] = 1; } } session->event_list[type] = 0; } } } } switch_thread_rwlock_unlock(session->event_rwlock); ei_x_encode_atom(rbuf, "ok"); } else { /* no session for this pid */ ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "notlistening"); } } return SWITCH_STATUS_SUCCESS; }
static switch_status_t api_erlang_node_command(switch_stream_handle_t *stream, const char *nodename, uint32_t command) { ei_node_t *ei_node; switch_thread_rwlock_rdlock(globals.ei_nodes_lock); ei_node = globals.ei_nodes; while(ei_node != NULL) { int length = strlen(ei_node->peer_nodename); if (!strncmp(ei_node->peer_nodename, nodename, length)) { handle_node_api_command(ei_node, stream, command); switch_thread_rwlock_unlock(globals.ei_nodes_lock); return SWITCH_STATUS_SUCCESS; } ei_node = ei_node->next; } switch_thread_rwlock_unlock(globals.ei_nodes_lock); return SWITCH_STATUS_NOTFOUND; }
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_remove(switch_core_session_t *session, switch_media_bug_t **bug) { switch_media_bug_t *bp = NULL, *bp2 = NULL, *last = NULL; switch_status_t status = SWITCH_STATUS_FALSE; int tap_only = 0; if (switch_core_media_bug_test_flag(*bug, SMBF_LOCK)) { return status; } switch_thread_rwlock_wrlock(session->bug_rwlock); if (session->bugs) { for (bp = session->bugs; bp; bp = bp->next) { if ((!bp->thread_id || bp->thread_id == switch_thread_self()) && bp->ready && bp == *bug) { if (last) { last->next = bp->next; } else { session->bugs = bp->next; } break; } last = bp; } } if (!session->bugs && switch_core_codec_ready(&session->bug_codec)) { switch_core_codec_destroy(&session->bug_codec); } if (session->bugs) { for(bp2 = session->bugs; bp2; bp2 = bp2->next) { if (bp2->ready && !switch_test_flag(bp2, SMBF_TAP_NATIVE_READ) && !switch_test_flag(bp2, SMBF_TAP_NATIVE_WRITE)) { tap_only = 0; } } } if (tap_only) { switch_set_flag(session, SSF_MEDIA_BUG_TAP_ONLY); } else { switch_clear_flag(session, SSF_MEDIA_BUG_TAP_ONLY); } switch_thread_rwlock_unlock(session->bug_rwlock); if (bp) { status = switch_core_media_bug_close(&bp); } return status; }
static switch_status_t api_erlang_nodes_list(switch_stream_handle_t *stream) { ei_node_t *ei_node; switch_thread_rwlock_rdlock(globals.ei_nodes_lock); ei_node = globals.ei_nodes; while(ei_node != NULL) { stream->write_function(stream, "%s (%s)\n", ei_node->peer_nodename, ei_node->remote_ip); ei_node = ei_node->next; } switch_thread_rwlock_unlock(globals.ei_nodes_lock); return SWITCH_STATUS_SUCCESS; }
/** * Thread that delivers logs to graylog2 server * @param thread this thread * @param obj unused * @return NULL */ static void *SWITCH_THREAD_FUNC deliver_graylog2_thread(switch_thread_t *thread, void *obj) { switch_socket_t *graylog2_sock = NULL; char *log; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "graylog2 delivery thread started\n"); switch_thread_rwlock_rdlock(globals.shutdown_rwlock); graylog2_sock = open_graylog2_socket(globals.server_host, globals.server_port, globals.pool); if (graylog2_sock) { while (!globals.shutdown) { if (switch_queue_pop(globals.log_queue, (void *)&log) == SWITCH_STATUS_SUCCESS) { if (!zstr(log)) { switch_size_t len = strlen(log); switch_size_t max_len = globals.send_uncompressed_header ? MAX_GELF_LOG_LEN - UNCOMPRESSED_MAGIC_LEN : MAX_GELF_LOG_LEN; if (len <= max_len) { if (globals.send_uncompressed_header) { char buf[MAX_GELF_LOG_LEN]; memcpy(buf, UNCOMPRESSED_MAGIC, UNCOMPRESSED_MAGIC_LEN); memcpy(buf + UNCOMPRESSED_MAGIC_LEN, log, len); len += UNCOMPRESSED_MAGIC_LEN; switch_socket_send_nonblock(graylog2_sock, (void *)buf, &len); } else { switch_socket_send_nonblock(graylog2_sock, (void *)log, &len); } } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Skipping large log\n"); } } switch_safe_free(log); } } } globals.shutdown = 1; /* clean up remaining logs */ while(switch_queue_trypop(globals.log_queue, (void *)&log) == SWITCH_STATUS_SUCCESS) { switch_safe_free(log); } if (graylog2_sock) { switch_socket_close(graylog2_sock); } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "graylog2 delivery thread finished\n"); switch_thread_rwlock_unlock(globals.shutdown_rwlock); return NULL; }
SWITCH_DECLARE(switch_status_t) switch_core_hash_delete_wrlock(switch_hash_t *hash, const char *key, switch_thread_rwlock_t *rwlock) { if (rwlock) { switch_thread_rwlock_wrlock(rwlock); } switch_core_hash_delete(hash, key); if (rwlock) { switch_thread_rwlock_unlock(rwlock); } return SWITCH_STATUS_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_wrlock(switch_hash_t *hash, const char *key, const void *data, switch_thread_rwlock_t *rwlock) { if (rwlock) { switch_thread_rwlock_wrlock(rwlock); } switch_core_hash_insert(hash, key, data); if (rwlock) { switch_thread_rwlock_unlock(rwlock); } return SWITCH_STATUS_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_core_hash_insert_wrlock(switch_hash_t *hash, const char *key, const void *data, switch_thread_rwlock_t *rwlock) { if (rwlock) { switch_thread_rwlock_wrlock(rwlock); } sqlite3HashInsert(&hash->table, key, (int) strlen(key) + 1, (void *) data); if (rwlock) { switch_thread_rwlock_unlock(rwlock); } return SWITCH_STATUS_SUCCESS; }
static switch_status_t handle_msg_event(listener_t *listener, int arity, ei_x_buff * buf, ei_x_buff * rbuf) { char atom[MAXATOMLEN]; if (arity == 1) { ei_x_encode_tuple_header(rbuf, 2); ei_x_encode_atom(rbuf, "error"); ei_x_encode_atom(rbuf, "badarg"); } else { int custom = 0; switch_event_types_t type; int i = 0; if (!switch_test_flag(listener, LFLAG_EVENTS)) { switch_set_flag_locked(listener, LFLAG_EVENTS); } switch_thread_rwlock_wrlock(listener->event_rwlock); for (i = 1; i < arity; i++) { if (!ei_decode_atom(buf->buff, &buf->index, atom)) { if (custom) { switch_core_hash_insert(listener->event_hash, atom, MARKER); } else if (switch_name_event(atom, &type) == SWITCH_STATUS_SUCCESS) { if (type == SWITCH_EVENT_ALL) { uint32_t x = 0; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "ALL events enabled\n"); for (x = 0; x < SWITCH_EVENT_ALL; x++) { listener->event_list[x] = 1; } } if (type <= SWITCH_EVENT_ALL) { listener->event_list[type] = 1; } if (type == SWITCH_EVENT_CUSTOM) { custom++; } } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "enable event %s\n", atom); } } switch_thread_rwlock_unlock(listener->event_rwlock); ei_x_encode_atom(rbuf, "ok"); } return SWITCH_STATUS_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_flush_all(switch_core_session_t *session) { switch_media_bug_t *bp; if (session->bugs) { switch_thread_rwlock_wrlock(session->bug_rwlock); for (bp = session->bugs; bp; bp = bp->next) { switch_core_media_bug_flush(bp); } switch_thread_rwlock_unlock(session->bug_rwlock); return SWITCH_STATUS_SUCCESS; } return SWITCH_STATUS_FALSE; }
SWITCH_DECLARE(void *) switch_core_hash_find_rdlock(switch_hash_t *hash, const char *key, switch_thread_rwlock_t *rwlock) { void *val; if (rwlock) { switch_thread_rwlock_rdlock(rwlock); } val = switch_core_hash_find(hash, key); if (rwlock) { switch_thread_rwlock_unlock(rwlock); } return val; }
SWITCH_DECLARE(void *) switch_core_hash_find_rdlock(switch_hash_t *hash, const char *key, switch_thread_rwlock_t *rwlock) { void *val; if (rwlock) { switch_thread_rwlock_rdlock(rwlock); } val = sqlite3HashFind(&hash->table, key, (int) strlen(key) + 1); if (rwlock) { switch_thread_rwlock_unlock(rwlock); } return val; }