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

SWITCH_DECLARE(switch_status_t) switch_nat_del_mapping(switch_port_t port, switch_nat_ip_proto_t proto){	switch_status_t status = SWITCH_STATUS_FALSE;	switch_event_t *event = NULL;	switch (nat_globals.nat_type) {	case SWITCH_NAT_TYPE_PMP:		status = switch_nat_del_mapping_pmp(port, proto);		break;	case SWITCH_NAT_TYPE_UPNP:		status = switch_nat_del_mapping_upnp(port, proto);		break;	default:		break;	}	if (status == SWITCH_STATUS_SUCCESS) {		switch_event_create(&event, SWITCH_EVENT_NAT);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "op", "del");		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "port", "%d", port);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", "%d", proto);		switch_event_fire(&event);	}	return status;}

static void switch_scheduler_execute(switch_scheduler_task_container_t *tp){	switch_event_t *event;	//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Executing task %u %s (%s)/n", tp->task.task_id, tp->desc, switch_str_nil(tp->task.group));	tp->func(&tp->task);	if (tp->task.repeat) {		tp->task.runtime = switch_epoch_time_now(NULL) + tp->task.repeat;	}	if (tp->task.runtime > tp->executed) {		tp->executed = 0;		if (switch_event_create(&event, SWITCH_EVENT_RE_SCHEDULE) == SWITCH_STATUS_SUCCESS) {			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-ID", "%u", tp->task.task_id);			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Desc", tp->desc);			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Group", switch_str_nil(tp->task.group));			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-Runtime", "%" SWITCH_INT64_T_FMT, tp->task.runtime);			switch_queue_push(globals.event_queue, event);			event = NULL;		}	} else {		tp->destroyed = 1;	}}

void append_event_message(switch_core_session_t *session, vmivr_profile_t *profile, switch_event_t *phrase_params, switch_event_t *msg_list_event, size_t current_msg) {	char *varname;	char *apicmd;	char *total_msg = NULL;	if (!msg_list_event || !(total_msg = switch_event_get_header(msg_list_event, "VM-List-Count")) || current_msg > atoi(total_msg)) {		/* TODO Error MSG */		return;	}	varname = switch_mprintf("VM-List-Message-%" SWITCH_SIZE_T_FMT "-UUID", current_msg);	apicmd = switch_mprintf("json %s %s %s %s", profile->api_profile, profile->domain, profile->id, switch_event_get_header(msg_list_event, varname));	switch_safe_free(varname);	jsonapi2event(session, phrase_params, profile->api_msg_get, apicmd);	/* TODO Set these 2 header correctly */	switch_event_add_header(phrase_params, SWITCH_STACK_BOTTOM, "VM-Message-Type", "%s", "new");	switch_event_add_header(phrase_params, SWITCH_STACK_BOTTOM, "VM-Message-Number", "%"SWITCH_SIZE_T_FMT, current_msg);	switch_event_add_header_string(phrase_params, SWITCH_STACK_BOTTOM, "VM-Message-Private-Local-Copy", "False");	switch_safe_free(apicmd);}

int skinny_device_event_callback(void *pArg, int argc, char **argv, char **columnNames){	switch_event_t *event = (switch_event_t *) pArg;	char *profile_name = argv[0];	char *device_name = argv[1];	char *user_id = argv[2];	char *device_instance = argv[3];	char *ip = argv[4];	char *device_type = argv[5];	char *max_streams = argv[6];	char *port = argv[7];	char *codec_string = argv[8];	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Profile-Name", "%s", profile_name);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Device-Name", "%s", device_name);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Station-User-Id", "%s", user_id);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Station-Instance", "%s", device_instance);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-IP-Address", "%s", ip);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Device-Type", "%s", device_type);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Max-Streams", "%s", max_streams);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Port", "%s", port);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-Codecs", "%s", codec_string);	return 0;}

