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

static switch_status_t load_config(void){    char *cf = "reference.conf";    switch_xml_t cfg, xml, settings, param;    memset(&globals, 0, sizeof(globals));    switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, module_pool);    if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed/n", cf);        return SWITCH_STATUS_TERM;    }    if ((settings = switch_xml_child(cfg, "settings"))) {        for (param = switch_xml_child(settings, "param"); param; param = param->next) {            char *var = (char *) switch_xml_attr_soft(param, "name");            char *val = (char *) switch_xml_attr_soft(param, "value");            if (!strcmp(var, "debug")) {                globals.debug = atoi(val);            } else if (!strcmp(var, "port")) {                globals.port = atoi(val);            } else if (!strcmp(var, "ip")) {                set_global_ip(val);            } else if (!strcmp(var, "codec-master")) {                if (!strcasecmp(val, "us")) {                    switch_set_flag(&globals, GFLAG_MY_CODEC_PREFS);                }            } else if (!strcmp(var, "dialplan")) {                set_global_dialplan(val);            } else if (!strcmp(var, "codec-prefs")) {                set_global_codec_string(val);                globals.codec_order_last = switch_separate_string(globals.codec_string, ',', globals.codec_order, SWITCH_MAX_CODECS);            } else if (!strcmp(var, "codec-rates")) {                set_global_codec_rates_string(val);                globals.codec_rates_last = switch_separate_string(globals.codec_rates_string, ',', globals.codec_rates, SWITCH_MAX_CODECS);            }        }    }    if (!globals.dialplan) {        set_global_dialplan("default");    }    if (!globals.port) {        globals.port = 4569;    }    switch_xml_free(xml);    return SWITCH_STATUS_SUCCESS;}

static switch_status_t switch_siren_fmtp_parse(const char *fmtp, switch_codec_fmtp_t *codec_fmtp){	if (codec_fmtp) {		int bit_rate = 0;		memset(codec_fmtp, '/0', sizeof(struct switch_codec_fmtp));		if (fmtp) {			int x, argc;			char *argv[10];			char *fmtp_dup = strdup(fmtp);			switch_assert(fmtp_dup);			argc = switch_separate_string(fmtp_dup, ';', argv, (sizeof(argv) / sizeof(argv[0])));			for (x = 0; x < argc; x++) {				char *data = argv[x];				char *arg;				switch_assert(data);				while (*data == ' ') {					data++;				}				if ((arg = strchr(data, '='))) {					*arg++ = '/0';					if (!strcasecmp(data, "bitrate")) {						bit_rate = atoi(arg);					}				}			}			free(fmtp_dup);		}		codec_fmtp->bits_per_second = bit_rate;		return SWITCH_STATUS_SUCCESS;	}	return SWITCH_STATUS_FALSE;}

