mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-04-30 14:06:04 +00:00
748 lines
16 KiB
C++
748 lines
16 KiB
C++
|
|
#include <switch.h>
|
|
#include "freeswitch_lua.h"
|
|
using namespace LUA;
|
|
|
|
extern "C" {
|
|
int docall(lua_State * L, int narg, int nresults, int perror, int fatal);
|
|
};
|
|
|
|
Session::Session():CoreSession()
|
|
{
|
|
cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
|
|
hh = mark = 0;
|
|
}
|
|
|
|
Session::Session(char *nuuid, CoreSession *a_leg):CoreSession(nuuid, a_leg)
|
|
{
|
|
cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
|
|
hh = mark = 0;
|
|
}
|
|
|
|
Session::Session(switch_core_session_t *new_session):CoreSession(new_session)
|
|
{
|
|
cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
|
|
hh = mark = 0;
|
|
}
|
|
static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup);
|
|
|
|
|
|
void Session::destroy(const char *err)
|
|
{
|
|
|
|
if (!allocated) {
|
|
return;
|
|
}
|
|
|
|
if (session) {
|
|
if (!channel) {
|
|
channel = switch_core_session_get_channel(session);
|
|
}
|
|
switch_channel_set_private(channel, "CoreSession", NULL);
|
|
switch_core_event_hook_remove_state_change(session, lua_hanguphook);
|
|
}
|
|
|
|
switch_safe_free(hangup_func_str);
|
|
switch_safe_free(hangup_func_arg);
|
|
switch_safe_free(cb_function);
|
|
switch_safe_free(cb_arg);
|
|
|
|
unsetInputCallback();
|
|
|
|
CoreSession::destroy();
|
|
|
|
|
|
if (!zstr(err)) {
|
|
lua_pushstring(L, err);
|
|
lua_error(L);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
Session::~Session()
|
|
{
|
|
destroy();
|
|
}
|
|
|
|
bool Session::begin_allow_threads()
|
|
{
|
|
do_hangup_hook();
|
|
return true;
|
|
}
|
|
|
|
bool Session::end_allow_threads()
|
|
{
|
|
do_hangup_hook();
|
|
return true;
|
|
}
|
|
|
|
void Session::setLUA(lua_State * state)
|
|
{
|
|
L = state;
|
|
|
|
if (session && allocated && uuid) {
|
|
lua_setglobal(L, uuid);
|
|
lua_getglobal(L, uuid);
|
|
}
|
|
|
|
}
|
|
|
|
int Session::originate(CoreSession *a_leg_session, char *dest, int timeout)
|
|
{
|
|
if (zstr(dest)) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing destination.\n");
|
|
return 0;
|
|
}
|
|
|
|
int x = CoreSession::originate(a_leg_session, dest, timeout);
|
|
|
|
if (x) {
|
|
setLUA(L);
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
lua_State *Session::getLUA()
|
|
{
|
|
if (!L) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh!\n");
|
|
}
|
|
return L;
|
|
}
|
|
|
|
|
|
bool Session::ready()
|
|
{
|
|
bool r;
|
|
|
|
if (!session) {
|
|
return false;
|
|
}
|
|
sanity_check(false);
|
|
r = switch_channel_ready(channel) != 0;
|
|
do_hangup_hook();
|
|
|
|
return r;
|
|
}
|
|
|
|
void Session::check_hangup_hook()
|
|
{
|
|
if (hangup_func_str && (hook_state == CS_HANGUP || hook_state == CS_ROUTING)) {
|
|
hh++;
|
|
}
|
|
}
|
|
|
|
void Session::do_hangup_hook()
|
|
{
|
|
if (hh && !mark) {
|
|
int arg_count = 2;
|
|
mark++;
|
|
|
|
if (!getLUA()) {
|
|
return;
|
|
}
|
|
|
|
lua_getglobal(L, (char *) hangup_func_str);
|
|
lua_getglobal(L, uuid);
|
|
|
|
lua_pushstring(L, hook_state == CS_HANGUP ? "hangup" : "transfer");
|
|
|
|
if (hangup_func_arg) {
|
|
lua_getglobal(L, (char *) hangup_func_arg);
|
|
arg_count++;
|
|
}
|
|
|
|
docall(L, arg_count, 1, 1, 0);
|
|
|
|
const char *err = lua_tostring(L, -1);
|
|
|
|
switch_channel_set_variable(channel, "lua_hangup_hook_return_val", err);
|
|
|
|
if (!zstr(err)) {
|
|
|
|
if (!strcasecmp(err, "exit") || !strcasecmp(err, "die")) {
|
|
lua_error(L);
|
|
} else {
|
|
lua_pop(L, 1);
|
|
}
|
|
} else {
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
|
|
if (channel) {
|
|
switch_channel_set_private(channel, "CoreSession", NULL);
|
|
}
|
|
|
|
if (session) {
|
|
switch_core_event_hook_remove_state_change(session, lua_hanguphook);
|
|
}
|
|
switch_safe_free(hangup_func_str);
|
|
|
|
}
|
|
}
|
|
|
|
static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup)
|
|
{
|
|
switch_channel_t *channel = switch_core_session_get_channel(session_hungup);
|
|
Session *coresession = NULL;
|
|
switch_channel_state_t state = switch_channel_get_state(channel);
|
|
|
|
if (session_hungup) {
|
|
|
|
channel = switch_core_session_get_channel(session_hungup);
|
|
|
|
if (channel) {
|
|
void *vs = switch_channel_get_private(channel, "CoreSession");
|
|
if (vs) {
|
|
coresession = (Session *) vs;
|
|
}
|
|
}
|
|
|
|
if (!(coresession && coresession->hook_state)) {
|
|
return SWITCH_STATUS_FALSE;
|
|
}
|
|
|
|
if (coresession && coresession->allocated && (state == CS_HANGUP || state == CS_ROUTING) && coresession->hook_state != state) {
|
|
coresession->hook_state = state;
|
|
coresession->check_hangup_hook();
|
|
switch_core_event_hook_remove_state_change(session_hungup, lua_hanguphook);
|
|
}
|
|
}
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
void Session::setHangupHook(char *func, char *arg)
|
|
{
|
|
|
|
sanity_check_noreturn;
|
|
|
|
switch_safe_free(hangup_func_str);
|
|
switch_safe_free(hangup_func_arg);
|
|
|
|
if (func) {
|
|
hangup_func_str = strdup(func);
|
|
if (!zstr(arg)) {
|
|
hangup_func_arg = strdup(arg);
|
|
}
|
|
switch_channel_set_private(channel, "CoreSession", this);
|
|
hook_state = switch_channel_get_state(channel);
|
|
switch_core_event_hook_add_state_change(session, lua_hanguphook);
|
|
}
|
|
}
|
|
|
|
void Session::unsetInputCallback(void)
|
|
{
|
|
sanity_check_noreturn;
|
|
switch_safe_free(cb_function);
|
|
switch_safe_free(cb_arg);
|
|
args.input_callback = NULL;
|
|
ap = NULL;
|
|
switch_channel_clear_flag_recursive(channel, CF_QUEUE_TEXT_EVENTS);
|
|
}
|
|
|
|
void Session::setInputCallback(char *cbfunc, char *funcargs)
|
|
{
|
|
|
|
sanity_check_noreturn;
|
|
|
|
switch_safe_free(cb_function);
|
|
if (cbfunc) {
|
|
cb_function = strdup(cbfunc);
|
|
}
|
|
|
|
switch_safe_free(cb_arg);
|
|
if (funcargs) {
|
|
cb_arg = strdup(funcargs);
|
|
}
|
|
|
|
args.buf = this;
|
|
switch_channel_set_private(channel, "CoreSession", this);
|
|
|
|
args.input_callback = dtmf_callback;
|
|
ap = &args;
|
|
|
|
switch_channel_set_flag_recursive(channel, CF_QUEUE_TEXT_EVENTS);
|
|
|
|
}
|
|
|
|
switch_status_t Session::run_dtmf_callback(void *input, switch_input_type_t itype)
|
|
{
|
|
const char *ret;
|
|
|
|
if (!getLUA()) {
|
|
return SWITCH_STATUS_FALSE;;
|
|
}
|
|
|
|
switch (itype) {
|
|
case SWITCH_INPUT_TYPE_DTMF:
|
|
{
|
|
switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
|
|
char str[3] = "";
|
|
int arg_count = 3;
|
|
int r;
|
|
|
|
lua_getglobal(L, (char *) cb_function);
|
|
lua_getglobal(L, uuid);
|
|
|
|
lua_pushstring(L, "dtmf");
|
|
|
|
lua_newtable(L);
|
|
lua_pushstring(L, "digit");
|
|
str[0] = dtmf->digit;
|
|
lua_pushstring(L, str);
|
|
lua_rawset(L, -3);
|
|
|
|
lua_pushstring(L, "duration");
|
|
lua_pushnumber(L, dtmf->duration);
|
|
lua_rawset(L, -3);
|
|
|
|
if (!zstr(cb_arg)) {
|
|
lua_getglobal(L, (char *) cb_arg);
|
|
arg_count++;
|
|
}
|
|
|
|
r = docall(L, arg_count, 1, 1, 0);
|
|
|
|
if (!r) {
|
|
ret = lua_tostring(L, -1);
|
|
lua_pop(L, 1);
|
|
} else {
|
|
ret = "SCRIPT_ERROR";
|
|
}
|
|
|
|
return process_callback_result((char *) ret);
|
|
}
|
|
break;
|
|
case SWITCH_INPUT_TYPE_EVENT:
|
|
{
|
|
switch_event_t *event = (switch_event_t *) input;
|
|
int arg_count = 3;
|
|
|
|
|
|
lua_getglobal(L, (char *) cb_function);
|
|
lua_getglobal(L, uuid);
|
|
lua_pushstring(L, "event");
|
|
mod_lua_conjure_event(L, event, "__Input_Event__", 1);
|
|
lua_getglobal(L, "__Input_Event__");
|
|
|
|
if (!zstr(cb_arg)) {
|
|
lua_getglobal(L, (char *) cb_arg);
|
|
arg_count++;
|
|
}
|
|
|
|
if (!docall(L, arg_count, 1, 1, 0)) {
|
|
ret = lua_tostring(L, -1);
|
|
lua_pop(L, 1);
|
|
} else {
|
|
ret = "SCRIPT_ERROR";
|
|
}
|
|
|
|
return process_callback_result((char *) ret);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
Dbh::Dbh(char *dsn, char *user, char *pass)
|
|
{
|
|
dbh = NULL;
|
|
err = NULL;
|
|
char *tmp = NULL;
|
|
|
|
if (!zstr(user) || !zstr(pass)) {
|
|
tmp = switch_mprintf("%s%s%s%s%s", dsn,
|
|
zstr(user) ? "" : ":",
|
|
zstr(user) ? "" : user,
|
|
zstr(pass) ? "" : ":",
|
|
zstr(pass) ? "" : pass
|
|
);
|
|
|
|
dsn = tmp;
|
|
}
|
|
|
|
if (!zstr(dsn) && switch_cache_db_get_db_handle_dsn(&dbh, dsn) == SWITCH_STATUS_SUCCESS) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "DBH handle %p Connected.\n", (void *) dbh);
|
|
} else {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Connection failed. DBH NOT Connected.\n");
|
|
}
|
|
|
|
switch_safe_free(tmp);
|
|
|
|
}
|
|
|
|
Dbh::~Dbh()
|
|
{
|
|
if (dbh) release();
|
|
|
|
clear_error();
|
|
}
|
|
|
|
void Dbh::clear_error()
|
|
{
|
|
switch_safe_free(err);
|
|
}
|
|
|
|
char *Dbh::last_error()
|
|
{
|
|
return err;
|
|
}
|
|
|
|
bool Dbh::release()
|
|
{
|
|
if (dbh) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "DBH handle %p released.\n", (void *) dbh);
|
|
switch_cache_db_release_db_handle(&dbh);
|
|
return true;
|
|
}
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
|
|
return false;
|
|
}
|
|
|
|
bool Dbh::connected()
|
|
{
|
|
return dbh ? true : false;
|
|
}
|
|
|
|
bool Dbh::test_reactive(char *test_sql, char *drop_sql, char *reactive_sql)
|
|
{
|
|
if (dbh) {
|
|
if (!zstr(test_sql) && !zstr(reactive_sql)) {
|
|
if (switch_cache_db_test_reactive(dbh, test_sql, drop_sql, reactive_sql) == SWITCH_TRUE) {
|
|
return true;
|
|
}
|
|
} else {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing parameters.\n");
|
|
}
|
|
} else {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int Dbh::query_callback(void *pArg, int argc, char **argv, char **cargv)
|
|
{
|
|
SWIGLUA_FN *lua_fun = (SWIGLUA_FN *)pArg;
|
|
int ret = 0;
|
|
|
|
lua_pushvalue(lua_fun->L, lua_fun->idx); /* get the lua callback function onto the stack */
|
|
|
|
lua_newtable(lua_fun->L); /* push a row (table) */
|
|
|
|
for (int i = 0; i < argc; i++) {
|
|
lua_pushstring(lua_fun->L, switch_str_nil(cargv[i]));
|
|
lua_pushstring(lua_fun->L, switch_str_nil(argv[i]));
|
|
lua_settable(lua_fun->L, -3);
|
|
}
|
|
|
|
if (docall(lua_fun->L, 1, 1, 1, 0)) {
|
|
return 1;
|
|
}
|
|
|
|
ret = lua_tonumber(lua_fun->L, -1);
|
|
lua_pop(lua_fun->L, 1);
|
|
|
|
if (ret != 0) {
|
|
return 1;
|
|
}
|
|
|
|
return 0; /* 0 to continue with next row */
|
|
}
|
|
|
|
bool Dbh::query(char *sql, SWIGLUA_FN lua_fun)
|
|
{
|
|
clear_error();
|
|
|
|
if (zstr(sql)) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing SQL query.\n");
|
|
return false;
|
|
}
|
|
|
|
if (dbh) {
|
|
if (lua_fun.L) {
|
|
if (switch_cache_db_execute_sql_callback(dbh, sql, query_callback, &lua_fun, &err) == SWITCH_STATUS_SUCCESS) {
|
|
return true;
|
|
}
|
|
} else { /* if no lua_fun arg is passed from Lua, an empty initialized struct will be sent - see freeswitch.i */
|
|
if (switch_cache_db_execute_sql(dbh, sql, &err) == SWITCH_STATUS_SUCCESS) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int Dbh::affected_rows()
|
|
{
|
|
if (dbh) {
|
|
return switch_cache_db_affected_rows(dbh);
|
|
}
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
|
|
return 0;
|
|
}
|
|
|
|
int Dbh::load_extension(const char *extension)
|
|
{
|
|
if (zstr(extension)) {
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing extension name.\n");
|
|
return 0;
|
|
}
|
|
|
|
if (dbh) {
|
|
return switch_cache_db_load_extension(dbh, extension);
|
|
}
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
|
|
return 0;
|
|
}
|
|
|
|
JSON::JSON()
|
|
{
|
|
_encode_empty_table_as_object = true;
|
|
}
|
|
|
|
JSON::~JSON()
|
|
{
|
|
}
|
|
|
|
void JSON::encode_empty_table_as_object(bool flag)
|
|
{
|
|
_encode_empty_table_as_object = flag;
|
|
}
|
|
|
|
void JSON::return_unformatted_json(bool flag)
|
|
{
|
|
_return_unformatted_json = flag;
|
|
}
|
|
|
|
cJSON *JSON::decode(const char *str)
|
|
{
|
|
cJSON *json = cJSON_Parse(str);
|
|
return json;
|
|
}
|
|
|
|
#define ADDITEM(json, k, v) do { \
|
|
if (return_array > 0) { cJSON_AddItemToArray(json, v);} else { cJSON_AddItemToObject(json, k, v); } \
|
|
} while (0)
|
|
|
|
void JSON::LuaTable2cJSON(lua_State *L, int index, cJSON **json)
|
|
{
|
|
int return_array = -1;
|
|
|
|
// Push another reference to the table on top of the stack (so we know
|
|
// where it is, and this function can work for negative, positive and
|
|
// pseudo indices
|
|
lua_pushvalue(L, index);
|
|
// stack now contains: -1 => table
|
|
lua_pushnil(L);
|
|
// stack now contains: -1 => nil; -2 => table
|
|
while (lua_next(L, -2)) {
|
|
// stack now contains: -1 => value; -2 => key; -3 => table
|
|
// copy the key so that lua_tostring does not modify the original
|
|
lua_pushvalue(L, -2);
|
|
// stack now contains: -1 => key; -2 => value; -3 => key; -4 => table
|
|
|
|
const char *key = lua_tostring(L, -1);
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "key: %s\n", key);
|
|
|
|
if (return_array < 0) {
|
|
if (lua_isnumber(L, -1) && lua_tonumber(L, -1) == 1) {
|
|
return_array = 1;
|
|
*json = cJSON_CreateArray();
|
|
} else {
|
|
return_array = 0;
|
|
*json = cJSON_CreateObject();
|
|
}
|
|
}
|
|
|
|
switch_assert(*json);
|
|
|
|
if (lua_isnumber(L, -2)) {
|
|
ADDITEM(*json, key, cJSON_CreateNumber(lua_tonumber(L, -2)));
|
|
} else if (lua_isstring(L, -2)) {
|
|
ADDITEM(*json, key, cJSON_CreateString(lua_tostring(L, -2)));
|
|
} else if (lua_isboolean(L, -2)) {
|
|
ADDITEM(*json, key, cJSON_CreateBool(lua_toboolean(L, -2)));
|
|
} else if (lua_isnil(L, -2)) {
|
|
ADDITEM(*json, key, cJSON_CreateNull());
|
|
} else if (lua_isnone(L, -2)) {
|
|
// ADDITEM(*json, key, cJSON_CreateNone());
|
|
} else if (lua_istable(L, -2)) {
|
|
cJSON *child = NULL;
|
|
LuaTable2cJSON(L, -2, &child);
|
|
if (child) {
|
|
ADDITEM(*json, key, child);
|
|
} else { // empty table?
|
|
ADDITEM(*json, key, _encode_empty_table_as_object ? cJSON_CreateObject() : cJSON_CreateArray());
|
|
}
|
|
}
|
|
|
|
// pop value + copy of key, leaving original key
|
|
lua_pop(L, 2);
|
|
// stack now contains: -1 => key; -2 => table
|
|
}
|
|
|
|
// stack now contains: -1 => table (when lua_next returns 0 it pops the key
|
|
// but does not push anything.)
|
|
// Pop table
|
|
lua_pop(L, 1);
|
|
// Stack is now the same as it was on entry to this function
|
|
}
|
|
|
|
std::string JSON::encode(SWIGLUA_TABLE lua_table)
|
|
{
|
|
lua_State *L = lua_table.L;
|
|
cJSON *json = NULL;
|
|
|
|
luaL_checktype(L, lua_table.idx, LUA_TTABLE);
|
|
LuaTable2cJSON(L, -1, &json);
|
|
|
|
if (!json) {
|
|
json = _encode_empty_table_as_object ? cJSON_CreateObject() : cJSON_CreateArray();
|
|
}
|
|
|
|
char *s = _return_unformatted_json ? cJSON_PrintUnformatted(json) : cJSON_Print(json);
|
|
std::string result = std::string(s);
|
|
free(s);
|
|
cJSON_Delete(json);
|
|
return result;
|
|
}
|
|
|
|
int JSON::cJSON2LuaTable(lua_State *L, cJSON *json) {
|
|
cJSON *current = NULL;
|
|
|
|
if (!json) return 0;
|
|
|
|
lua_newtable(L);
|
|
|
|
if (json->type == cJSON_Object) {
|
|
for (current = json->child; current; current = current->next) {
|
|
// printf("type: %d %s\n", current->type, current->string);
|
|
switch (current->type) {
|
|
case cJSON_String:
|
|
lua_pushstring(L, current->valuestring);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
case cJSON_Number:
|
|
lua_pushnumber(L, current->valuedouble);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
case cJSON_True:
|
|
lua_pushboolean(L, 1);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
case cJSON_False:
|
|
lua_pushboolean(L, 0);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
case cJSON_Object:
|
|
JSON::cJSON2LuaTable(L, current);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
case cJSON_Array:
|
|
JSON::cJSON2LuaTable(L, current);
|
|
lua_setfield(L, -2, current->string);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} else if (json->type == cJSON_Array) {
|
|
int i = 1;
|
|
|
|
for (current = json->child; current; current = current->next) {
|
|
// printf("array type: %d %s\n", current->type, current->valuestring);
|
|
switch (current->type) {
|
|
case cJSON_String:
|
|
lua_pushinteger(L, i++);
|
|
lua_pushstring(L, current->valuestring);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case cJSON_Number:
|
|
lua_pushinteger(L, i++);
|
|
lua_pushnumber(L, current->valuedouble);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case cJSON_True:
|
|
lua_pushinteger(L, i++);
|
|
lua_pushboolean(L, 1);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case cJSON_False:
|
|
lua_pushinteger(L, i++);
|
|
lua_pushboolean(L, 0);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case cJSON_Object:
|
|
lua_pushinteger(L, i++);
|
|
JSON::cJSON2LuaTable(L, current);
|
|
lua_settable(L, -3);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
cJSON *JSON::execute(const char *str)
|
|
{
|
|
cJSON *cmd = cJSON_Parse(str);
|
|
cJSON *reply = NULL;
|
|
|
|
if (cmd) {
|
|
switch_json_api_execute(cmd, NULL, &reply);
|
|
}
|
|
|
|
cJSON_Delete(cmd);
|
|
|
|
return reply;
|
|
}
|
|
|
|
cJSON *JSON::execute(SWIGLUA_TABLE table)
|
|
{
|
|
lua_State *L = table.L;
|
|
cJSON *json = NULL;
|
|
cJSON *reply = NULL;
|
|
|
|
luaL_checktype(L, table.idx, LUA_TTABLE);
|
|
LuaTable2cJSON(L, -1, &json);
|
|
|
|
switch_json_api_execute(json, NULL, &reply);
|
|
cJSON_Delete(json);
|
|
return reply;
|
|
}
|
|
|
|
std::string JSON::execute2(const char *str)
|
|
{
|
|
cJSON *reply = execute(str);
|
|
char *s = _return_unformatted_json ? cJSON_PrintUnformatted(reply) : cJSON_Print(reply);
|
|
std::string result = std::string(s);
|
|
free(s);
|
|
cJSON_Delete(reply);
|
|
return result;
|
|
}
|
|
|
|
std::string JSON::execute2(SWIGLUA_TABLE table)
|
|
{
|
|
cJSON *reply = execute(table);
|
|
char *s = _return_unformatted_json ? cJSON_PrintUnformatted(reply) : cJSON_Print(reply);
|
|
std::string result = std::string(s);
|
|
free(s);
|
|
cJSON_Delete(reply);
|
|
return result;
|
|
}
|