static switch_status_t skinny_api_cmd_profile_device_send_data(const char *profile_name, const char *device_name, const char *message_type, char *params, const char *body, switch_stream_handle_t *stream){	skinny_profile_t *profile;	if ((profile = skinny_find_profile(profile_name))) {		listener_t *listener = NULL;		skinny_profile_find_listener_by_device_name(profile, device_name, &listener);		if(listener) {			switch_event_t *event = NULL;			char *argv[64] = { 0 };			int argc = 0;			int x = 0;			/* skinny::user_to_device event */			skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_USER_TO_DEVICE);			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Message-Id-String", "%s", message_type);			argc = switch_separate_string(params, ';', argv, (sizeof(argv) / sizeof(argv[0])));			for (x = 0; x < argc; x++) {				char *var_name, *var_value = NULL;				var_name = argv[x];				if (var_name && (var_value = strchr(var_name, '='))) {					*var_value++ = '/0';				}				if (zstr(var_name)) {					stream->write_function(stream, "-ERR No variable specified/n");				} else {					char *tmp = switch_mprintf("Skinny-UserToDevice-%s", var_name);					switch_event_add_header(event, SWITCH_STACK_BOTTOM, tmp, "%s", var_value);					switch_safe_free(tmp);					/*					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Application-Id", "%d", request->data.extended_data.application_id);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Line-Instance", "%d", request->data.extended_data.line_instance);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Call-Id", "%d", request->data.extended_data.call_id);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Transaction-Id", "%d", request->data.extended_data.transaction_id);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Data-Length", "%d", request->data.extended_data.data_length);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Sequence-Flag", "%d", request->data.extended_data.sequence_flag);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Display-Priority", "%d", request->data.extended_data.display_priority);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Conference-Id", "%d", request->data.extended_data.conference_id);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-App-Instance-Id", "%d", request->data.extended_data.app_instance_id);					   switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-UserToDevice-Routing-Id", "%d", request->data.extended_data.routing_id);					 */				}			}			switch_event_add_body(event, "%s", body);			switch_event_fire(&event);			stream->write_function(stream, "+OK/n");		} else {			stream->write_function(stream, "Listener not found!/n");		}	} else {		stream->write_function(stream, "Profile not found!/n");	}	return SWITCH_STATUS_SUCCESS;}

SWITCH_DECLARE(uint32_t) switch_scheduler_add_task(time_t task_runtime,												   switch_scheduler_func_t func,												   const char *desc, const char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags){	switch_scheduler_task_container_t *container, *tp;	switch_event_t *event;	switch_time_t now = switch_epoch_time_now(NULL);	switch_ssize_t hlen = -1;	switch_mutex_lock(globals.task_mutex);	switch_zmalloc(container, sizeof(*container));	switch_assert(func);	if (task_runtime < now) {		container->task.repeat = (uint32_t)task_runtime;		task_runtime += now;	}	container->func = func;	container->task.created = now;	container->task.runtime = task_runtime;	container->task.group = strdup(group ? group : "none");	container->task.cmd_id = cmd_id;	container->task.cmd_arg = cmd_arg;	container->flags = flags;	container->desc = strdup(desc ? desc : "none");	container->task.hash = switch_ci_hashfunc_default(container->task.group, &hlen);	for (tp = globals.task_list; tp && tp->next; tp = tp->next);	if (tp) {		tp->next = container;	} else {		globals.task_list = container;	}	for (container->task.task_id = 0; !container->task.task_id; container->task.task_id = ++globals.task_id);	switch_mutex_unlock(globals.task_mutex);	tp = container;	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Added task %u %s (%s) to run at %" SWITCH_INT64_T_FMT "/n",					  tp->task.task_id, tp->desc, switch_str_nil(tp->task.group), tp->task.runtime);	if (switch_event_create(&event, SWITCH_EVENT_ADD_SCHEDULE) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-ID", "%u", tp->task.task_id);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Desc", tp->desc);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Group", switch_str_nil(tp->task.group));		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-Runtime", "%" SWITCH_INT64_T_FMT, tp->task.runtime);		switch_queue_push(globals.event_queue, event);		event = NULL;	}	return container->task.task_id;}

switch_status_t conference_event_add_data(conference_obj_t *conference, switch_event_t *event){	switch_status_t status = SWITCH_STATUS_SUCCESS;	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Size", "%u", conference->count);	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Ghosts", "%u", conference->count_ghosts);	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Conference-Profile-Name", conference->profile_name);	switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Conference-Unique-ID", conference->uuid_str);	return status;}

