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

/* NB. this starts the input thread after some initial setup for the call leg */void conference_loop_output(conference_member_t *member){	switch_channel_t *channel;	switch_frame_t write_frame = { 0 };	uint8_t *data = NULL;	switch_timer_t timer = { 0 };	uint32_t interval;	uint32_t samples;	//uint32_t csamples;	uint32_t tsamples;	uint32_t flush_len;	uint32_t low_count, bytes;	call_list_t *call_list, *cp;	switch_codec_implementation_t read_impl = { 0 };	int sanity;	switch_status_t st;	switch_core_session_get_read_impl(member->session, &read_impl);	channel = switch_core_session_get_channel(member->session);	interval = read_impl.microseconds_per_packet / 1000;	samples = switch_samples_per_packet(member->conference->rate, interval);	//csamples = samples;	tsamples = member->orig_read_impl.samples_per_packet;	low_count = 0;	bytes = samples * 2 * member->conference->channels;	call_list = NULL;	cp = NULL;	member->loop_loop = 0;	switch_assert(member->conference != NULL);	flush_len = switch_samples_per_packet(member->conference->rate, member->conference->interval) * 2 * member->conference->channels * (500 / member->conference->interval);	if (switch_core_timer_init(&timer, member->conference->timer_name, interval, tsamples, NULL) != SWITCH_STATUS_SUCCESS) {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Timer Setup Failed.  Conference Cannot Start/n");		return;	}	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "Setup timer %s success interval: %u  samples: %u/n",					  member->conference->timer_name, interval, tsamples);	write_frame.data = data = switch_core_session_alloc(member->session, SWITCH_RECOMMENDED_BUFFER_SIZE);	write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;	write_frame.codec = &member->write_codec;	/* Start the input thread */	conference_loop_launch_input(member, switch_core_session_get_pool(member->session));	if ((call_list = switch_channel_get_private(channel, "_conference_autocall_list_"))) {		const char *cid_name = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_name");		const char *cid_num = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_number");		const char *toval = switch_channel_get_variable(channel, "conference_auto_outcall_timeout");		const char *flags = switch_channel_get_variable(channel, "conference_utils_auto_outcall_flags");		const char *profile = switch_channel_get_variable(channel, "conference_auto_outcall_profile");		const char *ann = switch_channel_get_variable(channel, "conference_auto_outcall_announce");		const char *prefix = switch_channel_get_variable(channel, "conference_auto_outcall_prefix");		const char *maxwait = switch_channel_get_variable(channel, "conference_auto_outcall_maxwait");		const char *delimiter_val = switch_channel_get_variable(channel, "conference_auto_outcall_delimiter");		int to = 60;		int wait_sec = 2;		int loops = 0;		if (ann && !switch_channel_test_app_flag_key("conference_silent", channel, CONF_SILENT_REQ)) {			member->conference->special_announce = switch_core_strdup(member->conference->pool, ann);		}		switch_channel_set_private(channel, "_conference_autocall_list_", NULL);		conference_utils_set_flag(member->conference, CFLAG_OUTCALL);		if (toval) {			to = atoi(toval);			if (to < 10 || to > 500) {				to = 60;			}		}		for (cp = call_list; cp; cp = cp->next) {			int argc;			char *argv[512] = { 0 };			char *cpstr = strdup(cp->string);			int x = 0;			switch_assert(cpstr);			if (!zstr(delimiter_val) && strlen(delimiter_val) == 1) {				char delimiter = *delimiter_val;				argc = switch_separate_string(cpstr, delimiter, argv, (sizeof(argv) / sizeof(argv[0])));			} else {				argc = switch_separate_string(cpstr, ',', argv, (sizeof(argv) / sizeof(argv[0])));			}			for (x = 0; x < argc; x++) {				char *dial_str = switch_mprintf("%s%s", switch_str_nil(prefix), argv[x]);				switch_assert(dial_str);//.........这里部分代码省略.........

static switch_status_t my_on_reporting(switch_core_session_t *session){	struct json_object *json_cdr = NULL;	const char *json_text = NULL;	char *path = NULL;	char *curl_json_text = NULL;	const char *logdir = NULL;	char *json_text_escaped = NULL;	int fd = -1, err_dir_index;	uint32_t cur_try;	long httpRes;	CURL *curl_handle = NULL;	switch_curl_slist_t *headers = NULL;	switch_curl_slist_t *slist = NULL;	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_status_t status = SWITCH_STATUS_FALSE;	int is_b;	const char *a_prefix = "";	if (globals.shutdown) {		return SWITCH_STATUS_SUCCESS;	}	is_b = channel && switch_channel_get_originator_caller_profile(channel);	if (!globals.log_b && is_b) {		const char *force_cdr = switch_channel_get_variable(channel, SWITCH_FORCE_PROCESS_CDR_VARIABLE);		if (!switch_true(force_cdr)) {			return SWITCH_STATUS_SUCCESS;		}	}	if (!is_b && globals.prefix_a)		a_prefix = "a_";	if (generate_json_cdr(session, &json_cdr) != SWITCH_STATUS_SUCCESS) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Generating Data!/n");		return SWITCH_STATUS_FALSE;	}		json_text = json_object_to_json_string(json_cdr);	if (!json_text) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!/n");		goto error;	}	switch_thread_rwlock_rdlock(globals.log_path_lock);	if (!(logdir = switch_channel_get_variable(channel, "json_cdr_base"))) {		logdir = globals.log_dir;	}	if (!zstr(logdir) && (globals.log_http_and_disk || !globals.url_count)) {		path = switch_mprintf("%s%s%s%s.cdr.json", logdir, SWITCH_PATH_SEPARATOR, a_prefix, switch_core_session_get_uuid(session));		switch_thread_rwlock_unlock(globals.log_path_lock);		if (path) {#ifdef _MSC_VER			if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) {#else			if ((fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) > -1) {#endif				int wrote;				wrote = write(fd, json_text, (unsigned) strlen(json_text));				close(fd);				fd = -1;				if(wrote < 0) {					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error writing [%s]/n",path);				}			} else {				char ebuf[512] = { 0 };#ifdef WIN32				strerror_s(ebuf, sizeof(ebuf), errno);#else				strerror_r(errno, ebuf, sizeof(ebuf));#endif				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error writing [%s][%s]/n", path, ebuf);			}			switch_safe_free(path);		}	} else {		switch_thread_rwlock_unlock(globals.log_path_lock);	}	/* try to post it to the web server */	if (globals.url_count) {		char *destUrl = NULL;		curl_handle = switch_curl_easy_init();		if (globals.encode) {			switch_size_t need_bytes = strlen(json_text) * 3;			json_text_escaped = malloc(need_bytes);			switch_assert(json_text_escaped);			memset(json_text_escaped, 0, need_bytes);			if (globals.encode == ENCODING_DEFAULT) {				headers = switch_curl_slist_append(headers, "Content-Type: application/x-www-form-urlencoded");				switch_url_encode(json_text, json_text_escaped, need_bytes);			} else {				headers = switch_curl_slist_append(headers, "Content-Type: application/x-www-form-base64-encoded");				switch_b64_encode((unsigned char *) json_text, need_bytes / 3, (unsigned char *) json_text_escaped, need_bytes);//.........这里部分代码省略.........

//.........这里部分代码省略.........	switch_codec_t write_codec;	switch_frame_t read_frame;	unsigned char databuf[SWITCH_RECOMMENDED_BUFFER_SIZE];	switch_timer_t timer;	modem_t *modem;	switch_caller_profile_t *caller_profile;	int dead;};typedef struct private_object private_t;static switch_status_t channel_on_init(switch_core_session_t *session);static switch_status_t channel_on_hangup(switch_core_session_t *session);static switch_status_t channel_on_destroy(switch_core_session_t *session);static switch_status_t channel_on_routing(switch_core_session_t *session);static switch_status_t channel_on_exchange_media(switch_core_session_t *session);static switch_status_t channel_on_soft_execute(switch_core_session_t *session);static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,													switch_caller_profile_t *outbound_profile,													switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags,													switch_call_cause_t *cancel_cause);static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id);static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id);static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig);/*    State methods they get called when the state changes to the specific state    returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next   so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it.*/static switch_status_t channel_on_init(switch_core_session_t *session){	switch_channel_t *channel;	private_t *tech_pvt = NULL;	int to_ticks = 60, ring_ticks = 10, rt = ring_ticks;	int rest = 500000;		tech_pvt = switch_core_session_get_private(session);	switch_assert(tech_pvt != NULL);	channel = switch_core_session_get_channel(session);	switch_assert(channel != NULL);	if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {#ifndef WIN32		int tioflags;#endif		char call_time[16];		char call_date[16];		switch_size_t retsize;		switch_time_exp_t tm;		switch_time_exp_lt(&tm, switch_micro_time_now());		switch_strftime(call_date, &retsize, sizeof(call_date), "%m%d", &tm);		switch_strftime(call_time, &retsize, sizeof(call_time), "%H%M", &tm);#ifndef WIN32		ioctl(tech_pvt->modem->slave, TIOCMGET, &tioflags);		tioflags |= TIOCM_RI;		ioctl(tech_pvt->modem->slave, TIOCMSET, &tioflags);#endif		at_reset_call_info(&tech_pvt->modem->t31_state->at_state);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "DATE", call_date);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "TIME", call_time);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "NAME", tech_pvt->caller_profile->caller_id_name);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "NMBR", tech_pvt->caller_profile->caller_id_number);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "ANID", tech_pvt->caller_profile->ani);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "USER", tech_pvt->caller_profile->username);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "CDID", tech_pvt->caller_profile->context);		at_set_call_info(&tech_pvt->modem->t31_state->at_state, "NDID", tech_pvt->caller_profile->destination_number);		modem_set_state(tech_pvt->modem, MODEM_STATE_RINGING);		t31_call_event(tech_pvt->modem->t31_state, AT_CALL_EVENT_ALERTING);				while(to_ticks > 0 && switch_channel_up(channel) && modem_get_state(tech_pvt->modem) == MODEM_STATE_RINGING) {			if (--rt <= 0) {				t31_call_event(tech_pvt->modem->t31_state, AT_CALL_EVENT_ALERTING);				rt = ring_ticks;			}						switch_yield(rest);			to_ticks--;		}				if (to_ticks < 1 || modem_get_state(tech_pvt->modem) != MODEM_STATE_ANSWERED) {			t31_call_event(tech_pvt->modem->t31_state, AT_CALL_EVENT_NO_ANSWER);			switch_channel_hangup(channel, SWITCH_CAUSE_NO_ANSWER);		} else {			t31_call_event(tech_pvt->modem->t31_state, AT_CALL_EVENT_ANSWERED);			modem_set_state(tech_pvt->modem, MODEM_STATE_CONNECTED);			switch_channel_mark_answered(channel);		}	}	switch_channel_set_state(channel, CS_ROUTING);		return SWITCH_STATUS_SUCCESS;}

SWITCH_DECLARE(switch_status_t) switch_core_perform_new_memory_pool(switch_memory_pool_t **pool, const char *file, const char *func, int line){	char *tmp;#ifdef INSTANTLY_DESTROY_POOLS	apr_pool_create(pool, NULL);	switch_assert(*pool != NULL);#else#ifdef PER_POOL_LOCK	apr_allocator_t *my_allocator = NULL;	apr_thread_mutex_t *my_mutex;#else	void *pop = NULL;#endif#ifdef USE_MEM_LOCK	switch_mutex_lock(memory_manager.mem_lock);#endif	switch_assert(pool != NULL);#ifndef PER_POOL_LOCK	if (switch_queue_trypop(memory_manager.pool_recycle_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {		*pool = (switch_memory_pool_t *) pop;	} else {#endif#ifdef PER_POOL_LOCK		if ((apr_allocator_create(&my_allocator)) != APR_SUCCESS) {			abort();		}		if ((apr_pool_create_ex(pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {			abort();		}		if ((apr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, *pool)) != APR_SUCCESS) {			abort();		}		apr_allocator_mutex_set(my_allocator, my_mutex);		apr_allocator_owner_set(my_allocator, *pool);		apr_pool_mutex_set(*pool, my_mutex);#else		apr_pool_create(pool, NULL);		switch_assert(*pool != NULL);	}#endif#endif	tmp = switch_core_sprintf(*pool, "%s:%d", file, line);	apr_pool_tag(*pool, tmp);#ifdef DEBUG_ALLOC2	switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_CONSOLE, "%p New Pool %s/n", (void *) *pool, apr_pool_tag(*pool, NULL));#endif#ifdef USE_MEM_LOCK	switch_mutex_unlock(memory_manager.mem_lock);#endif	return SWITCH_STATUS_SUCCESS;}

switch_memory_pool_t *switch_core_memory_init(void){#ifndef INSTANTLY_DESTROY_POOLS	switch_threadattr_t *thd_attr;#endif#ifdef PER_POOL_LOCK	apr_allocator_t *my_allocator = NULL;	apr_thread_mutex_t *my_mutex;#endif	memset(&memory_manager, 0, sizeof(memory_manager));#ifdef PER_POOL_LOCK	if ((apr_allocator_create(&my_allocator)) != APR_SUCCESS) {		abort();	}	if ((apr_pool_create_ex(&memory_manager.memory_pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {		apr_allocator_destroy(my_allocator);		my_allocator = NULL;		abort();	}	if ((apr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, memory_manager.memory_pool)) != APR_SUCCESS) {		abort();	}	apr_allocator_mutex_set(my_allocator, my_mutex);	apr_pool_mutex_set(memory_manager.memory_pool, my_mutex);	apr_allocator_owner_set(my_allocator, memory_manager.memory_pool);	apr_pool_tag(memory_manager.memory_pool, "core_pool");#else	apr_pool_create(&memory_manager.memory_pool, NULL);	switch_assert(memory_manager.memory_pool != NULL);#endif#ifdef USE_MEM_LOCK	switch_mutex_init(&memory_manager.mem_lock, SWITCH_MUTEX_NESTED, memory_manager.memory_pool);#endif#ifdef INSTANTLY_DESTROY_POOLS	{		void *foo;		foo = (void *) (intptr_t) pool_thread;	}#else	switch_queue_create(&memory_manager.pool_queue, 50000, memory_manager.memory_pool);	switch_queue_create(&memory_manager.pool_recycle_queue, 50000, memory_manager.memory_pool);	switch_threadattr_create(&thd_attr, memory_manager.memory_pool);	switch_threadattr_detach_set(thd_attr, 0);	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);	switch_thread_create(&pool_thread_p, thd_attr, pool_thread, NULL, memory_manager.memory_pool);	while (!memory_manager.pool_thread_running) {		switch_cond_next();	}#endif	return memory_manager.memory_pool;}

SWITCH_DECLARE(switch_status_t) switch_core_asr_feed(switch_asr_handle_t *ah, void *data, unsigned int len, switch_asr_flag_t *flags){	switch_assert(ah != NULL);	return ah->asr_interface->asr_feed(ah, data, len, flags);}

static void switch_core_standard_on_soft_execute(switch_core_session_t *session){	switch_assert(session != NULL);	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard SOFT_EXECUTE/n", switch_channel_get_name(session->channel));}

static void switch_core_standard_on_consume_media(switch_core_session_t *session){	switch_assert(session != NULL);	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard CONSUME_MEDIA/n", switch_channel_get_name(session->channel));}

static switch_status_t my_on_reporting(switch_core_session_t *session){    switch_channel_t *channel = switch_core_session_get_channel(session);    switch_status_t status = SWITCH_STATUS_SUCCESS;    char *values = NULL, *tmp = NULL, *pq_var = NULL;    const char *var = NULL;    cdr_field_t *cdr_field = NULL;    switch_size_t len, offset;    if (globals.shutdown) {        return SWITCH_STATUS_SUCCESS;    }    if (!((globals.legs & CDR_LEG_A) && (globals.legs & CDR_LEG_B))) {        if ((globals.legs & CDR_LEG_A)) {            if (switch_channel_get_originator_caller_profile(channel)) {                return SWITCH_STATUS_SUCCESS;            }        } else {            if (switch_channel_get_originatee_caller_profile(channel)) {                return SWITCH_STATUS_SUCCESS;            }        }    }    if (switch_dir_make_recursive(globals.spool_dir, SWITCH_DEFAULT_DIR_PERMS, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating %s/n", globals.spool_dir);        return SWITCH_STATUS_FALSE;    }    if (globals.debug) {        switch_event_t *event;        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {            char *buf;            switch_channel_event_set_data(channel, event);            switch_event_serialize(event, &buf, SWITCH_FALSE);            switch_assert(buf);            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:/n%s/n", buf);            switch_event_destroy(&event);            switch_safe_free(buf);        }    }    switch_zmalloc(values, 1);    offset = 0;    for (cdr_field = globals.db_schema->fields; cdr_field->var_name; cdr_field++) {        if ((var = switch_channel_get_variable(channel, cdr_field->var_name))) {            /* Allocate sufficient buffer for PQescapeString */            len = strlen(var);            tmp = switch_core_session_alloc(session, len * 2 + 1);            PQescapeString(tmp, var, len);            var = tmp;        }        if ((cdr_field->not_null == SWITCH_FALSE) && zstr(var)) {            pq_var = switch_mprintf("null,", var);        } else {            if (cdr_field->quote) {                pq_var = switch_mprintf("'%s',", var);            } else {                pq_var = switch_mprintf("%s,", var);            }        }        /* Resize values buffer to accomodate next var */        len = strlen(pq_var);        tmp = realloc(values, offset + len);        values = tmp;        memcpy(values + offset, pq_var, len);        switch_safe_free(pq_var);        offset += len;    }    *(values + --offset) = '/0';    insert_cdr(values);    switch_safe_free(values);    return status;}

/* marshall frames from the call leg to the conference thread for muxing to other call legs */void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj){	switch_event_t *event;	conference_member_t *member = obj;	switch_channel_t *channel;	switch_status_t status;	switch_frame_t *read_frame = NULL;	uint32_t hangover = 40, hangunder = 5, hangover_hits = 0, hangunder_hits = 0, diff_level = 400;	switch_core_session_t *session = member->session;	uint32_t flush_len;	switch_frame_t tmp_frame = { 0 };	if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {		goto end;	}	switch_assert(member != NULL);	conference_utils_member_clear_flag_locked(member, MFLAG_TALKING);	channel = switch_core_session_get_channel(session);	switch_core_session_get_read_impl(session, &member->read_impl);	switch_channel_audio_sync(channel);	flush_len = switch_samples_per_packet(member->conference->rate, member->conference->interval) * 2 * member->conference->channels * (500 / member->conference->interval);	/* As long as we have a valid read, feed that data into an input buffer where the conference thread will take it	   and mux it with any audio from other channels. */	while (conference_utils_member_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {		if (switch_channel_ready(channel) && switch_channel_test_app_flag(channel, CF_APP_TAGGED)) {			switch_yield(100000);			continue;		}		/* Read a frame. */		status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);		switch_mutex_lock(member->read_mutex);		/* end the loop, if appropriate */		if (!SWITCH_READ_ACCEPTABLE(status) || !conference_utils_member_test_flag(member, MFLAG_RUNNING)) {			switch_mutex_unlock(member->read_mutex);			break;		}		if (switch_channel_test_flag(channel, CF_VIDEO) && !conference_utils_member_test_flag(member, MFLAG_ACK_VIDEO)) {			conference_utils_member_set_flag_locked(member, MFLAG_ACK_VIDEO);			conference_video_check_avatar(member, SWITCH_FALSE);			switch_core_session_video_reinit(member->session);			conference_video_set_floor_holder(member->conference, member, SWITCH_FALSE);		} else if (conference_utils_member_test_flag(member, MFLAG_ACK_VIDEO) && !switch_channel_test_flag(channel, CF_VIDEO)) {			conference_video_check_avatar(member, SWITCH_FALSE);		}		/* if we have caller digits, feed them to the parser to find an action */		if (switch_channel_has_dtmf(channel)) {			char dtmf[128] = "";			switch_channel_dequeue_dtmf_string(channel, dtmf, sizeof(dtmf));			if (conference_utils_member_test_flag(member, MFLAG_DIST_DTMF)) {				conference_member_send_all_dtmf(member, member->conference, dtmf);			} else if (member->dmachine) {				char *p;				char str[2] = "";				for (p = dtmf; p && *p; p++) {					str[0] = *p;					switch_ivr_dmachine_feed(member->dmachine, str, NULL);				}			}		} else if (member->dmachine) {			switch_ivr_dmachine_ping(member->dmachine, NULL);		}		if (switch_queue_size(member->dtmf_queue)) {			switch_dtmf_t *dt;			void *pop;			if (switch_queue_trypop(member->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {				dt = (switch_dtmf_t *) pop;				switch_core_session_send_dtmf(member->session, dt);				free(dt);			}		}		if (switch_channel_test_flag(member->channel, CF_CONFERENCE_RESET_MEDIA)) {			member->reset_media = 10;			switch_channel_audio_sync(member->channel);			switch_channel_clear_flag(member->channel, CF_CONFERENCE_RESET_MEDIA);		}		if (member->reset_media) {			if (--member->reset_media > 0) {				goto do_continue;			}//.........这里部分代码省略.........

static switch_status_t channel_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg){	switch_channel_t *channel;	loopback_private_t *tech_pvt;	int done = 1, pass = 0;	switch_core_session_t *other_session;		channel = switch_core_session_get_channel(session);	switch_assert(channel != NULL);	tech_pvt = switch_core_session_get_private(session);	switch_assert(tech_pvt != NULL);	switch (msg->message_id) {	case SWITCH_MESSAGE_INDICATE_ANSWER:		if (tech_pvt->other_channel && !switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {			switch_channel_mark_answered(tech_pvt->other_channel);		}		break;	case SWITCH_MESSAGE_INDICATE_PROGRESS:		if (tech_pvt->other_channel && !switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {			switch_channel_mark_pre_answered(tech_pvt->other_channel);		}		break;	case SWITCH_MESSAGE_INDICATE_RINGING:		if (tech_pvt->other_channel && !switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {			switch_channel_mark_ring_ready(tech_pvt->other_channel);		}		break;	case SWITCH_MESSAGE_INDICATE_BRIDGE:		{			switch_set_flag_locked(tech_pvt, TFLAG_BRIDGE);		}		break;	case SWITCH_MESSAGE_INDICATE_UNBRIDGE:		{			switch_clear_flag_locked(tech_pvt, TFLAG_BRIDGE);		}		break;	default:		done = 0;		break;	}	switch (msg->message_id) {	case SWITCH_MESSAGE_INDICATE_BRIDGE:	case SWITCH_MESSAGE_INDICATE_UNBRIDGE:	case SWITCH_MESSAGE_INDICATE_AUDIO_SYNC:		{			done = 1;			switch_set_flag(tech_pvt, TFLAG_CLEAR);			switch_set_flag(tech_pvt->other_tech_pvt, TFLAG_CLEAR);			switch_core_timer_sync(&tech_pvt->timer);			switch_core_timer_sync(&tech_pvt->other_tech_pvt->timer);		}		break;	default:		break;	}	switch (msg->message_id) {	case SWITCH_MESSAGE_INDICATE_DISPLAY:		if (tech_pvt->other_channel) {			if (switch_test_flag(tech_pvt, TFLAG_BLEG)) {				if (!zstr(msg->string_array_arg[0])) {					switch_channel_set_profile_var(tech_pvt->other_channel, "caller_id_name", msg->string_array_arg[0]);				}								if (!zstr(msg->string_array_arg[1])) {					switch_channel_set_profile_var(tech_pvt->other_channel, "caller_id_number", msg->string_array_arg[1]);				}			} else {				if (!zstr(msg->string_array_arg[0])) {					switch_channel_set_profile_var(tech_pvt->other_channel, "callee_id_name", msg->string_array_arg[0]);				}								if (!zstr(msg->string_array_arg[1])) {					switch_channel_set_profile_var(tech_pvt->other_channel, "callee_id_number", msg->string_array_arg[1]);				}			}						pass = 1;		}		break;	case SWITCH_MESSAGE_INDICATE_DEFLECT:		{			pass = 0;			if (!zstr(msg->string_arg) && switch_core_session_get_partner(tech_pvt->other_session, &other_session) == SWITCH_STATUS_SUCCESS) {				char *ext = switch_core_session_strdup(other_session, msg->string_arg);				char *context = NULL, *dp = NULL;								if ((context = strchr(ext, ' '))) {					*context++ = '/0';										if ((dp = strchr(context, ' '))) {//.........这里部分代码省略.........

static void switch_core_standard_on_hibernate(switch_core_session_t *session){	switch_assert(session != NULL);	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Standard HIBERNATE/n", switch_channel_get_name(session->channel));}

SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session){	switch_channel_state_t state = CS_NEW, midstate = CS_DESTROY, endstate;	const switch_endpoint_interface_t *endpoint_interface;	const switch_state_handler_table_t *driver_state_handler = NULL;	const switch_state_handler_table_t *application_state_handler = NULL;	int silly = 0;	uint32_t new_loops = 60000;	/*	   Life of the channel. you have channel and pool in your session	   everywhere you go you use the session to malloc with	   switch_core_session_alloc(session, <size>)	   The endpoint module gets the first crack at implementing the state	   if it wants to, it can cancel the default behavior by returning SWITCH_STATUS_FALSE	   Next comes the channel's event handler table that can be set by an application	   which also can veto the next behavior in line by returning SWITCH_STATUS_FALSE	   Finally the default state behavior is called.	 */	switch_assert(session != NULL);	switch_set_flag(session, SSF_THREAD_RUNNING);	endpoint_interface = session->endpoint_interface;	switch_assert(endpoint_interface != NULL);	driver_state_handler = endpoint_interface->state_handler;	switch_assert(driver_state_handler != NULL);	switch_mutex_lock(session->mutex);	while ((state = switch_channel_get_state(session->channel)) != CS_DESTROY) {		if (switch_channel_test_flag(session->channel, CF_BLOCK_STATE)) {			switch_channel_wait_for_flag(session->channel, CF_BLOCK_STATE, SWITCH_FALSE, 0, NULL);			if ((state = switch_channel_get_state(session->channel)) == CS_DESTROY) {				break;			}		}		midstate = state;		if (state != switch_channel_get_running_state(session->channel) || state >= CS_HANGUP) {			int index = 0;			int proceed = 1;			int global_proceed = 1;			int do_extra_handlers = 1;			switch_io_event_hook_state_run_t *ptr;			switch_status_t rstatus = SWITCH_STATUS_SUCCESS;			switch_channel_set_running_state(session->channel, state);			switch_channel_clear_flag(session->channel, CF_TRANSFER);			switch_channel_clear_flag(session->channel, CF_REDIRECT);						if (session->endpoint_interface->io_routines->state_run) {				rstatus = session->endpoint_interface->io_routines->state_run(session);			}						if (rstatus == SWITCH_STATUS_SUCCESS) {				for (ptr = session->event_hooks.state_run; ptr; ptr = ptr->next) {					if ((rstatus = ptr->state_run(session)) != SWITCH_STATUS_SUCCESS) {						break;					}				}			}						switch (state) {			case CS_NEW:		/* Just created, Waiting for first instructions */				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) State NEW/n", switch_channel_get_name(session->channel));				break;			case CS_DESTROY:				goto done;			case CS_REPORTING:	/* Call Detail */				{					switch_core_session_reporting_state(session);					switch_channel_set_state(session->channel, CS_DESTROY);				}				goto done;			case CS_HANGUP:	/* Deactivate and end the thread */				{					switch_core_session_hangup_state(session, SWITCH_TRUE);					switch_channel_set_state(session->channel, CS_REPORTING);				}				break;			case CS_INIT:		/* Basic setup tasks */				STATE_MACRO(init, "INIT");				break;			case CS_ROUTING:	/* Look for a dialplan and find something to do */				STATE_MACRO(routing, "ROUTING");				break;			case CS_RESET:		/* Reset */				STATE_MACRO(reset, "RESET");				break;				/* These other states are intended for prolonged durations so we do not signal lock for them */			case CS_EXECUTE:	/* Execute an Operation */				STATE_MACRO(execute, "EXECUTE");//.........这里部分代码省略.........

/*    State methods they get called when the state changes to the specific state    returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next   so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it.*/static switch_status_t channel_on_init(switch_core_session_t *session){	switch_channel_t *channel, *b_channel;	loopback_private_t *tech_pvt = NULL, *b_tech_pvt = NULL;	switch_core_session_t *b_session;	char name[128];	switch_caller_profile_t *caller_profile;	switch_event_t *vars = NULL;	const char *var;	tech_pvt = switch_core_session_get_private(session);	switch_assert(tech_pvt != NULL);	channel = switch_core_session_get_channel(session);	switch_assert(channel != NULL);	if (switch_test_flag(tech_pvt, TFLAG_OUTBOUND) && !switch_test_flag(tech_pvt, TFLAG_BLEG)) {		if (!(b_session = switch_core_session_request(loopback_endpoint_interface, SWITCH_CALL_DIRECTION_INBOUND, SOF_NONE, NULL))) {			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Failure./n");			goto end;		}		if (switch_core_session_read_lock(b_session) != SWITCH_STATUS_SUCCESS) {			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Failure./n");			switch_core_session_destroy(&b_session);			goto end;		}		switch_core_session_add_stream(b_session, NULL);		b_channel = switch_core_session_get_channel(b_session);		b_tech_pvt = (loopback_private_t *) switch_core_session_alloc(b_session, sizeof(*b_tech_pvt));		switch_snprintf(name, sizeof(name), "loopback/%s-b", tech_pvt->caller_profile->destination_number);		switch_channel_set_name(b_channel, name);		if (tech_init(b_tech_pvt, b_session, switch_core_session_get_read_codec(session)) != SWITCH_STATUS_SUCCESS) {			switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);			switch_core_session_destroy(&b_session);			goto end;		}		caller_profile = switch_caller_profile_clone(b_session, tech_pvt->caller_profile);		caller_profile->source = switch_core_strdup(caller_profile->pool, modname);		switch_channel_set_caller_profile(b_channel, caller_profile);		b_tech_pvt->caller_profile = caller_profile;		switch_channel_set_state(b_channel, CS_INIT);		switch_mutex_lock(tech_pvt->mutex);		tech_pvt->other_session = b_session;		tech_pvt->other_tech_pvt = b_tech_pvt;		tech_pvt->other_channel = b_channel;		switch_mutex_unlock(tech_pvt->mutex);		//b_tech_pvt->other_session = session;		//b_tech_pvt->other_tech_pvt = tech_pvt;		//b_tech_pvt->other_channel = channel;		b_tech_pvt->other_uuid = switch_core_session_strdup(b_session, switch_core_session_get_uuid(session));		switch_set_flag_locked(tech_pvt, TFLAG_LINKED);		switch_set_flag_locked(b_tech_pvt, TFLAG_LINKED);		switch_set_flag_locked(b_tech_pvt, TFLAG_BLEG);		switch_channel_set_flag(channel, CF_ACCEPT_CNG);		if ((vars = (switch_event_t *) switch_channel_get_private(channel, "__loopback_vars__"))) {			switch_event_header_t *h;					switch_channel_set_private(channel, "__loopback_vars__", NULL);			for (h = vars->headers; h; h = h->next) {				switch_channel_set_variable(tech_pvt->other_channel, h->name, h->value);			}			switch_event_destroy(&vars);		}		if ((var = switch_channel_get_variable(channel, "loopback_export"))) {			int argc = 0;			char *argv[128] = { 0 };			char *dup = switch_core_session_strdup(session, var);			if ((argc = switch_split(dup, ',', argv))) {				int i;				for (i = 0; i < argc; i++) {										if (!zstr(argv[i])) {						const char *val = switch_channel_get_variable(channel, argv[i]);						if(!zstr(val)) {							switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Transfer variable [%s]=[%s] %s -> %s/n",											  argv[i], val, switch_channel_get_name(channel), switch_channel_get_name(tech_pvt->other_channel));//.........这里部分代码省略.........

static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id){	switch_channel_t *channel = NULL;	loopback_private_t *tech_pvt = NULL;	switch_status_t status = SWITCH_STATUS_FALSE;	switch_mutex_t *mutex = NULL;	void *pop = NULL;	channel = switch_core_session_get_channel(session);	switch_assert(channel != NULL);	tech_pvt = switch_core_session_get_private(session);	switch_assert(tech_pvt != NULL);	if (!switch_test_flag(tech_pvt, TFLAG_LINKED)) {		goto end;	}	*frame = NULL;	if (!switch_channel_ready(channel)) {		goto end;	}	switch_core_timer_next(&tech_pvt->timer);	mutex = tech_pvt->mutex;	switch_mutex_lock(mutex);	if (switch_test_flag(tech_pvt, TFLAG_CLEAR)) {		clear_queue(tech_pvt);		switch_clear_flag(tech_pvt, TFLAG_CLEAR);	}	if (switch_queue_trypop(tech_pvt->frame_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {		if (tech_pvt->write_frame) {			switch_frame_free(&tech_pvt->write_frame);		}				tech_pvt->write_frame = (switch_frame_t *) pop;		tech_pvt->write_frame->codec = &tech_pvt->read_codec;		*frame = tech_pvt->write_frame;		tech_pvt->packet_count++;		switch_clear_flag(tech_pvt->write_frame, SFF_CNG);		tech_pvt->first_cng = 0;	} else {		*frame = &tech_pvt->cng_frame;		tech_pvt->cng_frame.codec = &tech_pvt->read_codec;		tech_pvt->cng_frame.datalen = tech_pvt->read_codec.implementation->decoded_bytes_per_packet;		switch_set_flag((&tech_pvt->cng_frame), SFF_CNG);		if (!tech_pvt->first_cng) {			switch_yield(tech_pvt->read_codec.implementation->samples_per_packet);			tech_pvt->first_cng = 1;		}	}	if (*frame) {		status = SWITCH_STATUS_SUCCESS;	} else {		status = SWITCH_STATUS_FALSE;	}  end:	if (mutex) {		switch_mutex_unlock(mutex);	}	return status;}

//.........这里部分代码省略.........		switch_hash_index_t *cur;		switch_ssize_t keylen;		const void *key;		void *value;		time_t now = switch_epoch_time_now(NULL);		struct peer_status *last;		char *host;		for (cur = switch_hash_first(NULL, globals.peer_hash); cur; cur = switch_hash_next(cur)) {			switch_hash_this(cur, &key, &keylen, &value);			host = (char *) key;			last = (struct peer_status *) value;			if (last->active && (now - (last->lastseen)) > 60) {				switch_event_t *local_event;				last->active = SWITCH_FALSE;				if (switch_event_create_subclass(&local_event, SWITCH_EVENT_CUSTOM, MULTICAST_PEERDOWN) == SWITCH_STATUS_SUCCESS) {					char lastseen[21];					switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Peer", host);					switch_snprintf(lastseen, sizeof(lastseen), "%d", (int) last->lastseen);					switch_event_add_header_string(local_event, SWITCH_STACK_BOTTOM, "Lastseen", lastseen);					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Peer %s has gone down; last seen: %s/n", host, lastseen);					switch_event_fire(&local_event);				}			}		}	}	switch_mutex_lock(globals.mutex);	if (globals.event_list[(uint8_t) SWITCH_EVENT_ALL]) {		send = 1;	} else if ((globals.event_list[(uint8_t) event->event_id])) {		if (event->event_id != SWITCH_EVENT_CUSTOM || (event->subclass_name && switch_core_hash_find(globals.event_hash, event->subclass_name))) {			send = 1;		}	}	switch_mutex_unlock(globals.mutex);	if (send) {		char *packet;		switch (event->event_id) {		case SWITCH_EVENT_LOG:			return;		default:			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Multicast-Sender", switch_core_get_switchname());			if (switch_event_serialize(event, &packet, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {				size_t len;				char *buf;#ifdef HAVE_OPENSSL				int outlen, tmplen;				EVP_CIPHER_CTX ctx;				char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];				switch_uuid_t uuid;				switch_uuid_get(&uuid);				switch_uuid_format(uuid_str, &uuid);				len = strlen(packet) + SWITCH_UUID_FORMATTED_LENGTH + EVP_MAX_IV_LENGTH + strlen((char *) MAGIC);#else				len = strlen(packet) + strlen((char *) MAGIC);#endif				buf = malloc(len + 1);				memset(buf, 0, len + 1);				switch_assert(buf);#ifdef HAVE_OPENSSL				if (globals.psk) {					switch_copy_string(buf, uuid_str, SWITCH_UUID_FORMATTED_LENGTH);					EVP_CIPHER_CTX_init(&ctx);					EVP_EncryptInit(&ctx, EVP_bf_cbc(), NULL, NULL);					EVP_CIPHER_CTX_set_key_length(&ctx, strlen(globals.psk));					EVP_EncryptInit(&ctx, NULL, (unsigned char *) globals.psk, (unsigned char *) uuid_str);					EVP_EncryptUpdate(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH,									  &outlen, (unsigned char *) packet, (int) strlen(packet));					EVP_EncryptUpdate(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH + outlen,									  &tmplen, (unsigned char *) MAGIC, (int) strlen((char *) MAGIC));					outlen += tmplen;					EVP_EncryptFinal(&ctx, (unsigned char *) buf + SWITCH_UUID_FORMATTED_LENGTH + outlen, &tmplen);					outlen += tmplen;					len = (size_t) outlen + SWITCH_UUID_FORMATTED_LENGTH;					*(buf + SWITCH_UUID_FORMATTED_LENGTH + outlen) = '/0';				} else {#endif					switch_copy_string(buf, packet, len);					switch_copy_string(buf + strlen(packet), (char *) MAGIC, strlen((char *) MAGIC) + 1);#ifdef HAVE_OPENSSL				}#endif				switch_socket_sendto(globals.udp_socket, globals.addr, 0, buf, &len);				switch_safe_free(packet);				switch_safe_free(buf);			}			break;		}	}	return;}

static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id){	switch_channel_t *channel = NULL;	loopback_private_t *tech_pvt = NULL;	switch_status_t status = SWITCH_STATUS_FALSE;	channel = switch_core_session_get_channel(session);	switch_assert(channel != NULL);	tech_pvt = switch_core_session_get_private(session);	switch_assert(tech_pvt != NULL);	if (switch_test_flag(frame, SFF_CNG) || 		(switch_test_flag(tech_pvt, TFLAG_BOWOUT) && switch_test_flag(tech_pvt, TFLAG_BOWOUT_USED))) {		switch_core_timer_sync(&tech_pvt->timer);		switch_core_timer_sync(&tech_pvt->other_tech_pvt->timer);		return SWITCH_STATUS_SUCCESS;	}	switch_mutex_lock(tech_pvt->mutex);	if (!switch_test_flag(tech_pvt, TFLAG_BOWOUT) &&		tech_pvt->other_tech_pvt &&		switch_test_flag(tech_pvt, TFLAG_BRIDGE) &&		!switch_test_flag(tech_pvt, TFLAG_BLEG) &&		switch_test_flag(tech_pvt->other_tech_pvt, TFLAG_BRIDGE) &&		switch_channel_test_flag(tech_pvt->channel, CF_BRIDGED) &&		switch_channel_test_flag(tech_pvt->other_channel, CF_BRIDGED) &&		switch_channel_test_flag(tech_pvt->channel, CF_ANSWERED) &&		switch_channel_test_flag(tech_pvt->other_channel, CF_ANSWERED) && --tech_pvt->bowout_frame_count <= 0) {		const char *a_uuid = NULL;		const char *b_uuid = NULL;		const char *vetoa, *vetob;		vetoa = switch_channel_get_variable(tech_pvt->channel, "loopback_bowout");		vetob = switch_channel_get_variable(tech_pvt->other_tech_pvt->channel, "loopback_bowout");		if ((!vetoa || switch_true(vetoa)) && (!vetob || switch_true(vetob))) {			switch_core_session_t *br_a, *br_b;			switch_channel_t *ch_a = NULL, *ch_b = NULL;			int good_to_go = 0;			switch_mutex_unlock(tech_pvt->mutex);			find_non_loopback_bridge(session, &br_a, &a_uuid);			find_non_loopback_bridge(tech_pvt->other_session, &br_b, &b_uuid);			switch_mutex_lock(tech_pvt->mutex);						if (br_a) {				ch_a = switch_core_session_get_channel(br_a);				switch_core_media_bug_transfer_recordings(session, br_a);			}			if (br_b) {				ch_b = switch_core_session_get_channel(br_b);				switch_core_media_bug_transfer_recordings(tech_pvt->other_session, br_b);			}						if (ch_a && ch_b && switch_channel_test_flag(ch_a, CF_BRIDGED) && switch_channel_test_flag(ch_b, CF_BRIDGED)) {				switch_set_flag_locked(tech_pvt, TFLAG_BOWOUT);				switch_set_flag_locked(tech_pvt->other_tech_pvt, TFLAG_BOWOUT);				switch_clear_flag_locked(tech_pvt, TFLAG_WRITE);				switch_clear_flag_locked(tech_pvt->other_tech_pvt, TFLAG_WRITE);				switch_set_flag_locked(tech_pvt, TFLAG_BOWOUT_USED);				switch_set_flag_locked(tech_pvt->other_tech_pvt, TFLAG_BOWOUT_USED);				if (a_uuid && b_uuid) {					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,									  "%s detected bridge on both ends, attempting direct connection./n", switch_channel_get_name(channel));										/* channel_masquerade eat your heart out....... */					switch_ivr_uuid_bridge(a_uuid, b_uuid);					good_to_go = 1;					switch_mutex_unlock(tech_pvt->mutex);				}			}			if (br_a) switch_core_session_rwunlock(br_a);			if (br_b) switch_core_session_rwunlock(br_b);						if (good_to_go) {				return SWITCH_STATUS_SUCCESS;			}		}	}	if (switch_test_flag(tech_pvt, TFLAG_LINKED) && tech_pvt->other_tech_pvt) {		switch_frame_t *clone;				if (frame->codec->implementation != tech_pvt->write_codec.implementation) {			/* change codecs to match */			tech_init(tech_pvt, session, frame->codec);			tech_init(tech_pvt->other_tech_pvt, tech_pvt->other_session, frame->codec);		}//.........这里部分代码省略.........

//.........这里部分代码省略.........			p++;		}		if (!p || switch_core_codec_init_with_bitrate(&codec, p, NULL, fmtp, rate, ptime, channels, bitrate, SWITCH_CODEC_FLAG_ENCODE|SWITCH_CODEC_FLAG_DECODE, NULL, pool) != SWITCH_STATUS_SUCCESS) {			fprintf(stderr, "Couldn't initialize codec for %[email
C++ switch_channel_event_set_data函数代码示例
C++ switch_api_execute函数代码示例