int on_wat_span_write(unsigned char span_id, void *buffer, unsigned len) { #if LOG_SIG_DATA fprintf(stdout, " Out Data ====================>>> %s \r\n (%d) - %d\n", (char *)buffer, len, (int) span_id); #endif ftdm_span_t *span = NULL; ftdm_status_t status = FTDM_FAIL; ftdm_gsm_span_data_t *gsm_data = NULL; ftdm_size_t outsize = len; status = ftdm_span_find(span_id, &span); if (status != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Failed to find span %d to write %d bytes\n", span_id, len); return -1; } gsm_data = span->signal_data; status = ftdm_channel_write(gsm_data->dchan, (void *)buffer, len, &outsize); if (status != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Failed to write %d bytes to d-channel in span %s\n", len, span->name); return -1; } //#if LOG_SIG_DATA // fprintf(stdout, "\r\n==================== len=%d outsize=%d \r\n", len, (int)outsize); //#endif fflush(stdout); return len; }
int lpwrap_init_bri(struct lpwrap_pri *spri, ftdm_span_t *span, ftdm_channel_t *dchan, int swtype, int node, int ptp, int debug) { int ret = -1; #ifdef HAVE_LIBPRI_BRI memset(spri, 0, sizeof(struct lpwrap_pri)); spri->dchan = dchan; spri->span = span; if (!spri->dchan) { ftdm_log(FTDM_LOG_ERROR, "No D-Channel available, unable to create BRI\n"); return ret; } if ((spri->pri = pri_new_bri_cb(spri->dchan->sockfd, ptp, node, swtype, __pri_lpwrap_read, __pri_lpwrap_write, spri))) { unsigned char buf[4] = { 0 }; size_t buflen = sizeof(buf), len = 0; pri_set_debug(spri->pri, debug); #ifdef HAVE_LIBPRI_AOC pri_aoc_events_enable(spri->pri, 1); #endif ftdm_channel_write(spri->dchan, buf, buflen, &len); ret = 0; } else { ftdm_log(FTDM_LOG_ERROR, "Unable to create BRI\n"); } #else ftdm_log(FTDM_LOG_ERROR, "Installed libpri version (%s) has no BRI support\n", pri_get_version()); #endif return ret; }
static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id) { ftdm_wait_flag_t wflags = FTDM_WRITE; ctdm_private_t *tech_pvt; const char *name; switch_channel_t *channel; uint32_t span_id, chan_id; ftdm_size_t len; unsigned char data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0}; channel = switch_core_session_get_channel(session); assert(channel != NULL); tech_pvt = switch_core_session_get_private(session); assert(tech_pvt != NULL); span_id = ftdm_channel_get_span_id(tech_pvt->ftdm_channel); chan_id = ftdm_channel_get_id(tech_pvt->ftdm_channel); name = switch_channel_get_name(channel); if (switch_test_flag(frame, SFF_CNG)) { frame->data = data; frame->buflen = sizeof(data); if ((frame->datalen = tech_pvt->write_codec.implementation->encoded_bytes_per_packet) > frame->buflen) { goto fail; } memset(data, 255, frame->datalen); } wflags = FTDM_WRITE; ftdm_channel_wait(tech_pvt->ftdm_channel, &wflags, ftdm_channel_get_io_interval(tech_pvt->ftdm_channel) * 10); if (!(wflags & FTDM_WRITE)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Dropping frame! (write not ready) in channel %s device %d:%d!\n", name, span_id, chan_id); return SWITCH_STATUS_SUCCESS; } len = frame->datalen; if (ftdm_channel_write(tech_pvt->ftdm_channel, frame->data, frame->buflen, &len) != FTDM_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Failed to write to channel %s device %d:%d!\n", name, span_id, chan_id); } return SWITCH_STATUS_SUCCESS; fail: return SWITCH_STATUS_GENERR; }
static int __pri_sangoma_write(struct pri *pri, void *buf, int buflen) { struct sangoma_pri *spri = (struct sangoma_pri *) pri->userdata; int res; ftdm_size_t len = buflen -2; char bb[4096] = ""; if (ftdm_channel_write(spri->zdchan, buf, buflen, &len) != FTDM_SUCCESS) { printf("D-WRITE FAIL! [%s]\n", spri->zdchan->last_error); return 0; } //print_bits(buf, (int)buflen-2, bb, sizeof(bb), 1, 0); //ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)buflen-2, LINE, bb); return (int) buflen; }
static int pri_io_write(struct pri *pri, void *buf, int buflen) { pritap_t *pritap = pri_get_userdata(pri); ftdm_size_t len = buflen - 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, "WRITE %"FTDM_SIZE_FMT"\n%s\n", len, hbuf); } if (ftdm_channel_write(pritap->dchan, buf, buflen, &len) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_CRIT, "span %d D channel write failed! [%s]\n", pritap->span->span_id, pritap->dchan->last_error); return -1; } return (int)buflen; }
static int __pri_lpwrap_write(struct pri *pri, void *buf, int buflen) { struct lpwrap_pri *spri = (struct lpwrap_pri *) pri_get_userdata(pri); ftdm_size_t len = buflen - 2; if (ftdm_channel_write(spri->dchan, buf, buflen, &len) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_CRIT, "span %d D-WRITE FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); /* we cannot return -1, libpri seems to expect values >= 0 */ return 0; } #ifdef IODEBUG { char bb[2048] = { 0 }; print_hex_bytes(buf, buflen - 2, bb, sizeof(bb)); ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", (int)buflen - 2); } #endif return (int)buflen; }
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 lpwrap_init_pri(struct lpwrap_pri *spri, ftdm_span_t *span, ftdm_channel_t *dchan, int swtype, int node, int debug) { int ret = -1; memset(spri, 0, sizeof(struct lpwrap_pri)); spri->dchan = dchan; spri->span = span; if ((spri->pri = pri_new_cb(spri->dchan->sockfd, node, swtype, __pri_lpwrap_read, __pri_lpwrap_write, spri))){ unsigned char buf[4] = { 0 }; size_t buflen = sizeof(buf), len = 0; pri_set_debug(spri->pri, debug); ret = 0; ftdm_set_flag(spri, LPWRAP_PRI_READY); ftdm_channel_write(spri->dchan, buf, buflen, &len); } else { fprintf(stderr, "Unable to create PRI\n"); } return ret; }
static int __pri_lpwrap_write(struct pri *pri, void *buf, int buflen) { struct lpwrap_pri *spri = (struct lpwrap_pri *) pri_get_userdata(pri); ftdm_size_t len = buflen -2; if (ftdm_channel_write(spri->dchan, buf, buflen, &len) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_CRIT, "span %d D-WRITE FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); ftdm_clear_flag(spri, LPWRAP_PRI_READY); return -1; } #ifdef IODEBUG { char bb[2048] = { 0 }; print_hex_bytes(buf, buflen - 2, bb, sizeof(bb)); ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", (int)buflen-2); } #endif return (int) buflen; }
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); }