static void append_event_profile(vmivr_menu_t *menu) {	if (!menu->phrase_params) {		switch_event_create(&menu->phrase_params, SWITCH_EVENT_REQUEST_PARAMS);	}	/* Used for some appending function */	if (menu->profile && menu->profile->name && menu->profile->id && menu->profile->domain) {		switch_event_add_header(menu->phrase_params, SWITCH_STACK_BOTTOM, "VM-Profile", "%s", menu->profile->name);		switch_event_add_header(menu->phrase_params, SWITCH_STACK_BOTTOM, "VM-Account-ID", "%s", menu->profile->id);		switch_event_add_header(menu->phrase_params, SWITCH_STACK_BOTTOM, "VM-Account-Domain", "%s", menu->profile->domain);	}}

static void ctdm_report_alarms(ftdm_channel_t *channel){	switch_event_t *event = NULL;	ftdm_alarm_flag_t alarmflag = 0;	if (switch_event_create(&event, SWITCH_EVENT_TRAP) != SWITCH_STATUS_SUCCESS) {		ftdm_log(FTDM_LOG_ERROR, "failed to create alarms events/n");		return;	}		if (ftdm_channel_get_alarms(channel, &alarmflag) != FTDM_SUCCESS) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to retrieve alarms %s:%d/n", ftdm_channel_get_span_name(channel), ftdm_channel_get_id(channel));		return;	}	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-name", "%s", ftdm_channel_get_span_name(channel));	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-number", "%d", ftdm_channel_get_span_id(channel));	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "chan-number", "%d", ftdm_channel_get_id(channel));		if (alarmflag) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-trap");	} else {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-clear");	}	if (alarmflag & FTDM_ALARM_RED) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "red");	}	if (alarmflag & FTDM_ALARM_YELLOW) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "yellow");	}	if (alarmflag & FTDM_ALARM_RAI) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "rai");	}	if (alarmflag & FTDM_ALARM_BLUE) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "blue");	}	if (alarmflag & FTDM_ALARM_AIS) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "ais");	}	if (alarmflag & FTDM_ALARM_GENERAL) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "general");	}	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Reporting [%s] alarms for %s:%d/n", 			(alarmflag?"ftdm-alarm-trap":"ftdm-alarm-clear"), ftdm_channel_get_span_name(channel), ftdm_channel_get_id(channel));	switch_event_fire(&event);	return;}

SWITCH_DECLARE(void) switch_limit_fire_event(const char *backend, const char *realm, const char *key, uint32_t usage, uint32_t rate, uint32_t max, uint32_t ratemax){	switch_event_t *event;	if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, LIMIT_EVENT_USAGE) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "backend", backend);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "realm", realm);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "key", key);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "usage", "%d", usage);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rate", "%d", rate);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "max", "%d", max);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "ratemax", "%d", ratemax);		switch_event_fire(&event);	}}

void vmivr_menu_authenticate(switch_core_session_t *session, vmivr_profile_t *profile) {	switch_channel_t *channel = switch_core_session_get_channel(session);	vmivr_menu_t menu = { "std_authenticate" };	int retry;	const char *auth_var = NULL;	/* Initialize Menu Configs */	menu_init(profile, &menu);	if (profile->id && (auth_var = switch_channel_get_variable(channel, "voicemail_authorized")) && switch_true(auth_var)) {		profile->authorized = SWITCH_TRUE;	}	for (retry = menu.ivr_maximum_attempts; switch_channel_ready(channel) && retry > 0 && profile->authorized == SWITCH_FALSE; retry--) {		const char *id = profile->id, *password = NULL;		char *cmd = NULL;		const char *password_mask = switch_event_get_header(menu.event_settings, "Password-Mask");		const char *user_mask = switch_event_get_header(menu.event_settings, "User-Mask");		if (!id) {			vmivr_menu_t sub_menu = { "std_authenticate_ask_user" };			/* Initialize Menu Configs */			menu_init(profile, &sub_menu);			switch_event_add_header(sub_menu.phrase_params, SWITCH_STACK_BOTTOM, "IVR-Retry-Left", "%d", retry);			id = vmivr_menu_get_input_set(session, profile, &sub_menu, user_mask);			menu_free(&sub_menu);		}		if (!password) {			vmivr_menu_t sub_menu = { "std_authenticate_ask_password" };			/* Initialize Menu Configs */			menu_init(profile, &sub_menu);			switch_event_add_header(sub_menu.phrase_params, SWITCH_STACK_BOTTOM, "IVR-Retry-Left", "%d", retry);			password = vmivr_menu_get_input_set(session, profile, &sub_menu, password_mask);			menu_free(&sub_menu);		}		cmd = switch_core_session_sprintf(session, "%s %s %s %s", profile->api_profile, profile->domain, id, password);		if (vmivr_api_execute(session, profile->api_auth_login, cmd) == SWITCH_STATUS_SUCCESS) {			profile->id = id;			profile->authorized = SWITCH_TRUE;		} else {			ivre_playback_dtmf_buffered(session, switch_event_get_header(menu.event_phrases, "fail_auth"), NULL, NULL, NULL, 0);		}	}	menu_free(&menu);}

