/* * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * Copyright (C) 2005-2012, Anthony Minessale II * * Version: MPL 1.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * * The Initial Developer of the Original Code is * Anthony Minessale II * Portions created by the Initial Developer are Copyright (C) * the Initial Developer. All Rights Reserved. * * Contributor(s): * * Anthony Minessale II * Michael Jerris * Johny Kadarisman * Paul Tinsley * Marcel Barbulescu * Bret McDanel * Cesar Cepeda * Massimo Cetra * Rupa Schomaker * Joseph Sullivan * * * mod_commands.c -- Misc. Command Module * */ #include #include #include SWITCH_MODULE_LOAD_FUNCTION(mod_commands_load); SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_commands_shutdown); SWITCH_MODULE_DEFINITION(mod_commands, mod_commands_load, mod_commands_shutdown, NULL); static switch_mutex_t *reload_mutex = NULL; struct cb_helper { uint32_t row_process; switch_stream_handle_t *stream; }; static int url_callback(void *pArg, int argc, char **argv, char **columnNames) { struct cb_helper *cb = (struct cb_helper *) pArg; cb->row_process++; if (!zstr(argv[0])) { cb->stream->write_function(cb->stream, "%s,", argv[0]); } return 0; } static switch_status_t select_url(const char *user, const char *domain, const char *concat, const char *exclude_contact, switch_stream_handle_t *stream) { struct cb_helper cb; char *sql, *errmsg = NULL; switch_core_flag_t cflags = switch_core_flags(); switch_cache_db_handle_t *db = NULL; if (!(cflags & SCF_USE_SQL)) { stream->write_function(stream, "-ERR SQL DISABLED NO DATA AVAILABLE!\n"); return SWITCH_STATUS_SUCCESS; } if (switch_core_db_handle(&db) != SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "%s", "-ERR Databse Error!\n"); return SWITCH_STATUS_SUCCESS; } cb.row_process = 0; cb.stream = stream; if (exclude_contact) { sql = switch_mprintf("select url, '%q' " "from registrations where reg_user='%q' and realm='%q' " "and url not like '%%%s%%'", (concat != NULL) ? concat : "", user, domain, exclude_contact); } else { sql = switch_mprintf("select url, '%q' " "from registrations where reg_user='%q' and realm='%q'", (concat != NULL) ? concat : "", user, domain); } switch_assert(sql); switch_cache_db_execute_sql_callback(db, sql, url_callback, &cb, &errmsg); if (errmsg) { stream->write_function(stream, "-ERR SQL Error [%s]\n", errmsg); free(errmsg); errmsg = NULL; } switch_safe_free(sql); if (db) { switch_cache_db_release_db_handle(&db); } return SWITCH_STATUS_SUCCESS; } #define SAY_STRING_SYNTAX "[.] [.] [] " SWITCH_STANDARD_API(say_string_function) { char *argv[6] = { 0 }; int argc; char *lbuf = NULL, *string = NULL; int err = 1, par = 0; char *p, *ext = "wav"; char *tosay = NULL; int strip = 0; if (cmd) { lbuf = strdup(cmd); } if (lbuf && (argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) && (argc == 5 || argc == 6)) { if ((p = strchr(argv[0], '.'))) { *p++ = '\0'; ext = p; par++; } if (!par && (p = strchr(argv[1], '.'))) { *p++ = '\0'; ext = p; } tosay = (argc == 5) ? argv[4] : argv[5]; if (*tosay == '~') { tosay++; strip++; } switch_ivr_say_string(session, argv[1], ext, tosay, argv[0], argv[2], argv[3], (argc == 6) ? argv[4] : NULL , &string); if (string) { stream->write_function(stream, "%s", strip ? string + 14 : string); free(string); err = 0; } } if (err) { stream->write_function(stream, "-ERR Usage: %s\n", SAY_STRING_SYNTAX); } free(lbuf); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(reg_url_function) { char *data; char *user = NULL; char *domain = NULL, *dup_domain = NULL; char *concat = NULL; const char *exclude_contact = NULL; char *reply = "error/facility_not_subscribed"; switch_stream_handle_t mystream = { 0 }; if (!cmd) { stream->write_function(stream, "%s", ""); return SWITCH_STATUS_SUCCESS; } if (session) { switch_channel_t *channel = switch_core_session_get_channel(session); exclude_contact = switch_channel_get_variable(channel, "sip_exclude_contact"); } data = strdup(cmd); switch_assert(data); user = data; if ((domain = strchr(user, '@'))) { *domain++ = '\0'; if ((concat = strchr(domain, '/'))) { *concat++ = '\0'; } } else { if ((concat = strchr(user, '/'))) { *concat++ = '\0'; } } if (zstr(domain)) { dup_domain = switch_core_get_variable_dup("domain"); domain = dup_domain; } if (!user) goto end; SWITCH_STANDARD_STREAM(mystream); switch_assert(mystream.data); select_url(user, domain, concat, exclude_contact, &mystream); reply = mystream.data; end: if (zstr(reply)) { reply = "error/user_not_registered"; } else if (end_of(reply) == ',') { end_of(reply) = '\0'; } stream->write_function(stream, "%s", reply); reply = NULL; switch_safe_free(mystream.data); switch_safe_free(data); switch_safe_free(dup_domain); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(banner_function) { stream->write_function(stream, "%s", switch_core_banner()); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(hostname_api_function) { stream->write_function(stream, "%s", switch_core_get_hostname()); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(switchname_api_function) { stream->write_function(stream, "%s", switch_core_get_switchname()); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(shutdown_function) { switch_session_ctl_t command = SCSC_SHUTDOWN; int arg = 0; stream->write_function(stream, "+OK\n"); switch_core_session_ctl(command, &arg); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(version_function) { stream->write_function(stream, "FreeSWITCH Version %s (%s)\n", SWITCH_VERSION_FULL, SWITCH_VERSION_FULL_HUMAN); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(db_cache_function) { int argc; char *mydata = NULL, *argv[2]; if (zstr(cmd)) { goto error; } mydata = strdup(cmd); switch_assert(mydata); argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 1) { goto error; } if (argv[0] && switch_stristr("status", argv[0])) { switch_cache_db_status(stream); goto ok; } else { goto error; } error: stream->write_function(stream, "%s", "parameter missing\n"); ok: switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(host_lookup_function) { char host[256] = ""; if (zstr(cmd)) { stream->write_function(stream, "%s", "parameter missing\n"); } else { if (switch_resolve_host(cmd, host, sizeof(host)) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "%s", host); } else { stream->write_function(stream, "%s", "!err!"); } } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(nat_map_function) { int argc; char *mydata = NULL, *argv[5]; switch_nat_ip_proto_t proto = SWITCH_NAT_UDP; switch_port_t external_port = 0; char *tmp = NULL; switch_bool_t sticky = SWITCH_FALSE; switch_bool_t mapping = SWITCH_TRUE; if (!cmd) { goto usage; } if (!switch_nat_is_initialized()) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "nat_map API called while NAT not initialized\n"); goto error; } mydata = strdup(cmd); switch_assert(mydata); argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 1) { goto usage; } if (argv[0] && switch_stristr("status", argv[0])) { tmp = switch_nat_status(); stream->write_function(stream, tmp); switch_safe_free(tmp); goto ok; } else if (argv[0] && switch_stristr("republish", argv[0])) { switch_nat_republish(); stream->write_function(stream, "true"); goto ok; } else if (argv[0] && switch_stristr("reinit", argv[0])) { switch_nat_reinit(); tmp = switch_nat_status(); stream->write_function(stream, tmp); switch_safe_free(tmp); goto ok; } if (argc < 2) { goto usage; } if (argv[0] && switch_stristr("mapping", argv[0])) { if (argv[1] && switch_stristr("enable", argv[1])) { mapping = SWITCH_TRUE; } else if (argv[1] && switch_stristr("disable", argv[1])) { mapping = SWITCH_FALSE; } switch_nat_set_mapping(mapping); tmp = switch_nat_status(); stream->write_function(stream, tmp); switch_safe_free(tmp); goto ok; } if (argc < 3) { goto error; } if (argv[2] && switch_stristr("tcp", argv[2])) { proto = SWITCH_NAT_TCP; } else if (argv[2] && switch_stristr("udp", argv[2])) { proto = SWITCH_NAT_UDP; } if (argv[3] && switch_stristr("sticky", argv[3])) { sticky = SWITCH_TRUE; } if (argv[0] && switch_stristr("add", argv[0])) { if (switch_nat_add_mapping((switch_port_t) atoi(argv[1]), proto, &external_port, sticky) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "true"); /* still return true */ goto ok; } } else if (argv[0] && switch_stristr("del", argv[0])) { if (switch_nat_del_mapping((switch_port_t) atoi(argv[1]), proto) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "true"); goto ok; } } error: stream->write_function(stream, "false"); goto ok; usage: stream->write_function(stream, "USAGE: nat_map [status|reinit|republish] | [add|del] [tcp|udp] [sticky] | [mapping] "); ok: switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(time_test_function) { switch_time_t now, then; int x; long mss; uint32_t total = 0; int diff; int max = 10, a = 0; char *p; if (zstr(cmd)) { stream->write_function(stream, "parameter missing\n"); return SWITCH_STATUS_SUCCESS; } mss = atol(cmd); if (mss > 1000000) { mss = 1000000; } if ((p = strchr(cmd, ' '))) { if ((a = atoi(p + 1)) > 0) { max = a; if (max > 100) { max = 100; } } } for (x = 1; x <= max; x++) { then = switch_time_ref(); switch_yield(mss); now = switch_time_ref(); diff = (int) (now - then); stream->write_function(stream, "test %d sleep %ld %d\n", x, mss, diff); total += diff; } stream->write_function(stream, "avg %d\n", total / (x > 1 ? x - 1 : 1)); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(msleep_function) { if (cmd) { long ms = atol(cmd); switch_yield(ms * 1000); } stream->write_function(stream, "+OK"); return SWITCH_STATUS_SUCCESS; } #define TIMER_TEST_SYNTAX "<10|20|40|60|120> [<1..200>] []" SWITCH_STANDARD_API(timer_test_function) { switch_time_t now, then, start, end; int x; int mss = 20; uint32_t total = 0; int diff; int max = 50; switch_timer_t timer = { 0 }; int argc = 0; char *argv[5] = { 0 }; const char *timer_name = "soft"; switch_memory_pool_t *pool; char *mycmd = NULL; switch_core_new_memory_pool(&pool); if (zstr(cmd)) { mycmd = ""; } else { mycmd = switch_core_strdup(pool, cmd); } argc = switch_split(mycmd, ' ', argv); if (argc > 0) { mss = atoi(argv[0]); } if (argc > 1) { int tmp = atoi(argv[1]); if (tmp > 0 && tmp <= 400) { max = tmp; } } if (argc > 2) { timer_name = argv[2]; } if (mss != 10 && mss != 20 && mss != 30 && mss != 32 && mss != 40 && mss != 60 && mss != 120) { stream->write_function(stream, "parameter missing: %s\n", TIMER_TEST_SYNTAX); goto end; } if (switch_core_timer_init(&timer, timer_name, mss, 1, pool) != SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "Timer Error!\n"); goto end; } switch_core_timer_next(&timer); /* Step timer once before testing results below, to get first timestamp as accurate as possible */ start = then = switch_time_ref(); for (x = 1; x <= max; x++) { switch_core_timer_next(&timer); now = switch_time_ref(); diff = (int) (now - then); total += diff; then = now; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Timer Test: %d sleep %d %d\n", x, mss, diff); } end = then; switch_yield(250000); stream->write_function(stream, "Avg: %0.3fms Total Time: %0.3fms\n", (float) ((float) (total / (x > 1 ? x - 1 : 1)) / 1000), (float) ((float) (end - start) / 1000)); end: switch_core_destroy_memory_pool(&pool); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(group_call_function) { char *domain, *dup_domain = NULL; char *group_name = NULL; char *flags; int ok = 0; switch_channel_t *channel = NULL; char *fp = NULL; const char *call_delim = ","; if (zstr(cmd)) { goto end; } if (session) { channel = switch_core_session_get_channel(session); } group_name = strdup(cmd); switch_assert(group_name); if ((flags = strchr(group_name, '+'))) { *flags++ = '\0'; for (fp = flags; fp && *fp; fp++) { switch (*fp) { case 'F': call_delim = "|"; break; case 'A': call_delim = ","; break; case 'E': call_delim = SWITCH_ENT_ORIGINATE_DELIM; break; default: break; } } } domain = strchr(group_name, '@'); if (domain) { *domain++ = '\0'; } else { if ((dup_domain = switch_core_get_variable_dup("domain"))) { domain = dup_domain; } } if (!zstr(domain)) { switch_xml_t xml, x_domain, x_group; switch_event_t *params; switch_stream_handle_t dstream = { 0 }; SWITCH_STANDARD_STREAM(dstream); switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "group", group_name); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "action", "group_call"); if (switch_xml_locate_group(group_name, domain, &xml, &x_domain, &x_group, params) == SWITCH_STATUS_SUCCESS) { switch_xml_t x_user, x_users, x_param, x_params, my_x_user; if ((x_users = switch_xml_child(x_group, "users"))) { ok++; for (x_user = switch_xml_child(x_users, "user"); x_user; x_user = x_user->next) { const char *id = switch_xml_attr_soft(x_user, "id"); const char *x_user_type = switch_xml_attr_soft(x_user, "type"); const char *dest = NULL; char *d_dest = NULL; switch_xml_t xml_for_pointer = NULL, x_domain_for_pointer = NULL, x_group_for_pointer = NULL, x_user_for_pointer = NULL; my_x_user = x_user; if (!strcmp(x_user_type, "pointer")) { if (switch_xml_locate_user("id", id, domain, NULL, &xml_for_pointer, &x_domain_for_pointer, &x_user_for_pointer, &x_group_for_pointer, params) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Can't find user [%s@%s]\n", id, domain); goto done_x_user; } my_x_user = x_user_for_pointer; } if ((x_params = switch_xml_child(x_domain, "params"))) { for (x_param = switch_xml_child(x_params, "param"); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (!strcasecmp(var, "group-dial-string")) { dest = val; break; } if (!strcasecmp(var, "dial-string")) { dest = val; } } } if ((x_params = switch_xml_child(x_group, "params"))) { for (x_param = switch_xml_child(x_params, "param"); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (!strcasecmp(var, "group-dial-string")) { dest = val; break; } if (!strcasecmp(var, "dial-string")) { dest = val; } } } if ((x_params = switch_xml_child(my_x_user, "params"))) { for (x_param = switch_xml_child(x_params, "param"); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (!strcasecmp(var, "group-dial-string")) { dest = val; break; } if (!strcasecmp(var, "dial-string")) { dest = val; } } } if (dest) { if (channel) { switch_channel_set_variable(channel, "dialed_group", group_name); switch_channel_set_variable(channel, "dialed_user", id); switch_channel_set_variable(channel, "dialed_domain", domain); d_dest = switch_channel_expand_variables(channel, dest); } else { switch_event_del_header(params, "dialed_user"); switch_event_del_header(params, "dialed_group"); switch_event_del_header(params, "dialed_domain"); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "dialed_user", id); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "dialed_group", group_name); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "dialed_domain", domain); d_dest = switch_event_expand_headers(params, dest); } } else { d_dest = switch_mprintf("user/%s@%s", id, domain); } if (d_dest) { dstream.write_function(&dstream, "%s%s", d_dest, call_delim); if (d_dest != dest) { free(d_dest); } } done_x_user: if (xml_for_pointer) { switch_xml_free(xml_for_pointer); xml_for_pointer = NULL; } } if (ok && dstream.data) { char *data = (char *) dstream.data; char *p; if ((p = strstr(end_of_p(data) - 3, call_delim))) { *p = '\0'; } for (p = data; p && *p; p++) { if (*p == '{') { *p = '['; } else if (*p == '}') { *p = ']'; } } stream->write_function(stream, "%s", data); free(dstream.data); } else { ok = 0; } } } switch_xml_free(xml); switch_event_destroy(¶ms); } end: switch_safe_free(group_name); switch_safe_free(dup_domain); if (!ok) { stream->write_function(stream, "error/NO_ROUTE_DESTINATION"); } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(in_group_function) { switch_xml_t x_domain, xml = NULL, x_user = NULL, x_group; int argc; char *mydata = NULL, *argv[2], *user, *domain, *dup_domain = NULL; char delim = ','; switch_event_t *params = NULL; const char *rval = "false"; char *group; if (zstr(cmd) || !(mydata = strdup(cmd))) { goto end; } if ((argc = switch_separate_string(mydata, delim, argv, (sizeof(argv) / sizeof(argv[0])))) < 2) { goto end; } user = argv[0]; group = argv[1]; if ((domain = strchr(user, '@'))) { *domain++ = '\0'; } else { if ((dup_domain = switch_core_get_variable_dup("domain"))) { domain = dup_domain; } } switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "user", user); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain); if (switch_xml_locate_group(group, domain, &xml, &x_domain, &x_group, params) == SWITCH_STATUS_SUCCESS) { switch_xml_t x_users; if ((x_users = switch_xml_child(x_group, "users"))) { if ((x_user = switch_xml_find_child(x_users, "user", "id", user))) { rval = "true"; } } } end: stream->write_function(stream, "%s", rval); switch_xml_free(xml); switch_safe_free(mydata); switch_safe_free(dup_domain); switch_event_destroy(¶ms); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(user_data_function) { switch_xml_t x_domain, xml = NULL, x_user = NULL, x_group = NULL, x_param, x_params; int argc; char *mydata = NULL, *argv[3], *key = NULL, *type = NULL, *user, *domain, *dup_domain = NULL; char delim = ' '; const char *container = "params", *elem = "param"; const char *result = NULL; switch_event_t *params = NULL; if (zstr(cmd) || !(mydata = strdup(cmd))) { goto end; } if ((argc = switch_separate_string(mydata, delim, argv, (sizeof(argv) / sizeof(argv[0])))) < 3) { goto end; } user = argv[0]; type = argv[1]; key = argv[2]; if ((domain = strchr(user, '@'))) { *domain++ = '\0'; } else { if ((dup_domain = switch_core_get_variable_dup("domain"))) { domain = dup_domain; } else { domain = "cluecon.com"; } } switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "user", user); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "type", type); if (key && type && switch_xml_locate_user("id", user, domain, NULL, &xml, &x_domain, &x_user, &x_group, params) == SWITCH_STATUS_SUCCESS) { if (!strcmp(type, "attr")) { const char *attr = switch_xml_attr_soft(x_user, key); result = attr; goto end; } if (!strcmp(type, "var")) { container = "variables"; elem = "variable"; } if ((x_params = switch_xml_child(x_domain, container))) { for (x_param = switch_xml_child(x_params, elem); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (var && val && !strcasecmp(var, key)) { result = val; } } } if (x_group && (x_params = switch_xml_child(x_group, container))) { for (x_param = switch_xml_child(x_params, elem); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (var && val && !strcasecmp(var, key)) { result = val; } } } if ((x_params = switch_xml_child(x_user, container))) { for (x_param = switch_xml_child(x_params, elem); x_param; x_param = x_param->next) { const char *var = switch_xml_attr(x_param, "name"); const char *val = switch_xml_attr(x_param, "value"); if (var && val && !strcasecmp(var, key)) { result = val; } } } } end: if (result) { stream->write_function(stream, "%s", result); } switch_xml_free(xml); switch_safe_free(mydata); switch_safe_free(dup_domain); switch_event_destroy(¶ms); return SWITCH_STATUS_SUCCESS; } static switch_status_t _find_user(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream, switch_bool_t tf) { switch_xml_t x_domain = NULL, x_user = NULL, xml = NULL; int argc; char *mydata = NULL, *argv[3]; char *key, *user, *domain; char *xmlstr; char *path_info = NULL; char delim = ' '; char *host = NULL; const char *err = NULL; if (stream->param_event && (host = switch_event_get_header(stream->param_event, "http-host"))) { stream->write_function(stream, "Content-Type: text/xml\r\n\r\n"); if ((path_info = switch_event_get_header(stream->param_event, "http-path-info"))) { cmd = path_info; delim = '/'; } } if (!cmd) { err = "bad args"; goto end; } mydata = strdup(cmd); switch_assert(mydata); argc = switch_separate_string(mydata, delim, argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 3) { err = "bad args"; goto end; } key = argv[0]; user = argv[1]; domain = argv[2]; if (!(key && user && domain)) { err = "bad args"; goto end; } if (switch_xml_locate_user(key, user, domain, NULL, &xml, &x_domain, &x_user, NULL, NULL) != SWITCH_STATUS_SUCCESS) { err = "can't find user"; goto end; } end: if (session || tf) { stream->write_function(stream, err ? "false" : "true"); } else { if (err) { if (host) { stream->write_function(stream, "%s\n", err); } else { stream->write_function(stream, "-Error %s\n", err); } } if (x_user) { xmlstr = switch_xml_toxml(x_user, SWITCH_FALSE); switch_assert(xmlstr); stream->write_function(stream, "%s", xmlstr); free(xmlstr); } } switch_xml_free(xml); switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(md5_function) { char digest[SWITCH_MD5_DIGEST_STRING_SIZE] = { 0 }; if (zstr(cmd)) { stream->write_function(stream, "%s", "!err!"); } else { switch_md5_string(digest, (void *) cmd, strlen(cmd)); stream->write_function(stream, "%s", digest); } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(url_decode_function) { char *reply = ""; char *data = NULL; if (!zstr(cmd)) { data = strdup(cmd); switch_url_decode(data); reply = data; } stream->write_function(stream, "%s", reply); switch_safe_free(data); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(echo_function) { stream->write_function(stream, "%s", cmd); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(stun_function) { char *stun_ip = NULL; switch_port_t stun_port = (switch_port_t) SWITCH_STUN_DEFAULT_PORT; char *p; char ip_buf[256] = ""; char *ip = NULL; char *pip = NULL; switch_port_t port = 0; switch_memory_pool_t *pool = NULL; char *error = ""; ip = ip_buf; if (zstr(cmd)) { stream->write_function(stream, "%s", "-STUN Failed! NO STUN SERVER\n"); return SWITCH_STATUS_SUCCESS; } stun_ip = strdup(cmd); switch_assert(stun_ip); if ((p = strchr(stun_ip, ':'))) { int iport; *p++ = '\0'; iport = atoi(p); if (iport > 0 && iport < 0xFFFF) { stun_port = (switch_port_t) iport; } } else { p = stun_ip; } if (p && (pip = strchr(p, ' '))) { *pip++ = '\0'; } if (pip) { switch_copy_string(ip_buf, pip, sizeof(ip_buf)); } else { switch_find_local_ip(ip_buf, sizeof(ip_buf), NULL, AF_INET); } switch_core_new_memory_pool(&pool); if (zstr(stun_ip)) { stream->write_function(stream, "%s", "-STUN Failed! NO STUN SERVER\n"); } else { if ((switch_stun_lookup(&ip, &port, stun_ip, stun_port, &error, pool)) == SWITCH_STATUS_SUCCESS && ip && port) { stream->write_function(stream, "%s:%u\n", ip, port); } else { stream->write_function(stream, "-STUN Failed! [%s]\n", error); } } switch_core_destroy_memory_pool(&pool); free(stun_ip); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(expand_function) { char *expanded; char *dup; char *arg; char *mycmd; switch_status_t status; const char *p; switch_core_session_t *xsession; char uuid[80] = ""; if (zstr(cmd)) { stream->write_function(stream, "-ERR, no input\n"); return SWITCH_STATUS_SUCCESS; } dup = strdup(cmd); mycmd = dup; if (!strncasecmp(mycmd, "uuid:", 5)) { p = cmd + 5; if ((mycmd = strchr(p, ' ')) && *mycmd++) { switch_copy_string(uuid, p, mycmd - p); } } if (zstr(mycmd)) { stream->write_function(stream, "-ERR, no input\n"); return SWITCH_STATUS_SUCCESS; } if (*uuid) { if ((xsession = switch_core_session_locate(uuid))) { switch_channel_event_set_data(switch_core_session_get_channel(xsession), stream->param_event); switch_core_session_rwunlock(xsession); } } if ((arg = strchr(mycmd, ' '))) { *arg++ = '\0'; } expanded = arg ? switch_event_expand_headers(stream->param_event, arg) : arg; if ((status = switch_api_execute(mycmd, expanded, session, stream)) != SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "-ERR, error executing command\n"); } if (expanded != arg) { free(expanded); expanded = NULL; } free(dup); dup = NULL; return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(console_complete_function) { const char *p, *cursor = NULL; int c; if (zstr(cmd)) { cmd = " "; } if ((p = strstr(cmd, "c="))) { p += 2; c = atoi(p); if ((p = strchr(p, ';'))) { cmd = p + 1; cursor = cmd + c; } } switch_console_complete(cmd, cursor, NULL, stream, NULL); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(console_complete_xml_function) { const char *p, *cursor = NULL; int c; switch_xml_t xml = switch_xml_new("complete"); char *sxml; if (zstr(cmd)) { cmd = " "; } if ((p = strstr(cmd, "c="))) { p += 2; c = atoi(p); if ((p = strchr(p, ';'))) { cmd = p + 1; cursor = cmd + c; } } switch_console_complete(cmd, cursor, NULL, NULL, xml); sxml = switch_xml_toxml(xml, SWITCH_TRUE); stream->write_function(stream, "%s", sxml); free(sxml); switch_xml_free(xml); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(eval_function) { char *expanded; switch_event_t *event; char uuid[80] = ""; const char *p, *input = cmd; if (zstr(cmd)) { stream->write_function(stream, "%s", ""); return SWITCH_STATUS_SUCCESS; } if (!strncasecmp(cmd, "uuid:", 5)) { p = cmd + 5; if ((input = strchr(p, ' ')) && *input++) { switch_copy_string(uuid, p, input - p); } } if (zstr(input)) { stream->write_function(stream, "%s", ""); return SWITCH_STATUS_SUCCESS; } switch_event_create(&event, SWITCH_EVENT_CHANNEL_DATA); if (*uuid) { if ((session = switch_core_session_locate(uuid))) { switch_channel_event_set_data(switch_core_session_get_channel(session), event); switch_core_session_rwunlock(session); } } expanded = switch_event_expand_headers(event, input); stream->write_function(stream, "%s", expanded); if (expanded != input) { free(expanded); } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(module_exists_function) { if (!zstr(cmd)) { if (switch_loadable_module_exists(cmd) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "true"); } else { stream->write_function(stream, "false"); } } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(domain_exists_function) { switch_xml_t root = NULL, domain = NULL; if (!zstr(cmd)) { if (switch_xml_locate_domain(cmd, NULL, &root, &domain) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "true"); switch_xml_free(root); } else { stream->write_function(stream, "false"); } } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(url_encode_function) { char *reply = ""; char *data = NULL; int len = 0; if (!zstr(cmd)) { len = (int)(strlen(cmd) * 3) + 1; switch_zmalloc(data, len); switch_url_encode(cmd, data, len); reply = data; } stream->write_function(stream, "%s", reply); switch_safe_free(data); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(user_exists_function) { return _find_user(cmd, session, stream, SWITCH_TRUE); } SWITCH_STANDARD_API(find_user_function) { return _find_user(cmd, session, stream, SWITCH_FALSE); } SWITCH_STANDARD_API(xml_locate_function) { switch_xml_t xml = NULL, obj = NULL; int argc; char *mydata = NULL, *argv[4]; char *section, *tag, *tag_attr_name, *tag_attr_val; switch_event_t *params = NULL; char *xmlstr; char *path_info, delim = ' '; char *host = NULL; const char *err = NULL; if (stream->param_event && (host = switch_event_get_header(stream->param_event, "http-host"))) { stream->write_function(stream, "Content-Type: text/xml\r\n\r\n"); if ((path_info = switch_event_get_header(stream->param_event, "http-path-info"))) { cmd = path_info; delim = '/'; } } if (!cmd) { err = "bad args"; goto end; } mydata = strdup(cmd); switch_assert(mydata); argc = switch_separate_string(mydata, delim, argv, (sizeof(argv) / sizeof(argv[0]))); if (argc == 1 && !strcasecmp(argv[0], "root")) { const char *error; xml = switch_xml_open_root(0, &error); obj = xml; goto end; } if (argc != 1 && argc != 4) { err = "bad args"; goto end; } section = argv[0]; tag = argv[1]; tag_attr_name = argv[2]; tag_attr_val = argv[3]; switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS); switch_assert(params); switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "section", section); if (tag) { switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "tag", tag); } if (tag_attr_name) { switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "tag_attr_name", tag_attr_name); } if (tag_attr_val) { switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "tag_attr_val", tag_attr_val); } if (switch_xml_locate(section, tag, tag_attr_name, tag_attr_val, &xml, &obj, params, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "can't find anything\n"); goto end; } end: if (err) { if (host) { stream->write_function(stream, "%s\n", err); } else { stream->write_function(stream, "-Error %s\n", err); } } if (obj) { xmlstr = switch_xml_toxml(obj, SWITCH_FALSE); switch_assert(xmlstr); stream->write_function(stream, "%s", xmlstr); free(xmlstr); } switch_xml_free(xml); switch_event_destroy(¶ms); free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(reload_acl_function) { const char *err; if (cmd && !strcasecmp(cmd, "reloadxml")) { stream->write_function(stream, "This option is deprecated, we now always reloadxml.\n"); } if (switch_xml_reload(&err) == SWITCH_STATUS_SUCCESS) { switch_load_network_lists(SWITCH_TRUE); stream->write_function(stream, "+OK acl reloaded\n"); } else { stream->write_function(stream, "-Error [%s]\n", err); } return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(acl_function) { int argc; char *mydata = NULL, *argv[3]; if (!cmd) { goto error; } mydata = strdup(cmd); switch_assert(mydata); argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 2) { goto error; } if (switch_check_network_list_ip(argv[0], argv[1])) { stream->write_function(stream, "true"); goto ok; } error: stream->write_function(stream, "false"); ok: switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(replace_function) { char delim = '|'; char *mydata = NULL, *argv[3], *d, *replace; int argc = 0; if (!cmd) { goto error; } mydata = strdup(cmd); d = mydata; if (*d == 'm' && *(d + 1) == ':' && *(d + 2)) { char t = *(d + 2); switch (t) { case '|': case '~': case '/': d += 3; delim = t; break; default: break; } } argc = switch_separate_string(d, delim, argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 3) { goto error; } replace = switch_string_replace(argv[0], argv[1], argv[2]); stream->write_function(stream, "%s", replace); free(replace); goto ok; error: stream->write_function(stream, "-ERR"); ok: switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(regex_function) { switch_regex_t *re = NULL; int ovector[30]; int argc; char *mydata = NULL, *argv[3]; size_t len = 0; char *substituted = NULL; int proceed = 0; char *d; char delim = '|'; if (!cmd) { goto error; } mydata = strdup(cmd); switch_assert(mydata); d = mydata; if (*d == 'm' && *(d + 1) == ':' && *(d + 2)) { char t = *(d + 2); switch (t) { case '|': case '~': case '/': d += 3; delim = t; break; default: break; } } argc = switch_separate_string(d, delim, argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 2) { goto error; } proceed = switch_regex_perform(argv[0], argv[1], &re, ovector, sizeof(ovector) / sizeof(ovector[0])); if (argc > 2) { len = (strlen(argv[0]) + strlen(argv[2]) + 10) * proceed; substituted = malloc(len); switch_assert(substituted); memset(substituted, 0, len); switch_replace_char(argv[2], '%', '$', SWITCH_FALSE); switch_perform_substitution(re, proceed, argv[2], argv[0], substituted, len, ovector); stream->write_function(stream, "%s", substituted); free(substituted); } else { stream->write_function(stream, proceed ? "true" : "false"); } goto ok; error: stream->write_function(stream, "-ERR"); ok: switch_regex_safe_free(re); switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } typedef enum { O_NONE, O_EQ, O_NE, O_GT, O_GE, O_LT, O_LE } o_t; SWITCH_STANDARD_API(cond_function) { int argc; char *mydata = NULL, *argv[3]; char *expr; char *a, *b; double a_f = 0.0, b_f = 0.0; o_t o = O_NONE; int is_true = 0; char *p; if (!cmd) { goto error; } mydata = strdup(cmd); switch_assert(mydata); if ((p = strchr(mydata, '?'))) { *p = ':'; } else { goto error; } argc = switch_separate_string(mydata, ':', argv, (sizeof(argv) / sizeof(argv[0]))); if (! (argc >= 2 && argc <= 3)) { goto error; } a = argv[0]; if ((expr = strchr(a, '!'))) { *expr++ = '\0'; if (*expr == '=') { o = O_NE; } } else if ((expr = strchr(a, '>'))) { if (*(expr + 1) == '=') { *expr++ = '\0'; o = O_GE; } else { o = O_GT; } } else if ((expr = strchr(a, '<'))) { if (*(expr + 1) == '=') { *expr++ = '\0'; o = O_LE; } else { o = O_LT; } } else if ((expr = strchr(a, '='))) { *expr++ = '\0'; if (*expr == '=') { o = O_EQ; } } if (o) { char *s_a = NULL, *s_b = NULL; int a_is_num, b_is_num; *expr++ = '\0'; b = expr; s_a = switch_strip_spaces(a, SWITCH_TRUE); s_b = switch_strip_spaces(b, SWITCH_TRUE); a_is_num = switch_is_number(s_a); b_is_num = switch_is_number(s_b); a_f = a_is_num ? atof(s_a) : (float) strlen(s_a); b_f = b_is_num ? atof(s_b) : (float) strlen(s_b); switch (o) { case O_EQ: if (!a_is_num && !b_is_num) { is_true = !strcmp(s_a, s_b); } else { is_true = a_f == b_f; } break; case O_NE: if (!a_is_num && !b_is_num) { is_true = strcmp(s_a, s_b); } else { is_true = a_f != b_f; } break; case O_GT: is_true = a_f > b_f; break; case O_GE: is_true = a_f >= b_f; break; case O_LT: is_true = a_f < b_f; break; case O_LE: is_true = a_f <= b_f; break; default: break; } switch_safe_free(s_a); switch_safe_free(s_b); if ((argc == 2 && !is_true)) { stream->write_function(stream, ""); } else { stream->write_function(stream, "%s", is_true ? argv[1] : argv[2]); } goto ok; } error: stream->write_function(stream, "-ERR"); ok: switch_safe_free(mydata); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(lan_addr_function) { stream->write_function(stream, "%s", switch_is_lan_addr(cmd) ? "true" : "false"); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(status_function) { uint8_t html = 0; switch_core_time_duration_t duration = { 0 }; char *http = NULL; int sps = 0, last_sps = 0; const char *var; switch_size_t cur = 0, max = 0; switch_core_measure_time(switch_core_uptime(), &duration); if (stream->param_event) { http = switch_event_get_header(stream->param_event, "http-host"); if ((var = switch_event_get_header(stream->param_event, "content-type"))) { if (!strcasecmp(var, "text/plain")) { http = NULL; } } } if (http) { stream->write_function(stream, "%s", "Content-Type: text/html\n\n"); } if (http || (cmd && strstr(cmd, "html"))) { html = 1; stream->write_function(stream, "

