自学教程：C++ switch_thread_rwlock_unlock函数代码示例

/* 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;}

/** * 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), "%[email
C++ switch_thread_rwlock_wrlock函数代码示例
C++ switch_task_namespaces函数代码示例