void conference_loop_volume_listen_dn(conference_member_t *member, caller_control_action_t *action){	char msg[512];	switch_event_t *event;	if (member == NULL)		return;	member->volume_in_level--;	switch_normalize_volume(member->volume_in_level);	if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {		conference_member_add_event_data(member, event);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);		switch_event_fire(&event);	}	//switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);	//conference_member_say(member, msg, 0);	if (member->volume_in_level < 0) {		switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_in_level);		conference_member_play_file(member, msg, 0, SWITCH_TRUE);	}	switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_in_level));	conference_member_play_file(member, msg, 0, SWITCH_TRUE);}

static void *torture_thread(switch_thread_t *thread, void *obj){	int y = 0;	int z = 0;	switch_core_thread_session_t *ts = obj;	switch_event_t *event;	z = THREADS++;	while (THREADS > 0) {		int x;		for (x = 0; x < 1; x++) {			if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_COOL) == SWITCH_STATUS_SUCCESS) {				switch_event_add_header(event, "event_info", "hello world %d %d", z, y++);				switch_event_fire(&event);			}		}		switch_yield(100000);	}	if (ts->pool) {		switch_memory_pool_t *pool = ts->pool;		switch_core_destroy_memory_pool(&pool);	}	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Thread Ended/n");}

static void do_rotate(cdr_fd_t *fd){	switch_time_exp_t tm;	char date[80] = "";	switch_size_t retsize;	char *p;	close(fd->fd);	fd->fd = -1;	if (globals.rotate) {		switch_time_exp_lt(&tm, switch_micro_time_now());		switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d-%H-%M-%S", &tm);		p = switch_mprintf("%s.%s", fd->path, date);		assert(p);		switch_file_rename(fd->path, p, globals.pool);		free(p);	}	do_reopen(fd);	if (fd->fd < 0) {		switch_event_t *event;		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error opening %s/n", fd->path);		if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) {			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Critical-Error", "Error opening cdr file %s/n", fd->path);			switch_event_fire(&event);		}	} else {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "%s CDR logfile %s/n", globals.rotate ? "Rotated" : "Re-opened", fd->path);	}}

SWITCH_DECLARE(switch_status_t) switch_core_session_set_video_write_codec(switch_core_session_t *session, switch_codec_t *codec){	switch_event_t *event;	switch_channel_t *channel = switch_core_session_get_channel(session);	char tmp[30];	switch_status_t status = SWITCH_STATUS_SUCCESS;	if (!codec || !codec->implementation || !switch_core_codec_ready(codec)) {		if (session->video_write_codec) {			session->video_write_codec = NULL;			status = SWITCH_STATUS_SUCCESS;			goto end;		}		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot set NULL codec!/n");		status = SWITCH_STATUS_FALSE;		goto end;	}	if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {		switch_channel_event_set_data(session->channel, event);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-name", codec->implementation->iananame);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-video-write-codec-rate", "%d", codec->implementation->actual_samples_per_second);		switch_event_fire(&event);	}	switch_channel_set_variable(channel, "video_write_codec", codec->implementation->iananame);	switch_snprintf(tmp, sizeof(tmp), "%d", codec->implementation->actual_samples_per_second);	switch_channel_set_variable(channel, "video_write_rate", tmp);	session->video_write_codec = codec;	session->video_write_impl = *codec->implementation;  end:	return status;}

void conference_loop_energy_dn(conference_member_t *member, caller_control_action_t *action){	char msg[512], str[30] = "", *p;	switch_event_t *event;	if (member == NULL)		return;	member->energy_level -= 200;	if (member->energy_level < 0) {		member->energy_level = 0;	}	if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&		switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {		conference_member_add_event_data(member, event);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);		switch_event_fire(&event);	}	//switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);	//conference_member_say(member, msg, 0);	switch_snprintf(str, sizeof(str), "%d", abs(member->energy_level) / 200);	for (p = str; p && *p; p++) {		switch_snprintf(msg, sizeof(msg), "digits/%c.wav", *p);		conference_member_play_file(member, msg, 0, SWITCH_TRUE);	}}

static void event_handler(switch_event_t *event) {	const char *dest_proto = switch_event_get_header(event, "dest_proto");	const char *check_failure = switch_event_get_header(event, "Delivery-Failure");	const char *check_nonblocking = switch_event_get_header(event, "Nonblocking-Delivery");	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "skip_global_process", "true");	if (switch_true(check_failure)) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Delivery Failure/n");		DUMP_EVENT(event);		send_report(event, "Failure");		return;	} else if ( check_failure && switch_false(check_failure) ) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SMS Delivery Success/n");		send_report(event, "Success");		return;	} else if ( check_nonblocking && switch_true(check_nonblocking) ) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SMS Delivery assumed successful due to being sent in non-blocking manner/n");		send_report(event, "Accepted");		return;	}	switch_core_chat_send(dest_proto, event);}

