507 lines
15 KiB
C
Executable File
507 lines
15 KiB
C
Executable File
/*
|
|
* Copyright (C) 2009 Mamadou Diop.
|
|
*
|
|
* Contact: Mamadou Diop <diopmamadou(at)doubango.org>
|
|
*
|
|
* This file is part of Open Source Doubango Framework.
|
|
*
|
|
* DOUBANGO is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* DOUBANGO is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with DOUBANGO.
|
|
*
|
|
*/
|
|
#include "main.h"
|
|
#include "common.h"
|
|
|
|
#include "invite.h"
|
|
#include "message.h"
|
|
#include "options.h"
|
|
#include "publish.h"
|
|
#include "register.h"
|
|
#include "subscribe.h"
|
|
|
|
#include "tinydav.h" /* Doubango Audio/Video Framework */
|
|
|
|
#include "tipsec.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#define LINE_DELIM "\n \r\n"
|
|
|
|
/* === global variables === */
|
|
ctx_t* ctx = tsk_null;
|
|
|
|
const char* trim(const char*);
|
|
int insert(char* dest, tsk_size_t index, tsk_size_t dest_size, char* src, tsk_size_t src_size);
|
|
int update_param(const char* , const char* );
|
|
int execute(const cmd_t* );
|
|
|
|
/* === entry point === */
|
|
int main(int argc, char** argv)
|
|
{
|
|
char cmdbuf[4096];
|
|
tsk_buffer_t* buffer = tsk_null;
|
|
cmd_t* cmd = tsk_null;
|
|
tsk_bool_t comment = tsk_false;
|
|
int ret;
|
|
int i, index;
|
|
const char* start = tsk_null, *end = tsk_null;
|
|
|
|
int a = 32 | 1 | 2;
|
|
|
|
/* Copyright */
|
|
printf("Doubango Project (tinyDEMO)\nCopyright (C) 2009 - 2013 Mamadou Diop \n\n");
|
|
|
|
/* Initialize Network Layer ==> Mandatory */
|
|
tnet_startup();
|
|
/* Initialize Doubango Audio/Video Framework ==> will register all plugins(codecs and sessions)
|
|
* Not mandatory if you have your own plugins*/
|
|
tdav_init();
|
|
|
|
struct tsk_plugin_s *ip_p;
|
|
tipsec_plugin_register_file("./ipsec_linux.so", &ip_p);
|
|
/* Print Usage */
|
|
//cmd_print_help();
|
|
|
|
/* create user's ctx */
|
|
if(!(ctx = ctx_create()) || !ctx->stack) {
|
|
TSK_DEBUG_ERROR("Failed to create user's ctx.");
|
|
goto bail;
|
|
}
|
|
|
|
/* create new buffer */
|
|
if(!(buffer = tsk_buffer_create_null())) {
|
|
TSK_DEBUG_ERROR("Failed to create new buffer.");
|
|
goto bail;
|
|
}
|
|
|
|
/* initial args */
|
|
for(i=1 /* index zero contains the exe path */, index=0; i<argc && argv[i]; i++) {
|
|
if(index) {
|
|
tsk_buffer_append(buffer, " ", 1);
|
|
}
|
|
tsk_buffer_append(buffer, argv[i], tsk_strlen(argv[i]));
|
|
}
|
|
|
|
/* If initial args ==> parse it now */
|
|
if(buffer->size) {
|
|
TSK_DEBUG_INFO("Initial command-line: %s", buffer->data);
|
|
goto init_buffer;
|
|
}
|
|
|
|
/* always use fgets() instead of gets. gets() is considered to be unsafe.(Android and Mac OS X will warn) */
|
|
while(fgets(cmdbuf, sizeof(cmdbuf), stdin)) {
|
|
TSK_DEBUG_INFO("Command-Line: %s", cmdbuf);
|
|
tsk_buffer_cleanup(buffer); /* cannot read from console while executing scenario */
|
|
tsk_buffer_append(buffer, cmdbuf, tsk_strlen(cmdbuf));
|
|
init_buffer:
|
|
start = buffer->data;
|
|
//start = trim(start);
|
|
end = start + buffer->size;
|
|
if(start >= end) {
|
|
TSK_DEBUG_INFO("Empty buffer");
|
|
continue;
|
|
}
|
|
parse_buffer:
|
|
TSK_OBJECT_SAFE_FREE(cmd); /* Free old value */
|
|
cmd = cmd_parse(start, (end-start), &comment, ctx->params);
|
|
if(cmd) {
|
|
if(comment || cmd->type == cmd_none) {
|
|
goto nex_line;
|
|
}
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
|
|
/* Load from scenario file? */
|
|
if(cmd->type == cmd_scenario) {
|
|
FILE* file;
|
|
const opt_t* opt;
|
|
tsk_size_t read = 0;
|
|
tsk_bool_t rm_lf = tsk_false;
|
|
if((opt = opt_get_by_type(cmd->opts, opt_path)) && !tsk_strnullORempty(opt->value)) { /* --path option */
|
|
if((file = fopen(opt->value, "r"))) {
|
|
memset(cmdbuf, '\0', sizeof(cmdbuf)), cmdbuf[0] = '\n';
|
|
read = fread(cmdbuf+1, sizeof(uint8_t), sizeof(cmdbuf)-1, file);
|
|
fclose(file), file = tsk_null;
|
|
|
|
if(read == 0) {
|
|
TSK_DEBUG_ERROR("[%s] is empty.", opt->value);
|
|
goto nex_line;
|
|
}
|
|
else if(read == sizeof(cmdbuf)-1) {
|
|
TSK_DEBUG_ERROR("Buffer too short.");
|
|
|
|
goto nex_line;
|
|
}
|
|
read++; /* \n */
|
|
/* repplace all '\' with spaces (easier than handling that in the ragel file) */
|
|
for(i=0; ((tsk_size_t)i)<read; i++) {
|
|
if(cmdbuf[i] == '\\') {
|
|
cmdbuf[i] = ' ';
|
|
rm_lf = tsk_true;
|
|
}
|
|
else if(rm_lf && cmdbuf[i] == '\n') {
|
|
cmdbuf[i] = ' ';
|
|
rm_lf = tsk_false;
|
|
}
|
|
}
|
|
cmdbuf[read] = '\n';
|
|
|
|
/* insert embedded scenario */
|
|
if((index = tsk_strindexOf(start, (end-start), "\n")) == -1) { /* ++sn line */
|
|
index = buffer->size;
|
|
}
|
|
else {
|
|
index += (start - ((const char*)buffer->data));
|
|
}
|
|
|
|
if(tsk_buffer_insert(buffer, index, cmdbuf, read)) {
|
|
continue;
|
|
}
|
|
else {
|
|
start = ((const char*)buffer->data) + index; // because insert use realloc()
|
|
end = (((const char*)buffer->data) + buffer->size);
|
|
goto nex_line;
|
|
}
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("Failed to open scenario-file [%s].", opt->value);
|
|
goto nex_line;
|
|
}
|
|
continue;
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("++scenario command must have --path option.");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* execute current command */
|
|
switch(cmd->type) {
|
|
case cmd_exit:
|
|
TSK_DEBUG_INFO("Exit/Quit");
|
|
goto bail;
|
|
default:
|
|
ret = execute(cmd);
|
|
break;
|
|
}
|
|
|
|
/* next line */
|
|
nex_line:
|
|
if((index = tsk_strindexOf(start, (end - start), "\n")) !=-1) {
|
|
start += index;
|
|
while((start < end) && isspace(*start)) {
|
|
start ++;
|
|
}
|
|
if((start + 2/*++*/) < end) {
|
|
goto parse_buffer; /* next line */
|
|
}
|
|
else {
|
|
continue; /* wait for new commands */
|
|
}
|
|
}
|
|
} /* while(buffer) */
|
|
|
|
|
|
bail:
|
|
|
|
/* Free current command */
|
|
TSK_OBJECT_SAFE_FREE(cmd);
|
|
/* Free buffer */
|
|
TSK_OBJECT_SAFE_FREE(buffer);
|
|
/* Destroy the user's ctx */
|
|
TSK_OBJECT_SAFE_FREE(ctx);
|
|
/* Deinitialize Doubango Audio/Video Framework ==> will unregister all plugins(codecs and sessions)
|
|
* Not mandatory */
|
|
tdav_init();
|
|
/* Uninitilize Network Layer */
|
|
tnet_cleanup();
|
|
|
|
#if ANDROID
|
|
exit(0);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
const char* trim(const char* str)
|
|
{
|
|
while(isspace(*str)) {
|
|
str++;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
int update_param(const char* pname, const char* pvalue)
|
|
{
|
|
if(ctx->params && pname) {
|
|
const tsk_param_t* param;
|
|
if((param = tsk_params_get_param_by_name(ctx->params, pname))) {
|
|
tsk_strupdate(&TSK_PARAM(param)->value, pvalue);
|
|
return 0;
|
|
}
|
|
else {
|
|
TSK_DEBUG_INFO("[%s] parameter does not exist", pname);
|
|
}
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("Invalid parameter");
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int execute(const cmd_t* cmd)
|
|
{
|
|
int ret = 0;
|
|
tsip_ssession_id_t sid;
|
|
tsk_istr_t istr;
|
|
|
|
if(!cmd) {
|
|
TSK_DEBUG_ERROR("Invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
tsk_safeobj_lock(ctx);
|
|
|
|
switch(cmd->type) {
|
|
case cmd_audio:
|
|
case cmd_audiovideo: {
|
|
TSK_DEBUG_INFO("command=audio/video");
|
|
if((sid = invite_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_config_session: {
|
|
TSK_DEBUG_INFO("command=config-session");
|
|
break;
|
|
}
|
|
case cmd_config_stack: {
|
|
TSK_DEBUG_INFO("command=config-satck");
|
|
ret = stack_config(cmd->opts);
|
|
break;
|
|
}
|
|
case cmd_dtmf: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=dtmf");
|
|
if(!(opt = opt_get_by_type(cmd->opts, opt_sid)) || tsk_strnullORempty(opt->value)) { /* --sid option */
|
|
TSK_DEBUG_ERROR("++dtmf command need --sid option");
|
|
break;
|
|
}
|
|
if(!(opt = opt_get_by_type(cmd->opts, opt_event)) || tsk_strnullORempty(opt->value)) { /* --event option */
|
|
TSK_DEBUG_ERROR("++dtmf command need --event option");
|
|
break;
|
|
}
|
|
invite_handle_cmd(cmd->type, cmd->opts);
|
|
break;
|
|
}
|
|
case cmd_dump: {
|
|
TSK_DEBUG_INFO("command=dump");
|
|
ret = stack_dump();
|
|
break;
|
|
}
|
|
case cmd_ect: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=ect");
|
|
if((opt = opt_get_by_type(cmd->opts, opt_sid)) && !tsk_strnullORempty(opt->value)) {
|
|
TSK_DEBUG_ERROR("++ect command need --sid option");
|
|
ret = -1;
|
|
break;
|
|
}
|
|
if((opt = opt_get_by_type(cmd->opts, opt_to)) && !tsk_strnullORempty(opt->value)) {
|
|
TSK_DEBUG_ERROR("++ect command need --to option");
|
|
ret = -1;
|
|
break;
|
|
}
|
|
invite_handle_cmd(cmd->type, cmd->opts);
|
|
break;
|
|
}
|
|
case cmd_exit: {
|
|
TSK_DEBUG_INFO("command=exit");
|
|
goto bail;
|
|
break;
|
|
}
|
|
case cmd_file: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=file");
|
|
if(!(opt = opt_get_by_type(cmd->opts, opt_path)) || tsk_strnullORempty(opt->value)) {
|
|
TSK_DEBUG_ERROR("++file command need --path option");
|
|
break;
|
|
}
|
|
if((sid = invite_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_hangup: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=hangup");
|
|
if((opt = opt_get_by_type(cmd->opts, opt_sid)) && !tsk_strnullORempty(opt->value)) { /* --sid option */
|
|
ret = session_hangup(tsk_atoll(opt->value));
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("++hangup command need --sid option");
|
|
ret = -1;
|
|
}
|
|
break;
|
|
}
|
|
case cmd_help: {
|
|
TSK_DEBUG_INFO("command=help");
|
|
cmd_print_help();
|
|
break;
|
|
}
|
|
case cmd_hold: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=hold");
|
|
if((opt = opt_get_by_type(cmd->opts, opt_sid)) && !tsk_strnullORempty(opt->value)) { /* --sid option */
|
|
invite_handle_cmd(cmd->type, cmd->opts);
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("++hold command need --sid option");
|
|
ret = -1;
|
|
}
|
|
break;
|
|
}
|
|
case cmd_message: {
|
|
TSK_DEBUG_INFO("command=message");
|
|
if((sid = message_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case cmd_options: {
|
|
TSK_DEBUG_INFO("command=options");
|
|
if((sid = options_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_publish: {
|
|
TSK_DEBUG_INFO("command=publish");
|
|
if((sid = publish_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_register: {
|
|
TSK_DEBUG_INFO("command=register");
|
|
if((sid = register_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_resume: {
|
|
const opt_t* opt;
|
|
TSK_DEBUG_INFO("command=resume");
|
|
if((opt = opt_get_by_type(cmd->opts, opt_sid)) && !tsk_strnullORempty(opt->value)) { /* --sid option */
|
|
invite_handle_cmd(cmd->type, cmd->opts);
|
|
}
|
|
else {
|
|
TSK_DEBUG_ERROR("++resume command need --sid option");
|
|
ret = -1;
|
|
}
|
|
break;
|
|
}
|
|
case cmd_run: {
|
|
TSK_DEBUG_INFO("command=run");
|
|
ret = stack_run(cmd->opts);
|
|
break;
|
|
}
|
|
case cmd_scenario: {
|
|
TSK_DEBUG_INFO("command=scenario");
|
|
break;
|
|
}
|
|
case cmd_sleep: {
|
|
const opt_t* opt;
|
|
double seconds;
|
|
|
|
tsk_safeobj_unlock(ctx); /* beacuse of callback function */
|
|
|
|
if((opt = opt_get_by_type(cmd->opts, opt_sec)) && !tsk_strnullORempty(opt->value)) { /* --sec option */
|
|
seconds = strtod(opt->value, tsk_null); /* strtod() is better than atof() */
|
|
if(seconds<=0) {
|
|
printf("\n==== Press ENTER to continue...\n");
|
|
getchar();
|
|
}
|
|
else {
|
|
TSK_DEBUG_INFO("Sleeping %f seconds", seconds);
|
|
tsk_thread_sleep((uint64_t)(seconds * 1000));
|
|
}
|
|
}
|
|
else {
|
|
TSK_DEBUG_WARN("++sleep need --sec option.");
|
|
}
|
|
return 0; /* bail: will unlock again */
|
|
}
|
|
case cmd_sms: {
|
|
TSK_DEBUG_INFO("command=sms");
|
|
if((sid = message_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_stop: {
|
|
TSK_DEBUG_INFO("command=stop");
|
|
tsip_stack_stop(ctx->stack);
|
|
break;
|
|
}
|
|
case cmd_subscribe: {
|
|
TSK_DEBUG_INFO("command=subscribe");
|
|
if((sid = subscribe_handle_cmd(cmd->type, cmd->opts)) != TSIP_SSESSION_INVALID_ID) {
|
|
if(cmd->sidparam) {
|
|
tsk_itoa(sid, &istr);
|
|
update_param(cmd->sidparam, istr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case cmd_video: {
|
|
TSK_DEBUG_INFO("command=video");
|
|
break;
|
|
}
|
|
default: {
|
|
TSK_DEBUG_ERROR("%d not a valid command.", cmd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
bail:
|
|
tsk_safeobj_unlock(ctx);
|
|
|
|
return ret;
|
|
}
|