Example #1
0
int
sandbox_init(sandbox_t * psbox, const char * argv[])
{
    FUNC_BEGIN("sandbox_init(%p,%p)", psbox, argv);

    assert(psbox);

    if (psbox == NULL)
    {
        WARNING("psbox: bad pointer");
        FUNC_RET(-1, "sandbox_init()");
    }

    pthread_mutex_init(&psbox->mutex, NULL);
    P(&psbox->mutex);
    pthread_cond_init(&psbox->update, NULL);
    __sandbox_task_init(&psbox->task, argv);
    __sandbox_stat_init(&psbox->stat);
    __sandbox_ctrl_init(&psbox->ctrl, (thread_func_t)__sandbox_tracer,
#ifdef WITH_CUSTOM_MONITOR
                                      (thread_func_t)__sandbox_monitor
#else
                                      (thread_func_t)(NULL)
#endif /* WITH_CUSTOM_MONITOR */
);
    V(&psbox->mutex);

    P(&psbox->mutex);
    psbox->result = S_RESULT_PD;
    psbox->status = S_STATUS_PRE;
    pthread_cond_broadcast(&psbox->update);
    V(&psbox->mutex);

    FUNC_RET(0, "sandbox_init()");
}
Example #2
0
int
sandbox_fini(sandbox_t * psbox)
{
    FUNC_BEGIN("sandbox_fini(%p)", psbox);

    assert(psbox);

    if (psbox == NULL)
    {
        WARNING("psbox: bad pointer");
        FUNC_RET(-1, "sandbox_fini()");
    }

    P(&psbox->mutex);
    psbox->result = S_RESULT_PD;
    psbox->status = S_STATUS_FIN;
    pthread_cond_broadcast(&psbox->update);
    V(&psbox->mutex);

    P(&psbox->mutex);
    __sandbox_task_fini(&psbox->task);
    __sandbox_stat_fini(&psbox->stat);
    __sandbox_ctrl_fini(&psbox->ctrl);
    pthread_cond_destroy(&psbox->update);
    V(&psbox->mutex);
    pthread_mutex_destroy(&psbox->mutex);

    FUNC_RET(0, "sandbox_fini()");
}
Example #3
0
int32_t fs_opr_t::subscribe_event(const char* event) {
    FUNC_BEGIN();

    (void)szcmd;
    (void)fs_resp;

    if (esl_events(&_handle, ESL_EVENT_TYPE_PLAIN, event) == ESL_SUCCESS) {
        TRACE_LOG("subscribe_event %s success", event);
        ret = IMS_SUCCESS;
        break;
    } else {
        WARNING_LOG("subscribe_event %s failed(connect err)", event);
        ims_tool_t::safe_sleepms(20);
    }

    /*
    if(is_handle_valid()){
        ret=IMS_FAIL_TIMEOUT;
        break;
    }
    else if(IMS_SUCCESS!=connect(_address,_port,_pswd,true)){
        WARNING_LOG("subscribe_event %s failed(connect err)",event);
        ret=IMS_FAIL_CONNECT;
        break;
    }
    */

    FUNC_END();
}
Example #4
0
int32_t fs_opr_t::eval(const char* key, char* val, uint32_t val_len) {
    FUNC_BEGIN();
    snprintf(szcmd, LEN_512, "api eval %s\n\n", key);
    TRACE_LOG("eval, (%s)", szcmd);

    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS
            && (fs_resp = esl_event_get_body(_handle.last_sr_event))) {
        strncpy(val, fs_resp, val_len);

        fs_resp = val;

        while (fs_resp && *fs_resp && (fs_resp - val) < val_len) {
            if ('\n' == *fs_resp || '\r' == *fs_resp) {
                val[fs_resp - val] = '\0';
                break;
            }

            ++fs_resp;
        }

        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs_eval(%s) failed", key);
    }

    FUNC_END();
}
Example #5
0
int32_t fs_opr_t::bridge(const char* uuid, const char* called_disp, const char* dnis) {
    FUNC_BEGIN();

    if (set_channel_attribute(uuid, "bridge_early_media=true")
            && set_channel_attribute(uuid, "hangup_after_bridge=false")
            && set_channel_attribute(uuid, "bypass_media=false")
            && set_channel_attribute(uuid, "playback_terminators=none")
            && set_channel_attribute(uuid, "continue_on_fail=true")) {
        set_channel_attribute(uuid, "export_vars=IMSDATA");
        snprintf(szcmd, LEN_512, "effective_caller_id_name=%s", called_disp);
        set_channel_attribute(uuid, szcmd);
        snprintf(szcmd, LEN_512, "effective_caller_id_number=%s", called_disp);
        set_channel_attribute(uuid, szcmd);

        if (esl_execute(&_handle, "bridge", dnis, uuid) == ESL_SUCCESS &&
                is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
            ret = IMS_SUCCESS;
            break;
        } else {
            WARNING_LOG("fs:bridge(%s,%s,%s);ret(%s)", uuid, called_disp, dnis, fs_resp);
        }

    }

    FUNC_END();
}
Example #6
0
int32_t fs_opr_t::get_var(const char* key, char* val, uint32_t val_len) {
    FUNC_BEGIN();
    (void)fs_resp;
    snprintf(szcmd, LEN_512, "variable_%s", key);
    ret = get_head_val(szcmd, val, val_len);
    FUNC_END();
}
Example #7
0
int32_t fs_opr_t::record(const char* uuid, const char* file, uint32_t time_s) {
    FUNC_BEGIN();

    std::string full_file = _recordbase;
    full_file += "/";
    full_file += file;

    TRACE_LOG("fs::record(%s) start.", full_file.c_str());
    //set_channel_attribute(uuid,"playback_terminators=none");
    //set_channel_attribute(uuid,"RECORD_HANGUP_ON_ERROR=false");//1.0.7的fs才有
    //set_channel_attribute(uuid,"RECORD_MIN_SEC=0");

    //TRACE_LOG("fs::record(%s) middle.",full_file.c_str());
    snprintf(szcmd, LEN_512, CMD_RECORD_FMT, uuid, full_file.c_str(), time_s);

    //if(esl_send_recv(&_handle,szcmd)==ESL_SUCCESS){
    //    if(is_result_ok(fs_resp=esl_event_get_body(_handle.last_sr_event))){
    //        ret=IMS_SUCCESS;
    //    }
    //    else{
    //        WARNING_LOG("fs:record(%s,%s,%u);ret(%s)",uuid,full_file.c_str(),time_s,fs_resp);
    //    }
    //}
    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS &&
            is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs:record(%s,%s,%u) esl_send_recv != ESL_SUCCESS", uuid, full_file.c_str(), time_s);
    }

    //TRACE_LOG("fs::record(%s) done.",full_file.c_str());

    FUNC_END();
}
Example #8
0
bool
proc_dump(const proc_t * const pproc, const void * const addr, 
          long * const pword)
{
    FUNC_BEGIN("%p,%p,%p", pproc, addr, pword);
    assert(pproc && addr && pword);
    
    if ((pproc == NULL) || (addr == NULL) || (pword == NULL))
    {
        FUNC_RET("%d", false);
    }
    
    trace_proxy_t __trace = TRACE_PROXY(pproc);
    
    long data = (long)addr;
    if (__trace(T_GETDATA, &data, (proc_t *)pproc) != 0)
    {
        FUNC_RET("%d", false);
    }
    
    *pword = data;
    
#ifdef DELETED
#ifdef HAVE_PROCFS
    /* Access the memory of targeted process via procfs */
    char buffer[4096];

    sprintf(buffer, PROCFS "/%d/mem", pproc->pid);
    if (access(buffer, R_OK | F_OK) < 0)
    {
        WARNING("procfs entries missing or invalid");
        FUNC_RET("%d", false);
    }

    /* Copy a word from targeted address */
    int fd = open(buffer, O_RDONLY);
    if (lseek(fd, (off_t)addr, SEEK_SET) < 0)
    {
        extern int errno;
        WARNING("lseek(%d, %p, SEEK_SET) failes, ERRNO %d", fd, addr, errno);
        FUNC_RET("%d", false);
    }
    if (read(fd, (void *)pword, sizeof(unsigned long)) < 0)
    {
        WARNING("read");
        FUNC_RET("%d", false);
    }
    close(fd);
#else
#warning "proc_dump() requires procfs"
#endif /* HAVE_PROCFS */
#endif /* DELETED */

    DBG("data.%p     0x%016lx", addr, *pword);

    FUNC_RET("%d", true);
}
Example #9
0
static long
__trace_req(act_t action, long * const pdata, proc_t * const pproc)
{
    FUNC_BEGIN("%d,%p,%p", action, pdata, pproc);
    assert(!NO_ACTION(action));
    assert(pproc);
    
    long res = 0;
    
    P(&trace_mutex);
    
    /* Wait while an existing action is being performed */
    while (trace_info.action != T_NOP)
    {
        DBG("waiting for slot");
        pthread_cond_wait(&trace_notice, &trace_mutex);
    }
    
    DBG("obtained slot");
    
    /* Propose the request */
    trace_info.action = action;
    trace_info.pproc = pproc;
    trace_info.data = ((pdata != NULL)?(*pdata):(0));
    trace_info.result = 0;
    
    /* Wait while the action is being performed */
    while (trace_info.action != T_ACK)
    {
        DBG("requesting action %s", trace_act_name(trace_info.action));
        pthread_cond_broadcast(&trace_notice);
        pthread_cond_wait(&trace_notice, &trace_mutex);
    }
    
    if (pdata != NULL)
    {
        *pdata = trace_info.data;
    }
    res = trace_info.result;
    
    DBG("collected results");
    
    /* Release slot */
    trace_info.action = T_NOP;
    trace_info.pproc = NULL;
    trace_info.data = 0;
    trace_info.result = 0;
    pthread_cond_broadcast(&trace_notice);
    
    DBG("released slot");
    
    V(&trace_mutex);
    
    FUNC_RET("%ld", res);
}
Example #10
0
bool
proc_dump(const proc_t * const pproc, const void * const addr,
          long * const pword)
{
    FUNC_BEGIN("proc_dump(%p,%p,%p)", pproc, addr, pword);

    assert(pproc);
    assert(addr);
    assert(pword);

#ifdef __linux__
    /* Current instruction */
    *pword = ptrace(PTRACE_PEEKDATA, pproc->pid, addr, NULL);

    if (errno != 0)
    {
        WARNING("ptrace:PTRACE_PEEKDATA");
        FUNC_RET(false, "proc_dump()");
    }
#else
#warning "proc_dump is not implemented for this platform"
#endif

#ifdef DELETED
    /* Access the memory of targeted process via procfs */
    char buffer[4096];

    sprintf(buffer, PROCFS "/%d/mem", pproc->pid);
    if (access(buffer, R_OK | F_OK) < 0)
    {
        WARNING("procfs entries missing or invalid");
        FUNC_RET(false, "proc_dump()");
    }

    /* Copy a word from targeted address */
    int fd = open(buffer, O_RDONLY);
    if (lseek(fd, (off_t)addr, SEEK_SET) < 0)
    {
        extern int errno;
        WARNING("lseek(%d, %p, SEEK_SET) failes, ERRNO %d", fd, addr, errno);
        FUNC_RET(false, "proc_dump()");
    }
    if (read(fd, (void *)pword, sizeof(unsigned long)) < 0)
    {
        WARNING("read");
        FUNC_RET(false, "proc_dump()");
    }
    close(fd);
#endif /* DELETED */

    DBG("data.%p     0x%08lx", addr, *pword);

    FUNC_RET(true, "proc_dump()");
}
Example #11
0
bool
trace_end(const proc_t * const pproc)
{
    FUNC_BEGIN("%p", pproc);
    assert(pproc);
    
    trace_proxy_t __trace = TRACE_PROXY(pproc);
    bool res = (__trace(T_END, NULL, (proc_t *)pproc) == 0);
    
    FUNC_RET("%d", res);
}
Example #12
0
bool
trace_hack(proc_t * const pproc)
{
    FUNC_BEGIN("%p", pproc);
    assert(pproc);
    
    trace_proxy_t __trace = TRACE_PROXY(pproc);
    
    bool res = (__trace(T_SETREGS, NULL, pproc) == 0);
    
    FUNC_RET("%d", res);
}
Example #13
0
bool
trace_self(void)
{
    FUNC_BEGIN("trace_self()");
    bool res = false;
    #ifdef __linux__
    res = (ptrace(PTRACE_TRACEME, 0, NULL, NULL) == 0);
    #else
    #warning "trace_self is not implemented for this platform"
    #endif /* __linux__ */
    FUNC_RET(res, "trace_self()");
}
Example #14
0
int32_t fs_opr_t::mark_sessionid(const char* uuid, uint64_t sid) {
    FUNC_BEGIN();
    snprintf(szcmd, LEN_512, "IMSDATA=%lu", sid);

    if (set_channel_attribute(uuid, szcmd)
            && is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs_opr:mark_sessionid(%s,%lu);ret(%s)", uuid, sid, fs_resp);
    }

    FUNC_END();
}
Example #15
0
int32_t fs_opr_t::conference(const char* uuid, const char* name) {
    FUNC_BEGIN();
    (void)szcmd;

    if (esl_execute(&_handle, "conference", name, uuid) == ESL_SUCCESS
            && is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs:conference(%s,%s);ret(%s)", uuid, name, fs_resp);
    }

    FUNC_END();
}
Example #16
0
bool
trace_kill(proc_t * const pproc, int signo)
{
    FUNC_BEGIN("%p,%d", pproc, signo);
    assert(pproc);
    
    trace_proxy_t __trace = TRACE_PROXY(pproc);
    
    long data = (long)(signo);
    bool res = (__trace(T_KILL, &data, (proc_t *)pproc) == 0);
    
    FUNC_RET("%d", res);
}
Example #17
0
bool
trace_next(proc_t * const pproc, trace_type_t type)
{
    FUNC_BEGIN("%p,%d", pproc, type);
    assert(pproc);
    
    trace_proxy_t __trace = TRACE_PROXY(pproc);
    
    long data = (long)type;
    bool res = (__trace(T_NEXT, &data, pproc) == 0);
    
    FUNC_RET("%d", res);
}
Example #18
0
/////////////////////////////////////媒体START/////////////////////////////////////////////////
int32_t fs_opr_t::stop_media(const char* uuid) {
    FUNC_BEGIN();
    (void)szcmd;

    if (esl_execute(&_handle, "break", NULL, uuid) == ESL_SUCCESS
            && is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs:stop_media(%s);ret(%s)", uuid, fs_resp);
    }

    FUNC_END();
}
Example #19
0
//=============================
// MotorTest
//
// Turn a motor connected to port 
// armPort at a speed of armSpeed
// for waitTime seconds
//=============================
void MotorTest( int portNum, int motorSpeed, float waitTime ) {
	FUNC_BEGIN("MotorTest");

	if (waitTime < 1)
                printf("WARNING: waitTime is lower than 1 second: %f\n", waitTime);
	
	Motor(portNum, motorSpeed);

	wait( waitTime );

	Motor(portNum, MOTOR_OFF);
	
	FUNC_END("MotorTest");
}
Example #20
0
bool
trace_self(void)
{
    FUNC_BEGIN();
    
    bool res = false;
#ifdef HAVE_PTRACE
    res = (ptrace(PTRACE_TRACEME, 0, NULL, NULL) == 0);
#else
#warning "trace_self() is not implemented for this platform"
#endif /* HAVE_PTRACE */
    
    FUNC_RET("%d", res);
}
Example #21
0
int32_t fs_opr_t::unbridge(const char* uuid) {
    FUNC_BEGIN();
    snprintf(szcmd, LEN_512, CMD_UNBRIDGE_FMT, uuid);
    TRACE_LOG("unbridge(%s)", szcmd);

    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS) {
        if (is_result_ok(fs_resp = esl_event_get_body(_handle.last_sr_event))) {
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("fs:unbridge(%s);ret(%s)", uuid, fs_resp);
        }
    }

    FUNC_END();
}
Example #22
0
int32_t fs_opr_t::play(const char* uuid, const char* file, uint32_t count) {
    FUNC_BEGIN();
    (void)szcmd;

    if (set_channel_attribute(uuid, "playback_terminators=none")
            && esl_execute(&_handle, "playback", file, uuid) == ESL_SUCCESS
            && is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
        ret = IMS_SUCCESS;
        TRACE_LOG("fs:play(%s,%s,%u) success.", uuid, file, count);
    } else {
        WARNING_LOG("fs:play(%s,%s,%u);ret(%s)", uuid, file, count, fs_resp);
    }

    FUNC_END();
}
Example #23
0
bool
proc_bind(const void * const dummy, proc_t * const pproc)
{
    FUNC_BEGIN("%p,%p", dummy, pproc);
    assert(dummy && pproc);
    
    if ((dummy == NULL) || (pproc == NULL))
    {
        FUNC_RET("%d", false);
    }
    
    pproc->tflags.trace_id = ((sandbox_t *)dummy)->ctrl.tid;
    
    FUNC_RET("%d", true);
}
Example #24
0
int32_t fs_opr_t::conference_mute(const char* name, const char* member) {
    FUNC_BEGIN();

    snprintf(szcmd, LEN_512, "api conference %s mute %s\n\n", name, member);
    TRACE_LOG("conference_mute(%s)", szcmd);

    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS) {
        if (is_result_ok(fs_resp = esl_event_get_body(_handle.last_sr_event))) {
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("fs:conference_mute (%s,%s);ret(%s)", name, member, fs_resp);
        }
    }

    FUNC_END();
}
Example #25
0
bool 
trace_next(proc_t * const pproc, trace_type_t type)
{
    FUNC_BEGIN("trace_next(%p,%d)", pproc, type);
    assert(pproc);
    bool res = false;
    #ifdef __linux__
    pproc->tflags &= ~TFLAGS_SINGLE_STEP;
    pproc->tflags |= (type == TRACE_SINGLE_STEP)?(TFLAGS_SINGLE_STEP):(0U);
    DBG("proc.tflags         0x%08x", pproc->tflags);
    res = (ptrace(type, pproc->pid, NULL, NULL) == 0);
    #else
    #warning "trace_next is not implemented for this platform"
    #endif /* __linux__ */
    FUNC_RET(res, "trace_next()");
}
Example #26
0
int32_t fs_opr_t::bridge_ex(const char* uuid, const char* called_disp, const char* dnis,
                            bool isAsync, bool return_ring_ready) {
    FUNC_BEGIN();

    if (set_channel_attribute(uuid, "bridge_early_media=true")
            && set_channel_attribute(uuid, "hangup_after_bridge=false")
            && set_channel_attribute(uuid, "bypass_media=false")
            && set_channel_attribute(uuid, "playback_terminators=none")
            && set_channel_attribute(uuid, "continue_on_fail=true")) {
        set_channel_attribute(uuid, "export_vars=IMSDATA");
        snprintf(szcmd, LEN_512, "effective_caller_id_name=%s", called_disp);
        set_channel_attribute(uuid, szcmd);
        snprintf(szcmd, LEN_512, "effective_caller_id_number=%s", called_disp);
        set_channel_attribute(uuid, szcmd);

        //char param[LEN_512+1]={0};
        //snprintf(param, LEN_512, "[return_ring_ready=%s]%s", return_ring_ready ? "true" : "false", dnis);

        esl_status_t esl_ret = ESL_GENERR;

        TRACE_LOG("before bridge %s", isAsync ? "async" : "sync");

        if (isAsync) {
            int async = _handle.async_execute;
            _handle.async_execute = 1;
            esl_ret = esl_execute(&_handle, "bridge", dnis, uuid);
            _handle.async_execute = async;
        } else {
            esl_ret = esl_execute(&_handle, "bridge", dnis, uuid);
        }

        TRACE_LOG("after bridge %s", isAsync ? "async" : "sync");

        if (esl_ret == ESL_SUCCESS &&
                is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
            ret = IMS_SUCCESS;
            break;
        } else {
            WARNING_LOG("fs:bridge(%s,%s,%s,%s);ret(%s)", uuid, called_disp, dnis, fs_resp,
                        isAsync ? "async" : "sync");
        }

    }

    FUNC_END();
}
Example #27
0
int32_t fs_opr_t::send_dtmf(const char* uuid, const char* keys) {
    FUNC_BEGIN();
    (void)szcmd;

    //snprintf(szcmd,LEN_512,CMD_UUIDSENDDTMF_FMT,uuid,keys);
    //TRACE_LOG("send_dtmf(%s)",szcmd);
    //if(esl_send_recv(&_handle,szcmd)==ESL_SUCCESS){
    if (esl_execute(&_handle, "send_dtmf", keys, uuid) == ESL_SUCCESS
            && is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {

        ret = IMS_SUCCESS;
    } else {
        WARNING_LOG("fs:send_dtmf(%s,%s);ret(%s)", uuid, keys, fs_resp);
    }

    FUNC_END();
}
Example #28
0
//============================
// MotorTestMultiple
//
// Test every motor connected on 
// startPort to (startPort + numMotors - 1)
//============================
void MotorTestMultiple( int startPort, int numMotors, int motorSpeed, float waitTime ) {
	int i;

	FUNC_BEGIN("MotorTestMultiple");

	if (waitTime < 1)
		printf("WARNING: waitTime is lower than 1 second: %f\n", waitTime);

	for (i = 0; i < numMotors; i++)
		Motor(startPort + i, motorSpeed);

	wait( waitTime );

	for (i = 0; i < numMotors; i++)
		Motor(startPort + i,  MOTOR_OFF);

	FUNC_END("MotorTestMultiple");
}
Example #29
0
int32_t fs_opr_t::join_conference(const char* name, const char* dest_disp, const char* destno,
                                  CONF_MODE mode, uint64_t sessionid) {
    FUNC_BEGIN();
    snprintf(szcmd, LEN_512, CMD_JOINCONFERENCE_FMT, dest_disp, dest_disp, sessionid, destno, name,
             ((CONF_LISTEN == mode) ? "+flags{mute}" : ""));
    TRACE_LOG("join_conference(%s)", szcmd);

    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS) {
        if (is_result_ok(fs_resp = esl_event_get_header(_handle.last_sr_event, "Reply-Text"))) {
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("fs:join_conference(%s,%s,%s,%u,%lu);ret(%s)", name, dest_disp, destno, mode, sessionid,
                        fs_resp);
        }
    }

    FUNC_END();
}
Example #30
0
int32_t fs_opr_t::unjoin_conference(const char* name, const char* uuid) {
    FUNC_BEGIN();

    snprintf(szcmd, LEN_512,
             "api uuid_transfer %s -aleg 'set:hangup_after_bridge=false,set:park_after_bridge=true,park:' inline \n\n",
             uuid);
    TRACE_LOG("unjoin_conference(%s)", szcmd);

    if (esl_send_recv(&_handle, szcmd) == ESL_SUCCESS) {
        if (is_result_ok(fs_resp = esl_event_get_body(_handle.last_sr_event))) {
            ret = IMS_SUCCESS;
        } else {
            WARNING_LOG("fs:unjoin_conference(%s,%s);ret(%s)", name, uuid, fs_resp);
        }
    }

    FUNC_END();
}