static void switch_core_media_bug_destroy(switch_media_bug_t *bug){	switch_event_t *event = NULL;	if (bug->raw_read_buffer) {		switch_buffer_destroy(&bug->raw_read_buffer);	}	if (bug->raw_write_buffer) {		switch_buffer_destroy(&bug->raw_write_buffer);	}	if (switch_event_create(&event, SWITCH_EVENT_MEDIA_BUG_STOP) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Function", "%s", bug->function);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Media-Bug-Target", "%s", bug->target);		if (bug->session) switch_channel_event_set_data(bug->session->channel, event);		switch_event_fire(&event);	}}

void vmivr_menu_preference(switch_core_session_t *session, vmivr_profile_t *profile) {	switch_channel_t *channel = switch_core_session_get_channel(session);	int retry;	vmivr_menu_t menu = { "std_preference" };	/* Initialize Menu Configs */	menu_init(profile, &menu);	if (!menu.event_keys_dtmf || !menu.event_phrases) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing Menu Phrases or Keys in menu '%s'/n", menu.name);		goto end;	}	for (retry = menu.ivr_maximum_attempts; switch_channel_ready(channel) && retry > 0; retry--) {		menu_instance_init(&menu);		switch_event_add_header(menu.phrase_params, SWITCH_STACK_BOTTOM, "IVR-Retry-Left", "%d", retry);		ivre_init(&menu.ivre_d, menu.dtmfa);		ivre_playback(session, &menu.ivre_d, switch_event_get_header(menu.event_phrases, "menu_options"), NULL, menu.phrase_params, NULL, menu.ivr_entry_timeout);		if (menu.ivre_d.result == RES_TIMEOUT) {			ivre_playback_dtmf_buffered(session, switch_event_get_header(menu.event_phrases, "timeout"), NULL, NULL, NULL, 0);		} else if (menu.ivre_d.result == RES_INVALID) {			ivre_playback_dtmf_buffered(session, switch_event_get_header(menu.event_phrases, "invalid"), NULL, NULL, NULL, 0);		} else if (menu.ivre_d.result == RES_FOUND) {  /* Matching DTMF Key Pressed */			const char *action = switch_event_get_header(menu.event_keys_dtmf, menu.ivre_d.dtmf_stored);			/* Reset the try count */			retry = menu.ivr_maximum_attempts;			if (action) {				if (!strcasecmp(action, "return")) { /* Return to the previous menu */					retry = -1;				} else if (!strncasecmp(action, "menu:", 5)) { /* Sub Menu */					void (*fPtr)(switch_core_session_t *session, vmivr_profile_t *profile) = vmivr_get_menu_function(action+5);					if (fPtr) {						fPtr(session, profile);					}				}			}		}		menu_instance_free(&menu);	}end:	menu_free(&menu);}

char *vmivr_menu_get_input_set(switch_core_session_t *session, vmivr_profile_t *profile, vmivr_menu_t *menu, const char *input_mask) {	char *result = NULL;	int retry;	const char *terminate_key = NULL;	switch_channel_t *channel = switch_core_session_get_channel(session);	if (!menu->event_keys_dtmf || !menu->event_phrases) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing Menu Phrases or Keys in menu '%s'/n", menu->name);		goto end;	}	terminate_key = switch_event_get_header(menu->event_keys_action, "ivrengine:terminate_entry");	for (retry = menu->ivr_maximum_attempts; switch_channel_ready(channel) && retry > 0; retry--) {		int i;		menu_instance_init(menu);		switch_event_add_header(menu->phrase_params, SWITCH_STACK_BOTTOM, "IVR-Retry-Left", "%d", retry);		/* Find the last entry and append this one to it */		for (i=0; i < 16 && menu->dtmfa[i]; i++){		}		menu->dtmfa[i] = (char *) input_mask;		ivre_init(&menu->ivre_d, menu->dtmfa);		if (terminate_key) {			menu->ivre_d.terminate_key = terminate_key[0];		}		ivre_playback(session, &menu->ivre_d, switch_event_get_header(menu->event_phrases, "instructions"), NULL, menu->phrase_params, NULL, menu->ivr_entry_timeout);		if (menu->ivre_d.result == RES_TIMEOUT) {			ivre_playback_dtmf_buffered(session, switch_event_get_header(menu->event_phrases, "timeout"), NULL, NULL, NULL, 0);		} else if (menu->ivre_d.result == RES_INVALID) {			ivre_playback_dtmf_buffered(session, switch_event_get_header(menu->event_phrases, "invalid"), NULL, NULL, NULL, 0);		} else if (menu->ivre_d.result == RES_FOUND) {  /* Matching DTMF Key Pressed */			/* Reset the try count */			retry = menu->ivr_maximum_attempts;			if (!strncasecmp(menu->ivre_d.completeMatch, input_mask, 1)) {				result = switch_core_session_strdup(session, menu->ivre_d.dtmf_stored);				retry = -1;			}		}		menu_instance_free(menu);	}end:	return result;}

cc_status_t cc_agent_get(const char *key, const char *agent, char *ret_result, size_t ret_result_size){	cc_status_t result = CC_STATUS_SUCCESS;	char *sql;	switch_event_t *event;	char res[256];	/* Check to see if agent already exists */	sql = switch_mprintf("SELECT count(*) FROM agents WHERE name = '%q'", agent);	cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));	switch_safe_free(sql);	if (atoi(res) == 0) {		result = CC_STATUS_AGENT_NOT_FOUND;		goto done;	}	if (!strcasecmp(key, "status") || !strcasecmp(key, "state") || !strcasecmp(key, "uuid") ) { 		/* Check to see if agent already exists */		sql = switch_mprintf("SELECT %q FROM agents WHERE name = '%q'", key, agent);		cc_execute_sql2str(NULL, NULL, sql, res, sizeof(res));		switch_safe_free(sql);		switch_snprintf(ret_result, ret_result_size, "%s", res);		result = CC_STATUS_SUCCESS;		if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CALLCENTER_EVENT) == SWITCH_STATUS_SUCCESS) {			char tmpname[256];			if (!strcasecmp(key, "uuid")) {				switch_snprintf(tmpname, sizeof(tmpname), "CC-Agent-UUID");				} else {				switch_snprintf(tmpname, sizeof(tmpname), "CC-Agent-%c%s", (char) switch_toupper(key[0]), key+1);			}			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CC-Agent", agent);			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "CC-Action", "agent-%s-get", key);			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, tmpname, res);			switch_event_fire(&event);		}	} else {		result = CC_STATUS_INVALID_KEY;		goto done;	}done:   	if (result == CC_STATUS_SUCCESS) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Get Info Agent %s %s = %s/n", agent, key, res);	}	return result;}

