static int __pri_lpwrap_read(struct pri *pri, void *buf, int buflen)
{
struct lpwrap_pri *spri = (struct lpwrap_pri *) pri_get_userdata(pri);
ftdm_size_t len = buflen;
ftdm_status_t zst;
int res;
if ((zst = ftdm_channel_read(spri->dchan, buf, &len)) != FTDM_SUCCESS) {
if (zst == FTDM_FAIL) {
ftdm_log(FTDM_LOG_CRIT, "span %d D-READ FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error);
spri->errs++;
} else {
ftdm_log(FTDM_LOG_CRIT, "span %d D-READ TIMEOUT\n", spri->span->span_id);
}
/* we cannot return -1, libpri seems to expect values >= 0 */
return 0;
}
spri->errs = 0;
res = (int)len;
if (res > 0) {
memset(&((unsigned char*)buf)[res], 0, 2);
res += 2;
#ifdef IODEBUG
{
char bb[2048] = { 0 };
print_hex_bytes(buf, res - 2, bb, sizeof(bb));
ftdm_log(FTDM_LOG_DEBUG, "READ %d\n", res - 2);
}
#endif
}
return res;
}
static int pri_io_read(struct pri *pri, void *buf, int buflen)
{
int res;
ftdm_status_t zst;
pritap_t *pritap = pri_get_userdata(pri);
ftdm_size_t len = buflen;
if ((zst = ftdm_channel_read(pritap->dchan, buf, &len)) != FTDM_SUCCESS) {
if (zst == FTDM_FAIL) {
ftdm_log(FTDM_LOG_CRIT, "span %d D channel read fail! [%s]\n", pritap->span->span_id, pritap->dchan->last_error);
} else {
ftdm_log(FTDM_LOG_CRIT, "span %d D channel read timeout!\n", pritap->span->span_id);
}
return -1;
}
res = (int)len;
memset(&((unsigned char*)buf)[res],0,2);
res += 2;
/* libpri passive q921 raw dump does not work for all frames */
if (pritap->debug & PRI_DEBUG_Q921_RAW) {
char hbuf[2048] = { 0 };
print_hex_bytes(buf, len, hbuf, sizeof(hbuf));
ftdm_log_chan(pritap->dchan, FTDM_LOG_DEBUG, "READ %"FTDM_SIZE_FMT"\n%s\n", len, hbuf);
}
return res;
}
static int read_channel(ftdm_channel_t *ftdm_chan , const void *buf, int size)
{
ftdm_size_t outsize = size;
ftdm_status_t status = ftdm_channel_read(ftdm_chan, (void *)buf, &outsize);
if (FTDM_FAIL == status) {
return -1;
}
return (int)outsize;
}
static int __pri_sangoma_read(struct pri *pri, void *buf, int buflen)
{
struct sangoma_pri *spri = (struct sangoma_pri *) pri->userdata;
ftdm_size_t len = buflen;
int res;
char bb[4096] = "";
if (ftdm_channel_read(spri->zdchan, buf, &len) != FTDM_SUCCESS) {
printf("D-READ FAIL! [%s]\n", spri->zdchan->last_error);
return 0;
}
res = (int)len;
memset(&((unsigned char*)buf)[res],0,2);
res+=2;
//print_bits(buf, res-2, bb, sizeof(bb), 1, 0);
//ftdm_log(FTDM_LOG_DEBUG, "READ %d\n%s\n%s\n\n", res-2, LINE, bb);
return res;
}
static void *test_call(ftdm_thread_t *me, void *obj)
{
ftdm_channel_t *chan = (ftdm_channel_t *) obj;
uint8_t frame[1024];
ftdm_size_t len;
char *number = strdup("5551212");
ftdm_sleep(10 * 1000);
ftdm_log(FTDM_LOG_DEBUG, "answer call and start echo test\n");
ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_UP);
ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, number);
while (chan->state == FTDM_CHANNEL_STATE_UP) {
ftdm_wait_flag_t flags = FTDM_READ;
if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) {
break;
}
len = sizeof(frame);
if (flags & FTDM_READ) {
if (ftdm_channel_read(chan, frame, &len) == FTDM_SUCCESS) {
//ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", len);
ftdm_channel_write(chan, frame, sizeof(frame), &len);
} else {
break;
}
}
}
if (chan->state == FTDM_CHANNEL_STATE_UP) {
ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_BUSY);
}
ftdm_log(FTDM_LOG_DEBUG, "call over\n");
free(number);
return NULL;
}
int main(int argc, char *argv[])
{
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
ftdm_channel_t *chan;
unsigned ms = 20;
ftdm_codec_t codec = FTDM_CODEC_SLIN;
unsigned runs = 1;
int spanid, chanid;
ftdm_unused_arg(argc);
ftdm_unused_arg(argv);
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(-1);
}
printf("FreeTDM loaded\n");
top:
//if (ftdm_channel_open_any("wanpipe", 0, FTDM_TOP_DOWN, &chan) == FTDM_SUCCESS) {
if (ftdm_channel_open(1, 1, &chan) == FTDM_SUCCESS) {
int x = 0;
spanid = ftdm_channel_get_span_id(chan);
chanid = ftdm_channel_get_id(chan);
printf("opened channel %d:%d\n", spanid, chanid);
#if 1
if (ftdm_channel_command(chan, FTDM_COMMAND_SET_INTERVAL, &ms) == FTDM_SUCCESS) {
ms = 0;
ftdm_channel_command(chan, FTDM_COMMAND_GET_INTERVAL, &ms);
printf("interval set to %u\n", ms);
} else {
printf("set interval failed [%s]\n", ftdm_channel_get_last_error(chan));
}
#endif
if (ftdm_channel_command(chan, FTDM_COMMAND_SET_CODEC, &codec) == FTDM_SUCCESS) {
codec = 1;
ftdm_channel_command(chan, FTDM_COMMAND_GET_CODEC, &codec);
printf("codec set to %u\n", codec);
} else {
printf("set codec failed [%s]\n", ftdm_channel_get_last_error(chan));
}
for(x = 0; x < 25; x++) {
unsigned char buf[2048];
ftdm_size_t len = sizeof(buf);
ftdm_wait_flag_t flags = FTDM_READ;
if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) {
printf("wait FAIL! %u [%s]\n", (unsigned)len, ftdm_channel_get_last_error(chan));
}
if (flags & FTDM_READ) {
if (ftdm_channel_read(chan, buf, &len) == FTDM_SUCCESS) {
printf("READ: %u\n", (unsigned)len);
} else {
printf("READ FAIL! %u [%s]\n", (unsigned)len, ftdm_channel_get_last_error(chan));
break;
}
} else {
printf("wait fail [%s]\n", ftdm_channel_get_last_error(chan));
}
}
ftdm_channel_close(&chan);
} else {
printf("open fail [%s]\n", ftdm_channel_get_last_error(chan));
}
if(--runs) {
goto top;
}
ftdm_global_destroy();
return 0;
}
static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
ftdm_wait_flag_t wflags = FTDM_READ;
ftdm_status_t status;
ctdm_private_t *tech_pvt;
const char *name;
switch_channel_t *channel;
int chunk;
uint32_t span_id, chan_id;
ftdm_size_t len;
char dtmf[128] = "";
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
name = switch_channel_get_name(channel);
top:
wflags = FTDM_READ;
chunk = ftdm_channel_get_io_interval(tech_pvt->ftdm_channel) * 2;
status = ftdm_channel_wait(tech_pvt->ftdm_channel, &wflags, chunk);
span_id = ftdm_channel_get_span_id(tech_pvt->ftdm_channel);
chan_id = ftdm_channel_get_id(tech_pvt->ftdm_channel);
if (status == FTDM_FAIL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to read from channel %s device %d:%d!\n", name, span_id, chan_id);
goto fail;
}
if (status == FTDM_TIMEOUT) {
goto top;
}
if (!(wflags & FTDM_READ)) {
goto top;
}
len = tech_pvt->read_frame.buflen;
if (ftdm_channel_read(tech_pvt->ftdm_channel, tech_pvt->read_frame.data, &len) != FTDM_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to read from channel %s device %d:%d!\n", name, span_id, chan_id);
}
*frame = &tech_pvt->read_frame;
tech_pvt->read_frame.datalen = (uint32_t)len;
tech_pvt->read_frame.samples = tech_pvt->read_frame.datalen;
tech_pvt->read_frame.codec = &tech_pvt->read_codec;
if (ftdm_channel_get_codec(tech_pvt->ftdm_channel) == FTDM_CODEC_SLIN) {
tech_pvt->read_frame.samples /= 2;
}
while (ftdm_channel_dequeue_dtmf(tech_pvt->ftdm_channel, dtmf, sizeof(dtmf))) {
switch_dtmf_t _dtmf = { 0, switch_core_default_dtmf_duration(0) };
char *p;
for (p = dtmf; p && *p; p++) {
if (is_dtmf(*p)) {
_dtmf.digit = *p;
ftdm_log(FTDM_LOG_DEBUG, "Queuing DTMF [%c] in channel %s device %d:%d\n", *p, name, span_id, chan_id);
switch_channel_queue_dtmf(channel, &_dtmf);
}
}
}
return SWITCH_STATUS_SUCCESS;
fail:
return SWITCH_STATUS_GENERR;
}
static void launch_channel(struct sangoma_pri *spri, int channo)
{
pid_t pid;
int fd = 0, file = 0, inlen = 0, outlen = 0;
unsigned char inframe[MAX_BYTES], outframe[MAX_BYTES];
fd_set readfds;
int mtu_mru=BYTES / 2;
int err;
ftdm_channel_t *chan;
ftdm_codec_t codec = FTDM_CODEC_SLIN;
unsigned ms = 20;
unsigned int lead = 50;
int ifd = -1;
ftdm_tone_type_t tt = FTDM_TONE_DTMF;
char dtmf[] = "1234567890";
int loops = 0;
pid = fork();
if (pid) {
pidmap[channo-1].pid = pid;
printf("-- Launching process %d to handle channel %d\n", pid, channo);
return;
}
signal(SIGINT, handle_SIGINT);
//ifd = open("/nfs/sounds/ptest.raw", O_WRONLY|O_CREAT|O_TRUNC, 777);
memset(inframe, 0, MAX_BYTES);
memset(outframe, 0, MAX_BYTES);
if (ftdm_channel_open(spri->span, channo, &chan) != FTDM_SUCCESS) {
printf("DEBUG cant open fd!\n");
}
#if 1
if (ftdm_channel_command(chan, FTDM_COMMAND_SET_CODEC, &codec) != FTDM_SUCCESS) {
printf("Critical Error: Failed to set driver codec!\n");
ftdm_channel_close(&chan);
exit(-1);
}
#endif
#if 1
if (ftdm_channel_command(chan, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) {
printf("Critical Error: Failed to set dtmf detect!\n");
ftdm_channel_close(&chan);
exit(-1);
}
ftdm_channel_set_event_callback(chan, my_ftdm_event_handler);
#endif
if (ftdm_channel_command(chan, FTDM_COMMAND_SET_INTERVAL, &ms) != FTDM_SUCCESS) {
printf("Critical Error: Failed to set codec interval!\n");
ftdm_channel_close(&chan);
exit(-1);
}
file = open("sound.raw", O_RDONLY);
if (file < 0) {
printf("Critical Error: Failed to open sound file!\n");
ftdm_channel_close(&chan);
exit(-1);
}
while(ready) {
ftdm_wait_flag_t flags = FTDM_READ;
ftdm_size_t len;
loops++;
if (lead) {
lead--;
}
if (!lead && loops == 300) {
#if 1
if (ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, dtmf) != FTDM_SUCCESS) {
printf("Critical Error: Failed to send dtmf\n");
ftdm_channel_close(&chan);
exit(-1);
}
#endif
}
if (ftdm_channel_wait(chan, &flags, 2000) != FTDM_SUCCESS) {
printf("wait FAIL! [%s]\n", chan->last_error);
break;
}
if (flags & FTDM_READ) {
len = MAX_BYTES;
if (ftdm_channel_read(chan, inframe, &len) == FTDM_SUCCESS) {
//printf("READ: %d\n", len);
//write(ifd, inframe, len);
if(!lead && (outlen = read(file, outframe, len)) <= 0) {
break;
}
} else {
printf("READ FAIL! %d [%s]\n", len, chan->last_error);
break;
}
if (lead) {
continue;
}
ftdm_channel_write(chan, outframe, sizeof(outframe), &len);
} else {
printf("BREAK");
break;
}
}
printf("loop done\n");
//sangoma_get_full_cfg(fd, &tdm_api);
close(file);
//close(ifd);
pri_hangup(spri->pri, channo, 16);
if (ftdm_channel_close(&chan) != FTDM_SUCCESS) {
printf("Critical Error: Failed to close channel [%s]\n", chan->last_error);
}
printf("Call Handler: Process Finished\n");
exit(0);
}