static switch_status_t limit_state_handler(switch_core_session_t *session){	switch_channel_t *channel = switch_core_session_get_channel(session);	switch_channel_state_t state = switch_channel_get_state(channel);	const char *vval = switch_channel_get_variable(channel, LIMIT_IGNORE_TRANSFER_VARIABLE);	const char *backendlist = switch_channel_get_variable(channel, LIMIT_BACKEND_VARIABLE);		if (zstr(backendlist)) {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Unset limit backendlist!/n");		return SWITCH_STATUS_SUCCESS;	}	if (state >= CS_HANGUP || (state == CS_ROUTING && !switch_true(vval))) {		int argc = 0;		char *argv[6] = { 0 };		char *mydata = strdup(backendlist);		int x;				argc = switch_separate_string(mydata, ',', argv, (sizeof(argv) / sizeof(argv[0])));		for (x = 0; x < argc; x++) {			switch_limit_release(argv[x], session, NULL, NULL);		}		switch_core_event_hook_remove_state_change(session, limit_state_handler);		/* Remove limit_backend variable so we register another hook if limit is called again */		switch_channel_set_variable(channel, LIMIT_BACKEND_VARIABLE, NULL);				free(mydata);	}		return SWITCH_STATUS_SUCCESS;}

static switch_status_t switch_sangoma_init_ilbc(switch_codec_t *codec, switch_codec_flag_t flags, const switch_codec_settings_t *codec_settings){	int mode = codec->implementation->microseconds_per_packet / 1000;	if (codec->fmtp_in) {		int x, argc;		char *argv[10];		argc = switch_separate_string(codec->fmtp_in, ';', argv, (sizeof(argv) / sizeof(argv[0])));		for (x = 0; x < argc; x++) {			char *data = argv[x];			char *arg;			switch_assert(data);			while (*data == ' ') {				data++;			}			if ((arg = strchr(data, '='))) {				*arg++ = '/0';				if (!strcasecmp(data, "mode")) {					mode = atoi(arg);				}			}		}	}	codec->fmtp_out = switch_core_sprintf(codec->memory_pool, "mode=%d", mode);	return switch_sangoma_init(codec, flags, codec_settings);}

static perl_parse_and_execute(PerlInterpreter * my_perl, char *input_code, char *setup_code){	int error = 0;	if (*input_code == '~') {		char *buff = input_code + 1;		perl_parse(my_perl, xs_init, 3, embedding, NULL);		if (setup_code)			Perl_safe_eval(my_perl, setup_code);		Perl_safe_eval(my_perl, buff);	} else {		int argc = 0;		char *argv[128] = { 0 };		char *err;		argv[0] = "FreeSWITCH";		argc++;		argc += switch_separate_string(input_code, ' ', &argv[1], (sizeof(argv) / sizeof(argv[0])) - 1);		if (!perl_parse(my_perl, xs_init, argc, argv, (char **) NULL)) {			if (setup_code) {				if (!Perl_safe_eval(my_perl, setup_code)) {					perl_run(my_perl);				}			}		}		if ((err = SvPV(get_sv("@", TRUE), n_a)) && !zstr(err)) {			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s/n", err);		}	}}

SWITCH_DECLARE(uint32_t) switch_log_str2mask(const char *str){	int argc = 0, x = 0;	char *argv[10] = { 0 };	uint32_t mask = 0;	char *p = strdup(str);	switch_log_level_t level;	switch_assert(p);	if ((argc = switch_separate_string(p, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {		for (x = 0; x < argc && argv[x]; x++) {			if (!strcasecmp(argv[x], "all")) {				mask = 0xFF;				break;			} else {				level = switch_log_str2level(argv[x]);				if (level != SWITCH_LOG_INVALID) {					mask |= (1 << level);				}			}		}	}	free(p);	return mask;}

void conference_loop_exec_app(conference_member_t *member, caller_control_action_t *action){	char *app = NULL;	char *arg = "";	char *argv[2] = { 0 };	int argc;	char *mydata = NULL;	switch_event_t *event = NULL;	switch_channel_t *channel = NULL;	if (!action->expanded_data) return;	if (test_eflag(member->conference, EFLAG_DTMF) && 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", "execute_app");		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", action->expanded_data);		switch_event_fire(&event);	}	mydata = strdup(action->expanded_data);	switch_assert(mydata);	if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {		if (argc > 0) {			app = argv[0];		}		if (argc > 1) {			arg = argv[1];		}	} else {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty execute app string [%s]/n",						  (char *) action->expanded_data);		goto done;	}	if (!app) {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to find application./n");		goto done;	}	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_INFO, "Execute app: %s, %s/n", app, arg);	channel = switch_core_session_get_channel(member->session);	switch_channel_set_app_flag(channel, CF_APP_TAGGED);	switch_core_session_set_read_codec(member->session, NULL);	switch_core_session_execute_application(member->session, app, arg);	switch_core_session_set_read_codec(member->session, &member->read_codec);	switch_channel_clear_app_flag(channel, CF_APP_TAGGED); done:	switch_safe_free(mydata);	return;}

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

static switch_status_t switch_speex_fmtp_parse(const char *fmtp, switch_codec_fmtp_t *codec_fmtp){	if (codec_fmtp) {		speex_codec_settings_t *codec_settings = NULL;		if (codec_fmtp->private_info) {			codec_settings = codec_fmtp->private_info;			memcpy(codec_settings, &default_codec_settings, sizeof(*codec_settings));		}		if (fmtp) {			int x, argc;			char *argv[10];			char *fmtp_dup = strdup(fmtp);			switch_assert(fmtp_dup);			argc = switch_separate_string(fmtp_dup, ';', argv, (sizeof(argv) / sizeof(argv[0])));			for (x = 0; x < argc; x++) {				char *data = argv[x];				char *arg;				switch_assert(data);				while (*data == ' ') {					data++;				}				if ((arg = strchr(data, '='))) {					*arg++ = '/0';					/*					   if (!strcasecmp(data, "bitrate")) {					   bit_rate = atoi(arg);					   }					 */					/*					   if (codec_settings) {					   if (!strcasecmp(data, "vad")) {					   bit_rate = atoi(arg);					   }					   }					 */							}			}			free(fmtp_dup);		}		/*codec_fmtp->bits_per_second = bit_rate;*/		return SWITCH_STATUS_SUCCESS;	}	return SWITCH_STATUS_FALSE;}

void conference_loop_transfer(conference_member_t *member, caller_control_action_t *action){	char *exten = NULL;	char *dialplan = "XML";	char *context = "default";	char *argv[3] = { 0 };	int argc;	char *mydata = NULL;	switch_event_t *event;	if (test_eflag(member->conference, EFLAG_DTMF) && 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", "transfer");		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Dialplan", action->expanded_data);		switch_event_fire(&event);	}	conference_utils_member_clear_flag_locked(member, MFLAG_RUNNING);	if ((mydata = switch_core_session_strdup(member->session, action->expanded_data))) {		if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {			if (argc > 0) {				exten = argv[0];			}			if (argc > 1) {				dialplan = argv[1];			}			if (argc > 2) {				context = argv[2];			}		} else {			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Empty transfer string [%s]/n", (char *) action->expanded_data);			goto done;		}	} else {		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Unable to allocate memory to duplicate transfer data./n");		goto done;	}	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_INFO, "Transfering to: %s, %s, %s/n", exten, dialplan, context);	switch_ivr_session_transfer(member->session, exten, dialplan, context); done:	return;}

static switch_status_t cdr_mongo_authenticate() {	switch_status_t status = SWITCH_STATUS_SUCCESS;	mongo_error_t db_status;	char *ns_tmp, *ns_split[2];	/* Split namespace db.collection into separate vars */	switch_strdup(ns_tmp, globals.mongo_namespace);	switch_separate_string(ns_tmp, '.', ns_split, 2);	db_status = mongo_cmd_authenticate(globals.mongo_conn, ns_split[0], globals.mongo_username, globals.mongo_password);	if (db_status != MONGO_OK) {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "mongo_cmd_authenticate: authentication failed/n");		status = SWITCH_STATUS_FALSE;	} else {		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Successfully authenticated %[email
C++ switch_set_flag函数代码示例
C++ switch_safe_free函数代码示例