FreeSWITCH Status

\n"); } stream->write_function(stream, "UP %u year%s, %u day%s, %u hour%s, %u minute%s, %u second%s, %u millisecond%s, %u microsecond%s\n", duration.yr, duration.yr == 1 ? "" : "s", duration.day, duration.day == 1 ? "" : "s", duration.hr, duration.hr == 1 ? "" : "s", duration.min, duration.min == 1 ? "" : "s", duration.sec, duration.sec == 1 ? "" : "s", duration.ms, duration.ms == 1 ? "" : "s", duration.mms, duration.mms == 1 ? "" : "s"); stream->write_function(stream, "FreeSWITCH is %s\n", switch_core_ready() ? "ready" : "not ready"); stream->write_function(stream, "%" SWITCH_SIZE_T_FMT " session(s) since startup\n", switch_core_session_id() - 1); switch_core_session_ctl(SCSC_LAST_SPS, &last_sps); switch_core_session_ctl(SCSC_SPS, &sps); stream->write_function(stream, "%d session(s) %d/%d\n", switch_core_session_count(), last_sps, sps); stream->write_function(stream, "%d session(s) max\n", switch_core_session_limit(0)); stream->write_function(stream, "min idle cpu %0.2f/%0.2f\n", switch_core_min_idle_cpu(-1.0), switch_core_idle_cpu()); if (switch_core_get_stacksizes(&cur, &max) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "Current Stack Size/Max %ldK/%ldK\n", cur / 1024, max / 1024); } if (html) { stream->write_function(stream, "\n"); } if (cmd && strstr(cmd, "refresh=")) { char *refresh = strchr(cmd, '='); if (refresh) { int r; refresh++; r = atoi(refresh); if (r > 0) { stream->write_function(stream, "\n", r, r, html ? "html=1" : ""); } } } return SWITCH_STATUS_SUCCESS; } #define CTL_SYNTAX "[recover|send_sighup|hupall|pause [inbound|outbound]|resume [inbound|outbound]|shutdown [cancel|elegant|asap|now|restart]|sps|sync_clock|sync_clock_when_idle|reclaim_mem|max_sessions|min_dtmf_duration [num]|max_dtmf_duration [num]|default_dtmf_duration [num]|min_idle_cpu|loglevel [level]|debug_level [level]]" SWITCH_STANDARD_API(ctl_function) { int argc; char *mydata, *argv[5]; int32_t arg = 0; if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", CTL_SYNTAX); return SWITCH_STATUS_SUCCESS; } if ((mydata = strdup(cmd))) { argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (!strcasecmp(argv[0], "hupall")) { arg = 1; switch_core_session_ctl(SCSC_HUPALL, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "recover")) { int r = switch_core_session_ctl(SCSC_RECOVER, argv[1]); if (r < 0){ stream->write_function(stream, "+OK flushed\n"); } else { stream->write_function(stream, "+OK %d session(s) recovered in total\n", r); } } else if (!strcasecmp(argv[0], "flush_db_handles")) { switch_core_session_ctl(SCSC_FLUSH_DB_HANDLES, NULL); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "pause")) { switch_session_ctl_t command = SCSC_PAUSE_ALL; arg = 1; if (argv[1]) { if (!strcasecmp(argv[1], "inbound")) { command = SCSC_PAUSE_INBOUND; } else if (!strcasecmp(argv[1], "outbound")) { command = SCSC_PAUSE_OUTBOUND; } } switch_core_session_ctl(command, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "send_sighup")) { arg = 1; switch_core_session_ctl(SCSC_SEND_SIGHUP, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "resume")) { switch_session_ctl_t command = SCSC_PAUSE_ALL; arg = 0; if (argv[1]) { if (!strcasecmp(argv[1], "inbound")) { command = SCSC_PAUSE_INBOUND; } else if (!strcasecmp(argv[1], "outbound")) { command = SCSC_PAUSE_OUTBOUND; } } switch_core_session_ctl(command, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "calibrate_clock")) { switch_core_session_ctl(SCSC_CALIBRATE_CLOCK, NULL); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "crash")) { switch_core_session_ctl(SCSC_CRASH, NULL); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "verbose_events")) { arg = -1; if (argv[1]) { arg = switch_true(argv[1]); } switch_core_session_ctl(SCSC_VERBOSE_EVENTS, &arg); stream->write_function(stream, "+OK verbose_events is %s \n", arg ? "on" : "off"); } else if (!strcasecmp(argv[0], "api_expansion")) { arg = -1; if (argv[1]) { arg = switch_true(argv[1]); } switch_core_session_ctl(SCSC_API_EXPANSION, &arg); stream->write_function(stream, "+OK api_expansion is %s \n", arg ? "on" : "off"); } else if (!strcasecmp(argv[0], "threaded_system_exec")) { arg = -1; if (argv[1]) { arg = switch_true(argv[1]); } switch_core_session_ctl(SCSC_THREADED_SYSTEM_EXEC, &arg); stream->write_function(stream, "+OK threaded_system_exec is %s \n", arg ? "true" : "false"); } else if (!strcasecmp(argv[0], "save_history")) { switch_core_session_ctl(SCSC_SAVE_HISTORY, NULL); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "pause_check")) { switch_session_ctl_t command = SCSC_PAUSE_CHECK; if (argv[1]) { if (!strcasecmp(argv[1], "inbound")) { command = SCSC_PAUSE_INBOUND_CHECK; } else if (!strcasecmp(argv[1], "outbound")) { command = SCSC_PAUSE_OUTBOUND_CHECK; } } switch_core_session_ctl(command, &arg); stream->write_function(stream, arg ? "true" : "false"); } else if (!strcasecmp(argv[0], "ready_check")) { switch_core_session_ctl(SCSC_READY_CHECK, &arg); stream->write_function(stream, arg ? "true" : "false"); } else if (!strcasecmp(argv[0], "shutdown_check")) { switch_core_session_ctl(SCSC_SHUTDOWN_CHECK, &arg); stream->write_function(stream, arg ? "true" : "false"); } else if (!strcasecmp(argv[0], "shutdown")) { switch_session_ctl_t command = SCSC_SHUTDOWN; int x = 0; arg = 0; for (x = 1; x < 5; x++) { if (argv[x]) { if (!strcasecmp(argv[x], "cancel")) { arg = 0; command = SCSC_CANCEL_SHUTDOWN; break; } else if (!strcasecmp(argv[x], "elegant")) { command = SCSC_SHUTDOWN_ELEGANT; } else if (!strcasecmp(argv[x], "now")) { command = SCSC_SHUTDOWN_NOW; } else if (!strcasecmp(argv[x], "asap")) { command = SCSC_SHUTDOWN_ASAP; } else if (!strcasecmp(argv[x], "restart")) { arg = 1; } } else { break; } } switch_core_session_ctl(command, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "debug_sql")) { int x = 0; switch_core_session_ctl(SCSC_DEBUG_SQL, &x); stream->write_function(stream, "+OK SQL DEBUG [%s]\n", x ? "on" : "off"); } else if (!strcasecmp(argv[0], "sql")) { if (argv[1]) { int x = 0; if (!strcasecmp(argv[1], "start")) { x = 1; } switch_core_session_ctl(SCSC_SQL, &x); stream->write_function(stream, "+OK\n"); } } else if (!strcasecmp(argv[0], "reclaim_mem")) { switch_core_session_ctl(SCSC_RECLAIM, &arg); stream->write_function(stream, "+OK\n"); } else if (!strcasecmp(argv[0], "max_sessions")) { if (argc > 1) { arg = atoi(argv[1]); } switch_core_session_ctl(SCSC_MAX_SESSIONS, &arg); stream->write_function(stream, "+OK max sessions: %d\n", arg); } else if (!strcasecmp(argv[0], "min_idle_cpu")) { double d = -1; if (argc > 1) { d = atof(argv[1]); } switch_core_session_ctl(SCSC_MIN_IDLE_CPU, &d); if (d) { stream->write_function(stream, "+OK min idle cpu: %0.2f%\n", d); } else { stream->write_function(stream, "+OK min idle cpu: DISABLED\n", d); } } else if (!strcasecmp(argv[0], "max_dtmf_duration")) { if (argc > 1) { arg = atoi(argv[1]); } switch_core_session_ctl(SCSC_MAX_DTMF_DURATION, &arg); stream->write_function(stream, "+OK max dtmf duration: %d\n", arg); } else if (!strcasecmp(argv[0], "min_dtmf_duration")) { if (argc > 1) { arg = atoi(argv[1]); } switch_core_session_ctl(SCSC_MIN_DTMF_DURATION, &arg); stream->write_function(stream, "+OK min dtmf duration: %d\n", arg); } else if (!strcasecmp(argv[0], "default_dtmf_duration")) { if (argc > 1) { arg = atoi(argv[1]); } switch_core_session_ctl(SCSC_DEFAULT_DTMF_DURATION, &arg); stream->write_function(stream, "+OK default dtmf duration: %d\n", arg); } else if (!strcasecmp(argv[0], "loglevel")) { if (argc > 1) { if (*argv[1] > 47 && *argv[1] < 58) { arg = atoi(argv[1]); } else { arg = switch_log_str2level(argv[1]); } } else { arg = -1; } if (arg == SWITCH_LOG_INVALID) { stream->write_function(stream, "-ERR syntax error, log level not set!\n"); } else { switch_core_session_ctl(SCSC_LOGLEVEL, &arg); stream->write_function(stream, "+OK log level: %s [%d]\n", switch_log_level2str(arg), arg); } } else if (!strcasecmp(argv[0], "debug_level")) { if (argc > 1) { arg = atoi(argv[1]); } else { arg = -1; } switch_core_session_ctl(SCSC_DEBUG_LEVEL, &arg); stream->write_function(stream, "+OK DEBUG level: %d\n", arg); } else if (!strcasecmp(argv[0], "last_sps")) { switch_core_session_ctl(SCSC_LAST_SPS, &arg); stream->write_function(stream, "+OK last sessions per second: %d\n", arg); } else if (!strcasecmp(argv[0], "sps")) { if (argc > 1) { arg = atoi(argv[1]); } else { arg = 0; } switch_core_session_ctl(SCSC_SPS, &arg); stream->write_function(stream, "+OK sessions per second: %d\n", arg); } else if (!strcasecmp(argv[0], "sync_clock")) { arg = 0; switch_core_session_ctl(SCSC_SYNC_CLOCK, &arg); stream->write_function(stream, "+OK clock synchronized\n"); } else if (!strcasecmp(argv[0], "sync_clock_when_idle")) { arg = 0; switch_core_session_ctl(SCSC_SYNC_CLOCK_WHEN_IDLE, &arg); if (arg) { stream->write_function(stream, "+OK clock synchronized\n"); } else { stream->write_function(stream, "+OK clock will synchronize when there are no more calls\n"); } } else { stream->write_function(stream, "-ERR INVALID COMMAND\nUSAGE: fsctl %s", CTL_SYNTAX); goto end; } end: free(mydata); } else { stream->write_function(stream, "-ERR Memory Error\n"); } return SWITCH_STATUS_SUCCESS; } #define LOAD_SYNTAX "" SWITCH_STANDARD_API(load_function) { const char *err; if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", LOAD_SYNTAX); return SWITCH_STATUS_SUCCESS; } switch_mutex_lock(reload_mutex); if (switch_xml_reload(&err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK Reloading XML\n"); } if (switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) cmd, SWITCH_TRUE, &err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK\n"); } else { stream->write_function(stream, "-ERR [%s]\n", err); } switch_mutex_unlock(reload_mutex); return SWITCH_STATUS_SUCCESS; } #define UNLOAD_SYNTAX "[-f] " SWITCH_STANDARD_API(unload_function) { const char *err; switch_bool_t force = SWITCH_FALSE; const char *p = cmd; if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", UNLOAD_SYNTAX); return SWITCH_STATUS_SUCCESS; } if (*p == '-') { p++; while (p && *p) { switch (*p) { case ' ': cmd = p + 1; goto end; case 'f': force = SWITCH_TRUE; break; default: break; } p++; } } end: if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", UNLOAD_SYNTAX); return SWITCH_STATUS_SUCCESS; } switch_mutex_lock(reload_mutex); if (switch_loadable_module_unload_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) cmd, force, &err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK\n"); } else { stream->write_function(stream, "-ERR [%s]\n", err); } switch_mutex_unlock(reload_mutex); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(reload_function) { const char *err; switch_bool_t force = SWITCH_FALSE; const char *p = cmd; if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", UNLOAD_SYNTAX); return SWITCH_STATUS_SUCCESS; } if (*p == '-') { p++; while (p && *p) { switch (*p) { case ' ': cmd = p + 1; goto end; case 'f': force = SWITCH_TRUE; break; default: break; } p++; } } end: if (zstr(cmd)) { stream->write_function(stream, "-USAGE: %s\n", UNLOAD_SYNTAX); return SWITCH_STATUS_SUCCESS; } switch_mutex_lock(reload_mutex); if (switch_loadable_module_unload_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) cmd, force, &err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK module unloaded\n"); } else { stream->write_function(stream, "-ERR unloading module [%s]\n", err); } if (switch_xml_reload(&err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK Reloading XML\n"); } if (switch_loadable_module_load_module((char *) SWITCH_GLOBAL_dirs.mod_dir, (char *) cmd, SWITCH_TRUE, &err) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK module loaded\n"); } else { stream->write_function(stream, "-ERR loading module [%s]\n", err); } switch_mutex_unlock(reload_mutex); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(reload_xml_function) { const char *err = ""; switch_xml_reload(&err); stream->write_function(stream, "+OK [%s]\n", err); return SWITCH_STATUS_SUCCESS; } #define KILL_SYNTAX " [cause]" SWITCH_STANDARD_API(kill_function) { char *mycmd = NULL, *kcause = NULL; switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; if (zstr(cmd) || !(mycmd = strdup(cmd))) { stream->write_function(stream, "-USAGE: %s\n", KILL_SYNTAX); return SWITCH_STATUS_SUCCESS; } if ((kcause = strchr(mycmd, ' '))) { *kcause++ = '\0'; if (!zstr(kcause)) { cause = switch_channel_str2cause(kcause); } } if (switch_ivr_kill_uuid(mycmd, cause) != SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "-ERR No Such Channel!\n"); } else { stream->write_function(stream, "+OK\n"); } switch_safe_free(mycmd); return SWITCH_STATUS_SUCCESS; } #define OUTGOING_ANSWER_SYNTAX "" SWITCH_STANDARD_API(outgoing_answer_function) { switch_core_session_t *outgoing_session = NULL; char *mycmd = NULL; if (zstr(cmd) || !(mycmd = strdup(cmd))) { stream->write_function(stream, "-USAGE: %s\n", OUTGOING_ANSWER_SYNTAX); return SWITCH_STATUS_SUCCESS; } if (zstr(mycmd) || !(outgoing_session = switch_core_session_locate(mycmd))) { stream->write_function(stream, "-ERR No Such Channel!\n"); } else { switch_channel_t *channel = switch_core_session_get_channel(outgoing_session); if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) { switch_channel_mark_answered(channel); stream->write_function(stream, "+OK\n"); } else { stream->write_function(stream, "-ERR Not an outbound channel!\n"); } switch_core_session_rwunlock(outgoing_session); } switch_safe_free(mycmd); return SWITCH_STATUS_SUCCESS; } #define PREPROCESS_SYNTAX "<>" SWITCH_STANDARD_API(preprocess_function) { switch_core_session_t *ksession = NULL; char *mycmd = NULL, *argv[3] = { 0 }; int argc = 0; if (zstr(cmd) || !(mycmd = strdup(cmd))) { goto usage; } argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 2) { goto usage; } if (!(ksession = switch_core_session_locate(argv[0]))) { stream->write_function(stream, "-ERR No Such Channel!\n"); goto done; } else { switch_ivr_preprocess_session(ksession, (char *) argv[1]); switch_core_session_rwunlock(ksession); stream->write_function(stream, "+OK\n"); goto done; } usage: stream->write_function(stream, "-USAGE: %s\n", PREPROCESS_SYNTAX); done: switch_safe_free(mycmd); return SWITCH_STATUS_SUCCESS; } #define PARK_SYNTAX "" SWITCH_STANDARD_API(park_function) { switch_core_session_t *ksession = NULL; if (!cmd) { stream->write_function(stream, "-USAGE: %s\n", PARK_SYNTAX); } else if ((ksession = switch_core_session_locate(cmd))) { switch_ivr_park_session(ksession); switch_core_session_rwunlock(ksession); stream->write_function(stream, "+OK\n"); } else { stream->write_function(stream, "-ERR No Such Channel!\n"); } return SWITCH_STATUS_SUCCESS; } #define TRANSFER_SYNTAX " [-bleg|-both] [] []" SWITCH_STANDARD_API(transfer_function) { switch_core_session_t *tsession = NULL, *other_session = NULL; char *mycmd = NULL, *argv[5] = { 0 }; int argc = 0; char *tuuid, *dest, *dp, *context, *arg = NULL; if (zstr(cmd) || !(mycmd = strdup(cmd))) { stream->write_function(stream, "-USAGE: %s\n", TRANSFER_SYNTAX); return SWITCH_STATUS_SUCCESS; } argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc < 2 || argc > 5) { stream->write_function(stream, "-USAGE: %s\n", TRANSFER_SYNTAX); goto done; } tuuid = argv[0]; dest = argv[1]; dp = argv[2]; context = argv[3]; if (zstr(tuuid) || !(tsession = switch_core_session_locate(tuuid))) { stream->write_function(stream, "-ERR No Such Channel!\n"); goto done; } if (*dest == '-') { arg = dest; dest = argv[2]; dp = argv[3]; context = argv[4]; } if (arg) { switch_channel_t *channel = switch_core_session_get_channel(tsession); const char *uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE); arg++; if (!strcasecmp(arg, "bleg")) { if (uuid && (other_session = switch_core_session_locate(uuid))) { switch_core_session_t *tmp = tsession; tsession = other_session; other_session = NULL; switch_core_session_rwunlock(tmp); } } else if (!strcasecmp(arg, "both")) { if (uuid && (other_session = switch_core_session_locate(uuid))) { switch_channel_t *other_channel = switch_core_session_get_channel(other_session); switch_channel_set_flag(other_channel, CF_REDIRECT); switch_channel_set_flag(channel, CF_REDIRECT); switch_ivr_session_transfer(other_session, dest, dp, context); switch_core_session_rwunlock(other_session); } } } if (switch_ivr_session_transfer(tsession, dest, dp, context) == SWITCH_STATUS_SUCCESS) { stream->write_function(stream, "+OK\n"); } else { stream->write_function(stream, "-ERR\n"); } switch_core_session_rwunlock(tsession); done: switch_safe_free(mycmd); return SWITCH_STATUS_SUCCESS; } #define DUAL_TRANSFER_SYNTAX " [/][/] [/][/]" SWITCH_STANDARD_API(dual_transfer_function) { switch_core_session_t *tsession = NULL, *other_session = NULL; char *mycmd = NULL, *argv[5] = { 0 }; int argc = 0; char *tuuid, *dest1, *dest2, *dp1 = NULL, *dp2 = NULL, *context1 = NULL, *context2 = NULL; if (zstr(cmd) || !(mycmd = strdup(cmd))) { stream->write_function(stream, "-USAGE: %s\n", DUAL_TRANSFER_SYNTAX); return SWITCH_STATUS_SUCCESS; } argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); if (argc != 3) { stream->write_function(stream, "-USAGE: %s\n", DUAL_TRANSFER_SYNTAX); goto done; } tuuid = argv[0]; dest1 = argv[1]; dest2= argv[2]; if ((dp1 = strstr(dest1, "/inline")) && *(dp1 + 7) == '\0') { *dp1++ = '\0'; } else { if ((dp1 = strchr(dest1, '/'))) { *dp1++ = '\0'; if ((context1 = strchr(dp1, '/'))) { *context1++ = '\0'; } } } if ((dp2 = strstr(dest2, "/inline")) && *(dp2 + 7) == '\0') { *dp2++ = '\0'; } else { if ((dp2 = strchr(dest2, '/'))) { *dp2++ = '\0'; if ((context2 = strchr(dp2, '/'))) { *context2++ = '\0'; } } } if (zstr(tuuid) || !(tsession = switch_core_session_locate(tuuid))) { stream->write_function(stream, "-ERR No Such Channel!\n"); goto done; } if (switch_core_session_get_partner(tsession, &other_session) == SWITCH_STATUS_SUCCESS) { switch_ivr_session_transfer(other_session, dest2, dp2, context2); switch_core_session_rwunlock(other_session); } switch_ivr_session_transfer(tsession, dest1, dp1, context1); stream->write_function(stream, "+OK\n"); switch_core_session_rwunlock(tsession); done: switch_safe_free(mycmd); return SWITCH_STATUS_SUCCESS; } #define TONE_DETECT_SYNTAX " [ ]" SWITCH_STANDARD_API(tone_detect_session_function) { char *argv[8] = { 0 }; int argc; char *mydata = NULL; time_t to = 0; switch_core_session_t *rsession; int hits = 1; if (!cmd) { stream->write_function(stream, "-USAGE: %s\n", TONE_DETECT_SYNTAX); return SWITCH_STATUS_SUCCESS; } mydata = strdup(cmd); switch_assert(mydata != NULL); if ((argc = switch_separate_string(mydata, ' ', argv, sizeof(argv) / sizeof(argv[0]))) < 3 || !argv[0]) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "-ERR INVALID ARGS!\n"); return SWITCH_STATUS_SUCCESS; } if (!(rsession = switch_core_session_locate(argv[0]))) { stream->write_function(stream, "-ERR Error Cannot locate session!\n"); return SWITCH_STATUS_SUCCESS; } if (argv[4]) { uint32_t mto; if (*argv[4] == '+') { if ((mto = atoi(argv[4] + 1)) > 0) { to = switch_epoch_time_now(NULL) + mto; } else { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "INVALID Timeout!\n"); goto done; } } else { if ((to = atoi(argv[4])) < switch_epoch_time_now(NULL)) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "INVALID Timeout!\n"); to = 0; goto done; } } } if (argv[7]) { hits = atoi(argv[7]); if (hits < 0) { hits = 1; } } switch_ivr_tone_detect_session(rsession, argv[1], argv[2], argv[3], to, hits, argv[5], argv[6], NULL); stream->write_function(stream, "+OK Enabling tone detection '%s' '%s' '%s'\n", argv[1], argv[2], argv[3]); done: free(mydata); switch_core_session_rwunlock(rsession); return SWITCH_STATUS_SUCCESS; } SWITCH_STANDARD_API(uuid_function) { char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1]; switch_uuid_str(uuid_str, sizeof(uuid_str)); stream->write_function(stream, "%s", uuid_str); return SWITCH_STATUS_SUCCESS; } #define UUID_CHAT_SYNTAX " " SWITCH_STANDARD_API(uuid_chat) { switch_core_session_t *tsession = NULL; char *uuid = NULL, *text = NULL; if (!zstr(cmd) && (uuid = strdup(cmd))) { if ((text = strchr(uuid, ' '))) { *text++ = '\0'; } } if (zstr(uuid) || zstr(text)) { stream->write_function(stream, "-USAGE: %s\n", UUID_CHAT_SYNTAX); } else { if ((tsession = switch_core_session_locate(uuid))) { switch_event_t *event; if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) { switch_event_add_body(event, "%s", text); if (switch_core_session_receive_event(tsession, &event) != SWITCH_STATUS_SUCCESS) { switch_event_destroy(&event); stream->write_function(stream, "-ERR Send Failed\n"); } else { stream->write_function(stream, "+OK\n"); } } switch_core_session_rwunlock(tsession); } else { stream->write_function(stream, "-ERR No Such Channel %s!\n", uuid); } } switch_safe_free(uuid); return SWITCH_STATUS_SUCCESS; } #define UUID_DEFLECT_SYNTAX " " SWITCH_STANDARD_API(uuid_deflect) { switch_core_session_t *tsession = NULL; char *uuid = NULL, *text = NULL; if (!zstr(cmd) && (uuid = strdup(cmd))) { if ((text = strchr(uuid, ' '))) { *text++ = '\0'; } } if (zstr(uuid) || zstr(text)) { stream->write_function(stream, "-USAGE: %s\n", UUID_DEFLECT_SYNTAX); } else { if ((tsession = switch_core_session_locate(uuid))) { switch_core_session_message_t msg = { 0 }; /* Tell the channel to deflect the call */ msg.from = __FILE__; msg.string_arg = text; msg.message_id = SWITCH_MESSAGE_INDICATE_DEFLECT; switch_core_session_receive_message(tsession, &msg); stream->write_function(stream, "+OK:%s\n", msg.string_reply); switch_core_session_rwunlock(tsession); } else { stream->write_function(stream, "-ERR No Such Channel %s!\n", uuid); } } switch_safe_free(uuid); return SWITCH_STATUS_SUCCESS; } #define UUID_RECOVERY_REFRESH_SYNTAX " " SWITCH_STANDARD_API(uuid_recovery_refresh) { switch_core_session_t *tsession = NULL; char *uuid = NULL, *text = NULL; if (!zstr(cmd) && (uuid = strdup(cmd))) { if ((text = strchr(uuid, ' '))) { *text++ = '\0'; } } if (zstr(uuid) || zstr(text)) { stream->write_function(stream, "-USAGE: %s\n", UUID_RECOVERY_REFRESH_SYNTAX); } else { if ((tsession = switch_core_session_locate(uuid))) { switch_core_session_message_t msg = { 0 }; /* Tell the channel to recovery_refresh the call */ msg.from = __FILE__; msg.string_arg = text; msg.message_id = SWITCH_MESSAGE_INDICATE_RECOVERY_REFRESH; switch_core_session_receive_message(tsession, &msg); stream->write_function(stream, "+OK:%s\n", msg.string_reply); switch_core_session_rwunlock(tsession); } else { stream->write_function(stream, "-ERR No Such Channel %s!\n", uuid); } } switch_safe_free(uuid); return SWITCH_STATUS_SUCCESS; } #define SCHED_TRANSFER_SYNTAX "[+]