SWITCH_DECLARE(void) switch_console_printf(switch_text_channel_t channel, const char *file, const char *func, int line, const char *fmt, ...){	char *data = NULL;	int ret = 0;	va_list ap;	FILE *handle = switch_core_data_channel(channel);	const char *filep = switch_cut_path(file);	char date[80] = "";	switch_size_t retsize;	switch_time_exp_t tm;	switch_event_t *event;	va_start(ap, fmt);	ret = switch_vasprintf(&data, fmt, ap);	va_end(ap);	if (ret == -1) {		fprintf(stderr, "Memory Error/n");		goto done;	}	if (channel == SWITCH_CHANNEL_ID_LOG_CLEAN) {		fprintf(handle, "%s", data);		goto done;	}	switch_time_exp_lt(&tm, switch_micro_time_now());	switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm);	if (channel == SWITCH_CHANNEL_ID_LOG) {		fprintf(handle, "[%d] %s %s:%d %s() %s", (int) getpid(), date, filep, line, func, data);		goto done;	}	if (channel == SWITCH_CHANNEL_ID_EVENT &&		switch_event_running() == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_LOG) == SWITCH_STATUS_SUCCESS) {		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Data", data);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-File", filep);		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Function", func);		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Line", "%d", line);		switch_event_fire(&event);	}  done:	if (data) {		free(data);	}	fflush(handle);}

