API tools faq
paste
jfabo

Freetdm latency measurement

jfabo
Oct 23rd, 2011
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 22.92 KB | None | 0 0
raw download clone embed print report
  1. #include "ftdm_core.h"
  2. #include "ftdm_state.h"
  3. #include "freetdm.h"
  4. #include <stdlib.h>
  5. /* some timers (in seconds) to fake responses in incoming calls */
  6. #define MAX_CALLS 255
  7. #define PROGRESS_TIMER 1
  8. #define ANSWER_TIMER 5
  9. #define HANGUP_TIMER 15
  10. #define SANGOMA_CARD
  11. #undef LIBPRI_CARD
  12. #define TELCO_SIDE
  13. #ifdef TELCO_SIDE
  14. #undef TERMINAL_SIDE
  15. #define  HUNTING_GROUP_ID 1
  16. #else
  17. #define  TERMINAL_SIDE
  18. #define  TERMINAL_SIDE_CALLS
  19. #define  HUNTING_GROUP_ID 2
  20. #endif
  21. #define  MAKE_CALLS
  22.  
  23. #define E1_SPANS 4
  24. /* simple variable used to stop the application */
  25. static int app_running = 0;
  26. static int global_call_count = 0;
  27. typedef void (*expired_function_t)(ftdm_channel_t *channel);
  28. typedef struct dummy_timer_s {
  29.     int time;
  30.     ftdm_channel_t *channel;
  31.     expired_function_t expired;
  32. } dummy_timer_t;
  33.  
  34. /* dummy second resolution timers */
  35. static dummy_timer_t g_timers[MAX_CALLS];
  36.  
  37. /* mutex to protect the timers (both, the test thread and the signaling thread may modify them) */
  38. static ftdm_mutex_t *g_schedule_mutex;
  39.  
  40. /* unique outgoing channel */
  41. static ftdm_channel_t *g_outgoing_channel = NULL;
  42.  
  43. static int callAnswered = 0;
  44. static char extCallId[100] = { 0 };
  45.  
  46. /* private data attached to each fs session */
  47. struct private_object {
  48.         unsigned int flags;
  49.         unsigned int codec;
  50.         unsigned int codecs;
  51.         unsigned short samprate;
  52.         ftdm_channel_t *ftdmchan;
  53.         uint32_t wr_error;
  54. };
  55.  
  56. /* private data attached to FTDM channels (only FXS for now) */
  57. typedef struct chan_pvt {
  58.         unsigned int flags;
  59. } chan_pvt_t;
  60.  
  61. typedef struct private_object private_t;
  62.  
  63. struct span_config {
  64.         ftdm_span_t *span;
  65.         char dialplan[80];
  66.         char context[80];
  67.         char dial_regex[256];
  68.         char fail_dial_regex[256];
  69.         char hold_music[256];
  70.         char type[256];
  71.         const char *limit_backend;
  72.         int limit_calls;
  73.         int limit_seconds;
  74.         chan_pvt_t pvts[FTDM_MAX_CHANNELS_SPAN];
  75. };
  76.  
  77. static ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg)
  78. {
  79.     uint32_t spanid, chanid;
  80.     char name[128];
  81.     ftdm_caller_data_t *channel_caller_data = ftdm_channel_get_caller_data(sigmsg->channel);
  82.    
  83.  
  84.     spanid = ftdm_channel_get_span_id(sigmsg->channel);
  85.     chanid = ftdm_channel_get_id(sigmsg->channel);
  86.    
  87.     snprintf(name, sizeof(name), "FreeTDM/%u:%u/%s", spanid, chanid, channel_caller_data->dnis.digits);
  88.     ftdm_log(FTDM_LOG_NOTICE, "freetdm span name %s\n", name);
  89.  
  90.     return FTDM_SUCCESS;
  91. }
  92.  
  93. static void schedule_timer(ftdm_channel_t *channel, int sec, expired_function_t expired)
  94. {
  95.     int i;
  96.     ftdm_mutex_lock(g_schedule_mutex);
  97.     for (i = 0; i < sizeof(g_timers)/sizeof(g_timers[0]); i++) {
  98.         /* check the timer slot is free to use */
  99.         if (!g_timers[i].time) {
  100.             g_timers[i].time = sec;
  101.             g_timers[i].channel = channel;
  102.             g_timers[i].expired = expired;
  103.             ftdm_mutex_unlock(g_schedule_mutex);
  104.             return;
  105.         }
  106.     }
  107.     ftdm_log(FTDM_LOG_ERROR, "Failed to schedule timer\n");
  108.     ftdm_mutex_unlock(g_schedule_mutex);
  109. }
  110.  
  111. static void run_timers(void)
  112. {
  113.     int i;
  114.     void *channel;
  115.     expired_function_t expired_func = NULL;
  116.     ftdm_mutex_lock(g_schedule_mutex);
  117.     for (i = 0; i < sizeof(g_timers)/sizeof(g_timers[0]); i++) {
  118.         /* if there's time left, decrement */
  119.         if (g_timers[i].time) {
  120.             g_timers[i].time--;
  121.         }
  122.  
  123.         /* if time expired and we have an expired function, call it */
  124.         if (!g_timers[i].time && g_timers[i].expired) {
  125.             expired_func = g_timers[i].expired;
  126.             channel = g_timers[i].channel;
  127.             memset(&g_timers[i], 0, sizeof(g_timers[i]));
  128.             expired_func(channel);
  129.         }
  130.     }
  131.     ftdm_mutex_unlock(g_schedule_mutex);
  132. }
  133.  
  134. static void release_timers(ftdm_channel_t *channel)
  135. {
  136.     int i;
  137.     ftdm_mutex_lock(g_schedule_mutex);
  138.     for (i = 0; i < sizeof(g_timers)/sizeof(g_timers[0]); i++) {
  139.         /* clear any timer belonging to the given channel */
  140.         if (g_timers[i].channel == channel) {
  141.             memset(&g_timers[i], 0, sizeof(g_timers[i]));
  142.         }
  143.     }
  144.     ftdm_mutex_unlock(g_schedule_mutex);
  145. }
  146.  
  147. /*  send answer for an incoming call */
  148. static void send_answer(ftdm_channel_t *channel)
  149. {
  150.      /* we move the channel signaling state machine to UP (answered) */
  151.     ftdm_log(FTDM_LOG_NOTICE, "-- Requesting answer in channel %d:%d\n", channel->span_id, channel->chan_id);
  152.         ftdm_channel_call_answer(channel);
  153.         callAnswered = 1;
  154. }
  155.  
  156. /* send progress for an incoming */
  157. static void send_progress(ftdm_channel_t *channel)
  158. {
  159.      /* we move the channel signaling state machine to UP (answered) */
  160.     ftdm_log(FTDM_LOG_NOTICE, "-- Requesting progress\n", channel->span_id, channel->chan_id);
  161.     ftdm_channel_call_indicate(channel, FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA);
  162.     schedule_timer(channel, ANSWER_TIMER, send_answer);
  163. }
  164.  
  165. /* send ringing for an incoming */
  166. static void send_ringing(ftdm_channel_t *channel)
  167. {
  168.      /* we move the channel signaling state machine to UP (answered) */
  169.     ftdm_log(FTDM_LOG_NOTICE, "-- Requesting ringing\n", channel->span_id, channel->chan_id);
  170.     ftdm_channel_call_indicate(channel, FTDM_CHANNEL_INDICATE_RINGING);
  171.     schedule_timer(channel, ANSWER_TIMER, send_progress);
  172. }
  173.  
  174. /* send proceed for an incoming */
  175. static void send_proceed(ftdm_channel_t *channel)
  176. {
  177.      /* we move the channel signaling state machine to UP (answered) */
  178.     ftdm_log(FTDM_LOG_NOTICE, "-- Requesting proceed\n", channel->span_id, channel->chan_id);
  179.     ftdm_channel_call_indicate(channel, FTDM_CHANNEL_INDICATE_PROCEED);
  180.     schedule_timer(channel, ANSWER_TIMER, send_ringing);
  181. }
  182.  
  183. static void place_call(void)
  184. {
  185. //   return ;
  186.    ftdm_usrmsg_t usrmsg;
  187.  
  188.    uint8_t *my_facility_ie = ftdm_calloc(1, 200); /*memory has to be allocated using ftdm_calloc !! */
  189.    unsigned my_facility_ie_len = 0;
  190.  
  191.    memset(&usrmsg, 0, sizeof(usrmsg));
  192.    my_facility_ie[my_facility_ie_len++] = 0xEE;
  193.    my_facility_ie[my_facility_ie_len++] = 0xFF;
  194.    my_facility_ie[my_facility_ie_len++] = 0x5C;
  195.    my_facility_ie[my_facility_ie_len++] = 0x5D;
  196.    my_facility_ie[my_facility_ie_len++] = 0x6E;
  197.    my_facility_ie[my_facility_ie_len++] = 0x7F;
  198.  
  199.  
  200.    ftdm_caller_data_t caller_data = {{ 0 }};
  201.  
  202.    /* set destiny number */
  203.    ftdm_set_string(caller_data.dnis.digits, "2223");
  204.  
  205.    /* set callerid */
  206.    ftdm_set_string(caller_data.cid_name, "testsangomaboost");
  207.    ftdm_set_string(caller_data.cid_num.digits, "1234");
  208.  
  209.    /* set the caller data for the outgoing channel */
  210.  
  211.    ftdm_hunting_scheme_t hunting;
  212.    memset(&hunting, 0, sizeof(hunting));
  213.  
  214.    hunting.mode_data.span.direction = FTDM_TOP_DOWN;
  215.    hunting.mode = FTDM_HUNT_SPAN;
  216.    hunting.mode_data.span.span_id = 3;
  217.  
  218. #ifdef  MAKE_CALLS
  219.    ftdm_status_t status = FTDM_SUCCESS;
  220.    ftdm_log(FTDM_LOG_ERROR, "testapp placing call, raw_len: %d\n", usrmsg.raw.len);
  221.    int callcount = 0;
  222.    struct timeval td_start,td_end;
  223.    if(gettimeofday(&td_start,NULL))
  224.    {
  225.       printf("time failed\n");
  226.       exit(1);
  227.    }
  228.  
  229.    while ((callcount < global_call_count) && (status == FTDM_SUCCESS)) // place as many calls as succeeds
  230.    {
  231.       char caller[25], called[25];
  232.       snprintf(caller, sizeof(caller), "0259682345");
  233.       snprintf(called, sizeof(called), "02595682345");
  234.  
  235.       ftdm_set_string(caller_data.dnis.digits, called);
  236.       ftdm_set_string(caller_data.cid_num.digits, caller);
  237.       caller_data.priv = (void *) (&extCallId[callcount]);
  238.       status = ftdm_call_place_ex(&caller_data, &hunting, &usrmsg);
  239.       callcount++;
  240.       if (status != FTDM_SUCCESS)
  241.       {
  242.          ftdm_log(FTDM_LOG_ERROR, "Failed to originate call %d\n", status);
  243.          //return;
  244.          break;
  245.       }
  246.    }
  247.    if(gettimeofday(&td_end,NULL))
  248.    {
  249.       printf("time failed\n");
  250.       exit(1);
  251.    }
  252.  
  253.    long elapsed = 1000000.0 * (td_end.tv_sec -td_start.tv_sec);
  254.    elapsed += (td_end.tv_usec - td_start.tv_usec);
  255.  
  256.    ftdm_log(FTDM_LOG_ERROR, "placing %d calls took %dms\n", callcount, elapsed);
  257. #endif // TERMINAL_SIDE
  258.    ftdm_log(FTDM_LOG_ERROR, "Call originated, call_id returned: %d\n", caller_data.call_id);
  259. }
  260.  
  261. static FIO_SIGNAL_CB_FUNCTION(on_signaling_event)
  262. {
  263.    ftdm_log(FTDM_LOG_NOTICE, "XXX CALLBACK\n");
  264.  
  265.    /* Inside event call-back function */
  266.    ftdm_iterator_t *iter = NULL;
  267.    ftdm_iterator_t *curr = NULL;
  268.    const char *var_name = NULL;
  269.    const char *var_value = NULL;
  270.    ftdm_status_t retval;
  271.    ftdm_log(FTDM_LOG_NOTICE, ">***** ***** ****** ******\n");
  272.    /* Read all variables attached to this event */
  273.    iter = ftdm_sigmsg_get_var_iterator(sigmsg, iter);
  274.    for (curr = iter ; curr; curr = ftdm_iterator_next(curr))
  275.    {
  276.       ftdm_get_current_var(curr, &var_name, &var_value);
  277.       ftdm_log(FTDM_LOG_NOTICE, "Call Variable: %s=%s\n", var_name, var_value);
  278.    }
  279.    ftdm_iterator_free(iter);   
  280.    ftdm_log(FTDM_LOG_NOTICE, "<***** ***** ****** ******\n");
  281.    ftdm_log(FTDM_LOG_NOTICE, "RAW>***** ***** ****** ******\n");
  282.  
  283.    /* Inside event call-back function */
  284.    ftdm_log(FTDM_LOG_NOTICE, "raw.len: %d\n", sigmsg->raw.len);
  285.    ftdm_size_t len;
  286.    uint8_t *mydata;
  287.    if (ftdm_sigmsg_get_raw_data(sigmsg, (void**)&mydata, &len) == FTDM_SUCCESS)
  288.    {
  289.       /* raw data is available, do something with mydata here */
  290.       for (int i = 0; i < len; i++)
  291.       {
  292.          ftdm_log(FTDM_LOG_NOTICE, "0x%x ", mydata[i]);
  293.       }
  294.       ftdm_log(FTDM_LOG_NOTICE, "\n");
  295.    }
  296.    /* Once this function returns, raw data will be free'd inside FreeTDM */
  297.  
  298.    ftdm_log(FTDM_LOG_NOTICE, "RAW<***** ***** ****** ******\n");
  299.  
  300.    switch (sigmsg->event_id)
  301.    {
  302.     /* This event signals the start of an incoming call */
  303.     case FTDM_SIGEVENT_START:
  304.         ftdm_log(FTDM_LOG_NOTICE, "Incoming call received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  305.         schedule_timer(sigmsg->channel, PROGRESS_TIMER, send_proceed);
  306.         g_outgoing_channel = sigmsg->channel;
  307.         if (g_outgoing_channel != NULL)
  308.         {
  309.             ftdm_log(FTDM_LOG_NOTICE, "XXX outgoing channel assigned\n");
  310.         }
  311.         ftdm_log(FTDM_LOG_WARNING, "NATIVE CODEC: %d\n", g_outgoing_channel->native_codec);
  312.         ftdm_log(FTDM_LOG_WARNING, "EFFECT CODEC: %d\n", g_outgoing_channel->effective_codec);
  313.         retval = ftdm_channel_command(sigmsg->channel,FTDM_COMMAND_ENABLE_DTMF_DETECT, NULL);
  314.                
  315.         ftdm_log(FTDM_LOG_NOTICE, "dtmf enabling retval%d\n", retval);
  316.  
  317.         return ftdm_channel_from_event(sigmsg);
  318.         break;
  319.     /* This event signals progress on an outgoing call */
  320.     case FTDM_SIGEVENT_PROGRESS_MEDIA:
  321.         ftdm_log(FTDM_LOG_NOTICE, "Progress message received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  322.         break;
  323.     /* This event signals answer in an outgoing call */
  324.     case FTDM_SIGEVENT_UP:
  325.         ftdm_log(FTDM_LOG_NOTICE, "Answer received in channel %d:%d extCallId %d\n", sigmsg->span_id, sigmsg->chan_id, *((char *)sigmsg->call_priv));
  326.         /* now the channel is answered and we can use
  327.          * ftdm_channel_wait() to wait for input/output in a channel (equivalent to poll() or select())
  328.          * ftdm_channel_read() to read available data in a channel
  329.          * ftdm_channel_write() to write to the channel */
  330.         g_outgoing_channel = sigmsg->channel;
  331.       callAnswered = 1;
  332.       retval = 0;
  333.         ftdm_log(FTDM_LOG_NOTICE, "dtmf enabling retval%d\n", retval);
  334.         break;
  335.     /* This event signals hangup from the other end */
  336.     case FTDM_SIGEVENT_STOP:
  337.         ftdm_log(FTDM_LOG_NOTICE, "Hangup received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  338.         if (g_outgoing_channel == sigmsg->channel) {
  339.                            g_outgoing_channel = NULL;
  340.                    }
  341.            
  342.                    release_timers(sigmsg->channel);
  343.                    ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_HANGUP);
  344.                    break;
  345.            case FTDM_SIGEVENT_RESTART:
  346.                    ftdm_log(FTDM_LOG_NOTICE, "Restart received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  347.                    break;
  348.            case FTDM_SIGEVENT_PROGRESS:
  349.                    ftdm_log(FTDM_LOG_NOTICE, "Progress received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  350.                    break;
  351.  
  352.            case FTDM_SIGEVENT_RINGING:
  353.                    ftdm_log(FTDM_LOG_NOTICE, "Ringing received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  354.  
  355.                    break;
  356.  
  357.            case FTDM_SIGEVENT_PROCEED:
  358.                    ftdm_log(FTDM_LOG_NOTICE, " proceed received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  359.                    break;
  360.  
  361.            case FTDM_SIGEVENT_FACILITY:
  362.                    ftdm_log(FTDM_LOG_NOTICE, " facility received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  363.                    break;
  364.  
  365.            case FTDM_SIGEVENT_SIGSTATUS_CHANGED:
  366.                    ftdm_log(FTDM_LOG_NOTICE, "status changed received in channel %d:%d\n", sigmsg->span_id, sigmsg->chan_id);
  367.                    break;
  368.  
  369.  
  370.            default:
  371.                    ftdm_log(FTDM_LOG_WARNING, "Unhandled event %s in channel %d:%d\n", ftdm_signal_event2str(sigmsg->event_id),
  372.                                    sigmsg->span_id, sigmsg->chan_id);
  373.                    break;
  374.            }
  375.            return FTDM_SUCCESS;
  376.    }
  377.  
  378.    int main(int argc, char *argv[])
  379.    {
  380.       ftdm_global_set_default_logger(7);
  381.  
  382.       int ako = 0;
  383.       for (; ako < sizeof(extCallId); ako++)
  384.       {
  385.          extCallId[ako] = ako;
  386.       }
  387.       ftdm_conf_parameter_t parameters[20];
  388.       ftdm_span_t *span[4];
  389.  
  390.       if (ftdm_global_init() != FTDM_SUCCESS)
  391.       {
  392.           fprintf(stderr, "Error loading FreeTDM\n");
  393.           exit(-1);
  394.       }
  395.       ftdm_mutex_create(&g_schedule_mutex);
  396.       ftdm_global_configuration();
  397.       printf("MY own FreeTDM loaded\n");
  398.  
  399.       //global_call_count = atoi(argv[1]);
  400.       global_call_count = 1;
  401.       int i = 0;
  402.       for(i = 0; i<E1_SPANS; i++)
  403.       {
  404.          if (ftdm_span_find(i+1, &span[i]) != FTDM_SUCCESS)
  405.          {
  406.             fprintf(stderr, "Error finding FreeTDM span\n");
  407.             goto done;
  408.          }
  409.          /* following parameters are signaling stack specific, this ones are for PRI */
  410. #ifdef SANGOMA_CARD
  411.          parameters[0].var = "switchtype";
  412.          parameters[0].val = "euroisdn";
  413.          parameters[1].var = "interface";
  414. #ifdef TERMINAL_SIDE
  415.       parameters[1].val = "pri_cpe";
  416. #endif // TERMINAL_SIDE
  417. #ifdef TELCO_SIDE
  418.       if (i == 1)
  419.       {
  420.          parameters[1].val = "pri_cpe";
  421.       }
  422.       else
  423.       {
  424.          parameters[1].val = "pri_net";
  425.       }
  426. #endif // TELCO_SIDE
  427.       parameters[2].var = "outbound-bearer_cap";
  428.       parameters[2].val = "unrestricted-digital";
  429.  
  430.       parameters[3].var = "outbound-bearer_layer1";
  431.       parameters[3].val = "alaw";
  432.       parameters[4].var = "overlap";
  433.       parameters[4].val = "yes";
  434.       parameters[5].var = "facility-ie-decode";
  435.       parameters[5].val = "no";
  436.  
  437.  
  438.       parameters[6].var = NULL;
  439. #endif
  440. #ifdef LIBPRI_CARD
  441.       parameters[0].var = "switch";
  442.       parameters[0].val = "euroisdn";
  443.  
  444.       parameters[1].var = "mode";
  445. #ifdef TERMINAL_SIDE
  446.       parameters[1].val = "cpe";
  447. #endif // TERMINAL_SIDE
  448. #ifdef TELCO_SIDE
  449.       parameters[1].val = "net";
  450. #endif // TELCO_SIDE
  451.  
  452.       parameters[2].var = "debug";
  453.       parameters[2].val = "all";
  454.  
  455.  
  456.       parameters[3].var = NULL;
  457.  
  458. #endif
  459.  
  460. /* send the configuration values down to the stack */
  461. #ifdef LIBPRI_CARD
  462.       if (ftdm_configure_span_signaling(span[i], "libpri", on_signaling_event, parameters) != FTDM_SUCCESS)
  463.       {
  464. #endif
  465. #ifdef SANGOMA_CARD
  466.       if (ftdm_configure_span_signaling(span[i], "sangoma_isdn", on_signaling_event, parameters) != FTDM_SUCCESS)
  467.       {
  468. #endif
  469.          goto done;
  470.       }
  471.         ftdm_span_start(span[i]);
  472.    }
  473.  
  474.    /* OK SPANS ARE STARTED */
  475.  
  476.    int32_t ticks = 0;
  477.    ftdm_wait_flag_t wflags = FTDM_READ;
  478.    ftdm_size_t len = 0, bufLen = 0;
  479.    unsigned char dataBuff[160];
  480.    unsigned char to = 20;
  481.    unsigned long globalRead = 0, inbufferdatalen = 0, inbuffercurrentread = 144000;
  482.  
  483.    /* read the prebuferred voice data in binary file */
  484.    unsigned char inbuffer[800000];
  485.    FILE *inFile;
  486.    if((inFile = fopen("sample_binin", "rb")))
  487.    {
  488.          inbufferdatalen = fread(inbuffer, 1, sizeof(inbuffer), inFile);
  489.          fclose(inFile);
  490.    }
  491.  
  492.    printf("inbufferdatalelu %lu \n", inbufferdatalen);
  493.  
  494.    app_running = 1;
  495.    /* The application thread can go on and do anything else, like waiting for a shutdown signal */
  496.    while(ftdm_running() && app_running && ticks < 300000000)
  497.    {
  498.       if (callAnswered == 0)
  499.       {
  500.          ftdm_sleep(1000);
  501.       }
  502.       run_timers();
  503.       if (ticks == 20)
  504.       {
  505.          place_call();
  506.       }
  507.       ftdm_log(FTDM_LOG_ERROR, "ticks %d\n", ticks);
  508.       ticks++;
  509.       if (callAnswered && (g_outgoing_channel != NULL))
  510.       {
  511. //         ftdm_sleep(1);
  512.          int sp = 0;
  513.          to = 20;
  514.          char needWait = 1;
  515.          for (sp = 0; sp < 2; sp++)
  516.          {
  517.             ftdm_iterator_t *channelSpanIterator = ftdm_span_get_chan_iterator(span[sp], NULL);
  518.             do
  519.             {
  520.                ftdm_channel_t *ftdmchan = ftdm_iterator_current(channelSpanIterator);
  521.                if (ftdmchan == NULL)
  522.                {
  523.                   ftdm_log(FTDM_LOG_WARNING, "iterator current returned NULL\n");
  524.                   break;
  525.                }
  526.                
  527.                channelSpanIterator = ftdm_iterator_next(channelSpanIterator);
  528.                unsigned char channelId = ftdm_channel_get_id(ftdmchan);
  529.                unsigned char spanId = ftdm_channel_get_span_id(ftdmchan);
  530.  
  531.  
  532.                if (channelId == 31)
  533.                {
  534.                   // Skip the D-chan
  535.                   break;
  536.                }
  537.                
  538.                if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN))
  539.                {
  540.                   // Channel is not open
  541.                   ftdm_log(FTDM_LOG_WARNING, "Channel is not openedi s %d ch %d\n", spanId, channelId);
  542.                   continue;
  543.                }
  544.                unsigned int llen = ftdm_channel_get_io_packet_len(ftdmchan);
  545.                ftdm_log(FTDM_LOG_ERROR, "channel packet length %d s %d ch %d\n", llen, spanId, channelId);
  546.  
  547.                ftdm_status_t ftdmret = FTDM_SUCCESS;
  548.                
  549.                wflags = FTDM_READ | FTDM_WRITE ;
  550.                if (needWait)
  551.                {
  552.                   ftdmret = ftdm_channel_wait(ftdmchan, &wflags, 20);
  553.                   to = 0;
  554.                   if (ftdmret == FTDM_FAIL)
  555.                   {
  556.                      ftdm_log(FTDM_LOG_WARNING, "r wait failed s %d ch %d\n", spanId, channelId);
  557.                      break;
  558.                   }
  559.                   if (ftdmret == FTDM_TIMEOUT)
  560.                   {
  561.                      ftdm_log(FTDM_LOG_WARNING, "r wait timeouted s %d ch %d\n", spanId, channelId);
  562.                      break;
  563.                   }
  564.  
  565.                   if (!(wflags & FTDM_READ))
  566.                   {
  567.                      ftdm_log(FTDM_LOG_WARNING, "read not possibles %d ch %d wf 0x%x\n", spanId, channelId, wflags);
  568.                      break;
  569.                   }
  570.                
  571.                   if (!(wflags & FTDM_WRITE))
  572.                   {
  573.                      ftdm_log(FTDM_LOG_WARNING, "write not possibles %d ch %d wf 0x%x\n", spanId, channelId, wflags);
  574.                      break;
  575.                   }
  576.                  
  577.                   needWait = 0;
  578.                }
  579.                bufLen = sizeof(dataBuff);
  580.                int read = 1;
  581.                
  582.                /* measurement loop */
  583.                
  584.                while (read)
  585.                {
  586.                   if (ftdm_channel_read(ftdmchan, dataBuff, &bufLen) != FTDM_SUCCESS)
  587.                   {
  588.                      ftdm_log(FTDM_LOG_WARNING, "r failed to read from device s %d ch %d\n", spanId, channelId);
  589.                      read = 0;
  590.                   }
  591.                   else
  592.                   {
  593.                      globalRead += bufLen;                    
  594.                      if (bufLen != 160)
  595.                      {
  596.                         ftdm_log(FTDM_LOG_ERROR, "XXXXX different buflen %d\n ", bufLen);
  597.                      }
  598.                      len = bufLen;
  599.                      if ((1== ftdm_channel_get_id(ftdmchan)) && (sp == 0))
  600.                      {
  601.                         //originator
  602.                         if (ftdm_channel_write(ftdmchan, inbuffer + inbuffercurrentread , 80, &len) != FTDM_SUCCESS)
  603.                         {
  604.                            ftdm_log(FTDM_LOG_WARNING, "failed to write to device s %d ch %d\n", spanId, channelId);
  605.                         }
  606.                         else
  607.                         {
  608.                            ftdm_log(FTDM_LOG_ERROR, "buflen %d lenn %d written s %d ch %d\n", bufLen, len, spanId, channelId);
  609.                            if (len != bufLen)
  610.                            {
  611.                               ftdm_log(FTDM_LOG_ERROR, "requested %d written %d\n", bufLen, len);
  612.                            }
  613.                            FILE *outrFile;
  614.                            if((outrFile = fopen("orbinout", "a")))
  615.                            {
  616.                                  fwrite(dataBuff, 1, len, outrFile);
  617.                                  fclose(outrFile);
  618.                            }
  619.    
  620.                            FILE *outFile;
  621.                            if((outFile = fopen("owbinout", "a")))
  622.                            {
  623.                                  fwrite(inbuffer + inbuffercurrentread, 1, len, outFile);
  624.                                  fclose(outFile);
  625.                            }
  626.                            inbuffercurrentread += len;
  627.                            if (inbuffercurrentread >= inbufferdatalen)
  628.                            {
  629.                               inbuffercurrentread = 144000;
  630.                            }
  631.                         }
  632.                      }
  633.                      else if ((1== ftdm_channel_get_id(ftdmchan)) && (sp == 1))
  634.                      {
  635.                         // acceptor
  636.                         if (ftdm_channel_write(ftdmchan, dataBuff, bufLen, &len) != FTDM_SUCCESS)
  637.                         {
  638.                            ftdm_log(FTDM_LOG_WARNING, "failed to write to device s %d ch %d\n", spanId, channelId);
  639.                         }
  640.                         else
  641.                         {
  642.                            ftdm_log(FTDM_LOG_ERROR, "buflen %d lenn %d written s %d ch %d\n", bufLen, len, spanId, channelId);
  643.                            if (len != bufLen)
  644.                            {
  645.                               ftdm_log(FTDM_LOG_ERROR, "requested %d written %d\n", bufLen, len);
  646.                            }
  647.                            FILE *outawFile;
  648.                            if((outawFile = fopen("awbinout", "a")))
  649.                            {
  650.                                  fwrite(dataBuff, 1, len, outawFile);
  651.                                  fclose(outawFile);
  652.                            }
  653.                         }
  654.                      }
  655.                   }
  656.                }
  657.             }
  658.             while (channelSpanIterator);
  659.             ftdm_iterator_free(channelSpanIterator);
  660.          }
  661.       }
  662.    }
  663. done:
  664.    ftdm_global_destroy();
  665.    return 1;
  666. }
  667.  
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!