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); }