void BoardE1::onLinkStatus(K3L_EVENT *e){    DBG(FUNC, D("Link %02hu on board %02hu changed") % e->AddInfo % e->DeviceId);    /* Fire a custom event about this */    switch_event_t * event;    if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, KHOMP_EVENT_MAINT) == SWITCH_STATUS_SUCCESS)    {        //khomp_add_event_board_data(e->AddInfo, event);        Board::khomp_add_event_board_data(K3LAPI::target(Globals::k3lapi, K3LAPI::target::LINK, e->DeviceId, e->AddInfo), event);        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "EV_LINK_STATUS", "%d", e->AddInfo);        switch_event_fire(&event);    }}

static switch_status_t chat_send(switch_event_t *message_event)								 {	switch_status_t status = SWITCH_STATUS_BREAK;	switch_event_t *exten;	int forwards = 0;	const char *var;	var = switch_event_get_header(message_event, "max_forwards");	if (!var) {		forwards = 70;	} else {		forwards = atoi(var);				if (forwards) {			forwards--;		}		if (!forwards) {			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Max forwards reached/n");			DUMP_EVENT(message_event);			return SWITCH_STATUS_FALSE;		}	}	if (forwards) {		switch_event_add_header(message_event, SWITCH_STACK_BOTTOM, "max_forwards", "%d", forwards);	}	if ((exten = chatplan_hunt(message_event))) {		switch_event_header_t *hp;				for (hp = exten->headers; hp; hp = hp->next) {			status = switch_core_execute_chat_app(message_event, hp->name, hp->value);			if (!SWITCH_READ_ACCEPTABLE(status)) {				status = SWITCH_STATUS_SUCCESS;					break;			}		}		switch_event_destroy(&exten);	} else {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SMS chatplan no actions found/n");	}	return status;}

static void populate_dtmfa_from_event(vmivr_menu_t *menu) {	int i = 0;	if (menu->event_keys_dtmf) {		switch_event_header_t *hp;		for (hp = menu->event_keys_dtmf->headers; hp; hp = hp->next) {			if (strlen(hp->name) < 3 && hp->value) { /* TODO This is a hack to discard default FS Events ! */				const char *varphrasename = switch_event_get_header(menu->event_keys_varname, hp->value);				menu->dtmfa[i++] = hp->name;				if (varphrasename && !zstr(varphrasename)) {					switch_event_add_header(menu->phrase_params, SWITCH_STACK_BOTTOM, varphrasename, "%s", hp->name);				}			}		}	}	menu->dtmfa[i++] = '/0';}

void jsonapi_populate_event(switch_core_session_t *session, switch_event_t *apply_event, const char *api, const char *data) {	switch_event_t *phrases_event = NULL;	switch_stream_handle_t stream = { 0 };	switch_event_header_t *hp;	switch_assert(apply_event);	SWITCH_STANDARD_STREAM(stream);	switch_api_execute(api, data, session, &stream);	switch_event_create_json(&phrases_event, (char *) stream.data);	switch_safe_free(stream.data);	for (hp = phrases_event->headers; hp; hp = hp->next) {		if (!strncasecmp(hp->name, "VM-", 3)) {			switch_event_add_header(apply_event, SWITCH_STACK_BOTTOM, hp->name, "%s", hp->value);		}	}	switch_event_destroy(&phrases_event);	phrases_event = apply_event;	return;}

void conference_data_event_handler(switch_event_t *event){	switch_event_t *revent;	char *name = switch_event_get_header(event, "conference-name");	char *domain = switch_event_get_header(event, "conference-domain");	conference_obj_t *conference = NULL;	char *body = NULL;	if (!zstr(name) && (conference = conference_find(name, domain))) {		if (conference_utils_test_flag(conference, CFLAG_RFC4579)) {			switch_event_dup(&revent, event);			revent->event_id = SWITCH_EVENT_CONFERENCE_DATA;			revent->flags |= EF_UNIQ_HEADERS;			switch_event_add_header(revent, SWITCH_STACK_TOP, "Event-Name", "CONFERENCE_DATA");			body = conference_cdr_rfc4579_render(conference, event, revent);			switch_event_add_body(revent, "%s", body);			switch_event_fire(&revent);			switch_safe_free(body);		}		switch_thread_rwlock_unlock(conference->rwlock);	}}

static int task_thread_loop(int done){	switch_scheduler_task_container_t *tofree, *tp, *last = NULL;	switch_mutex_lock(globals.task_mutex);	for (tp = globals.task_list; tp; tp = tp->next) {		if (done) {			tp->destroyed = 1;		} else if (!tp->destroyed) {			int64_t now = switch_epoch_time_now(NULL);			if (now >= tp->task.runtime && !tp->in_thread) {				int32_t diff = (int32_t) (now - tp->task.runtime);				if (diff > 1) {					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Task was executed late by %d seconds %u %s (%s)/n",									  diff, tp->task.task_id, tp->desc, switch_str_nil(tp->task.group));				}				tp->executed = now;				if (switch_test_flag(tp, SSHF_OWN_THREAD)) {					switch_thread_t *thread;					switch_threadattr_t *thd_attr;					switch_core_new_memory_pool(&tp->pool);					switch_threadattr_create(&thd_attr, tp->pool);					switch_threadattr_detach_set(thd_attr, 1);					tp->in_thread = 1;					switch_thread_create(&thread, thd_attr, task_own_thread, tp, tp->pool);				} else {					tp->running = 1;					switch_mutex_unlock(globals.task_mutex);					switch_scheduler_execute(tp);					switch_mutex_lock(globals.task_mutex);					tp->running = 0;				}			}		}	}	switch_mutex_unlock(globals.task_mutex);	switch_mutex_lock(globals.task_mutex);	for (tp = globals.task_list; tp;) {		if (tp->destroyed && !tp->in_thread) {			switch_event_t *event;			tofree = tp;			tp = tp->next;			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Deleting task %u %s (%s)/n",							  tofree->task.task_id, tofree->desc, switch_str_nil(tofree->task.group));			if (switch_event_create(&event, SWITCH_EVENT_DEL_SCHEDULE) == SWITCH_STATUS_SUCCESS) {				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-ID", "%u", tofree->task.task_id);				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Desc", tofree->desc);				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Task-Group", switch_str_nil(tofree->task.group));				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Task-Runtime", "%" SWITCH_INT64_T_FMT, tofree->task.runtime);				switch_queue_push(globals.event_queue, event);				event = NULL;			}			if (last) {				last->next = tofree->next;			} else {				globals.task_list = tofree->next;			}			switch_safe_free(tofree->task.group);			if (tofree->task.cmd_arg && switch_test_flag(tofree, SSHF_FREE_ARG)) {				free(tofree->task.cmd_arg);			}			switch_safe_free(tofree->desc);			free(tofree);		} else {			last = tp;			tp = tp->next;		}	}	switch_mutex_unlock(globals.task_mutex);	return done;}