sample.c File Reference

WANPIPE(tm) API C Sample Code. More...

#include "libsangoma.h"
#include "lib_api.h"

Include dependency graph for sample.c:

Go to the source code of this file.

Classes
struct	sangoma_chan

Macros
#define	TEST_NUMBER_OF_OBJECTS   1
	Number of wait objects to define in object array. More...

Typedefs
typedef struct sangoma_chan	sangoma_chan_t

Functions
int __cdecl	main (int argc, char *argv[])
	Main function that starts the sample code. More...
int	open_sangoma_device (void)
	Open a single span chan device. More...
void	handle_span_chan (int open_device_counter)
	Write data buffer into a file. More...
int	handle_tdm_event (uint32_t dev_index)
	Read Event buffer from the device. More...
int	handle_data (uint32_t dev_index, int flags_out)
	Read data buffer from the device and transmit it back down. More...
int	read_data (uint32_t dev_index, wp_api_hdr_t *rx_hdr, void *rx_buffer, int rx_buffer_length)
int	write_data (uint32_t dev_index, wp_api_hdr_t *tx_hdr, void *tx_buffer, int tx_len)
	Transmit a data buffer to a device. More...
int	dtmf_event (sng_fd_t fd, unsigned char digit, unsigned char type, unsigned char port)
int	rbs_event (sng_fd_t fd, unsigned char rbs_bits)
int	rxhook_event (sng_fd_t fd, unsigned char hook_state)
int	rxring_event (sng_fd_t fd, unsigned char ring_state)
int	ringtrip_event (sng_fd_t fd, unsigned char ring_state)
int	write_data_to_file (unsigned char *data, unsigned int data_length)
	Write data buffer into a file. More...
int	sangoma_print_stats (sng_fd_t sangoma_dev)
void	cleanup (void)
	Protperly shutdown single device. More...
int	handle_fe_rw (void)
void	TerminateHandler (int)
	Signal handler for graceful shutdown. More...
void	print_rxdata (unsigned char *data, int datalen, wp_api_hdr_t *hdr)

Variables
sangoma_chan_t	sangoma_channels [TEST_NUMBER_OF_OBJECTS]
unsigned char	rx_rbs_bits = WAN_RBS_SIG_A
FILE *	pRxFile
int	application_termination_flag = 0

Detailed Description

WANPIPE(tm) API C Sample Code.

Authors: David Rokhvarg david.nosp@m.r@sa.nosp@m.ngoma.nosp@m..com Nenad Corbic ncorb.nosp@m.ic@s.nosp@m.angom.nosp@m.a.co.nosp@m.m

Copyright (c) 2007 - 08, Sangoma Technologies All rights reserved.

• Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
  • Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  • Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  • Neither the name of the Sangoma Technologies nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY Sangoma Technologies ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Sangoma Technologies BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

Definition in file sample.c.

Macro Definition Documentation

#define TEST_NUMBER_OF_OBJECTS   1

Number of wait objects to define in object array.

Objects are used to wait on file descripotrs. Usually there is one wait object per file descriptor.

In this example there is a single file descriptor and a single wait object.

Definition at line 50 of file sample.c.

Referenced by cleanup(), handle_span_chan(), and main().

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Main function that starts the sample code.

Main function start of the applicatoin.

Parameters

argc	number of arguments
argv	argument list
argc	number of arguments
argv	argument list

Returns

0 - ok non-zero - Error

Get user Input Set program settings based on user input Create SangomaInterface Class based on user span/chan input. Bind callback functions read/event to SangomaInteface class. Execute the SangomaInterface handling function -> start() The start function will read/write/event data. In Main thread prompt the user for commands.

Definition at line 1018 of file sample.c.

References _getch, cleanup(), handle_span_chan(), open_sangoma_device(), TerminateHandler(), TEST_NUMBER_OF_OBJECTS, and TRUE.

{
    int proceed, i;


    proceed=init_args(argc,argv);
    if (proceed != WAN_TRUE){
        usage(argv[0]);
        return -1;
    }
    
    if (hw_pci_rescan) {
        /* Function used to rescan pci/usb bus.
           added here as use example. Uncomment to use.
           This function should only be used when all ports
           are down. */
        return sangoma_hardware_rescan();
    }

    /* register Ctrl+C handler - we want a clean termination */
#if defined(__WINDOWS__)
    if (!SetConsoleCtrlHandler(TerminateHandler, TRUE)) {
        printf("ERROR : Unable to register terminate handler ( %d ).\nProcess terminated.\n", 
            GetLastError());
        return -1;
    }
#else
    signal(SIGHUP,TerminateHandler);
    signal(SIGTERM,TerminateHandler);
#endif
    
    for(i = 0; i < TEST_NUMBER_OF_OBJECTS; i++){
        sangoma_wait_objects[i] = NULL;
    }

    poll_events_bitmap = 0;
    if(read_enable  == 1){
        poll_events_bitmap |= POLLIN;
    }

    if(write_enable == 1 && rx2tx == 1){
        /* These two options are mutually exclusive because 'rx2tx' option
         * indicates "use Reciever as the timing source for Transmitter". */
        write_enable = 0;
    }
    
    if(write_enable == 1){
        poll_events_bitmap |= POLLOUT;
    }

    /* Front End connect/disconnect, and other events, such as DTMF... */
    poll_events_bitmap |= (POLLHUP | POLLPRI);
#if defined(__WINDOWS__)
    printf("Enabling Poll Events:\n");
    print_poll_event_bitmap(poll_events_bitmap);
#endif
    printf("Connecting to Port/Span: %d, Interface/Chan: %d\n",
        wanpipe_port_no, wanpipe_if_no);


    if(open_sangoma_device()){
        return -1;
    }

    printf("********************************\n");
    printf("files_used: 0x%x\n", files_used);
    printf("********************************\n");
    if(files_used & RX_FILE_USED){
        pRxFile = fopen( (const char*)&rx_file[0], "wb" );
        if(pRxFile == NULL){
            printf("Can't open Rx file: [%s]!!\n", rx_file);
        }else{
            printf("Open Rx file: %s. OK.\n", rx_file);
        }
    }

    if (fe_read_cmd || fe_write_cmd) {
        handle_fe_rw();
        goto done;
    }
    
    handle_span_chan(1 /* handle a single device */);

done:
    /* returned from main loop, do the cleanup before exiting: */
    cleanup();

    printf("\nSample application exiting.(press any key)\n");
    _getch();
    return 0;
}

Here is the call graph for this function:

int open_sangoma_device

(

void

)

Open a single span chan device.

Returns

0 ok otherise error.

This function will open a single span chan.

However it can be rewritten to iterate for all spans and chans and try to open all existing wanpipe devices.

For each opened device, a wait object will be initialized. For each device, configure the chunk size for tx/rx enable events such as DTMF/RBS ...etc

Definition at line 760 of file sample.c.

References __sangoma_open_api_span_chan(), INVALID_HANDLE_VALUE, SANG_STATUS_SUCCESS, SANGOMA_DEVICE_WAIT_OBJ, sangoma_fe_reg_read(), sangoma_flush_bufs(), sangoma_flush_stats(), sangoma_get_full_cfg(), sangoma_get_rx_queue_sz(), sangoma_get_tx_queue_sz(), sangoma_open_api_span_chan(), sangoma_set_rx_queue_sz(), sangoma_set_tx_queue_sz(), sangoma_ss7_get_cfg_status(), sangoma_tdm_enable_dtmf_events(), sangoma_tdm_enable_rbs_events(), sangoma_tdm_enable_rm_dtmf_events(), sangoma_tdm_enable_rxhook_events(), sangoma_tdm_set_buffer_multiplier(), sangoma_tdm_set_codec(), sangoma_tdm_set_usr_period(), and sangoma_wait_obj_create().

Referenced by main().

{
    int span, chan, err = 0, open_dev_cnt = 0;
    sangoma_status_t status;
    sng_fd_t    dev_fd = INVALID_HANDLE_VALUE;
    wanpipe_api_t tdm_api;

    span = wanpipe_port_no;
    chan = wanpipe_if_no;

    /* span and chan are 1-based */
    if (force_open) {
        dev_fd = __sangoma_open_api_span_chan(span, chan);
    } else {
        dev_fd = sangoma_open_api_span_chan(span, chan);
    }
    if( dev_fd == INVALID_HANDLE_VALUE){
        printf("Warning: Failed to open span %d, chan %d\n", span , chan);
        return 1;
    }else{
        printf("Successfuly opened span %d, chan %d\n", span , chan);
    }

    memset(&tdm_api, 0x00, sizeof(tdm_api));

    status = sangoma_wait_obj_create(&sangoma_wait_objects[open_dev_cnt], dev_fd, SANGOMA_DEVICE_WAIT_OBJ);
    if(status != SANG_STATUS_SUCCESS){
        printf("Error: Failed to create 'sangoma_wait_object'!\n");
        return 1;
    }
    sangoma_channels[open_dev_cnt].channo = chan;
    sangoma_channels[open_dev_cnt].spanno = span;
    sangoma_wait_obj_set_context(sangoma_wait_objects[open_dev_cnt], &sangoma_channels[open_dev_cnt]);
    /* open_dev_cnt++; */

    if((err = sangoma_get_full_cfg(dev_fd, &tdm_api))){
        return 1;
    }

    if(set_codec_slinear){
        printf("Setting SLINEAR codec\n");
        if((err=sangoma_tdm_set_codec(dev_fd, &tdm_api, WP_SLINEAR))){
            return 1;
        }
    }

    if(set_codec_none){
        printf("Disabling codec\n");
        if((err=sangoma_tdm_set_codec(dev_fd, &tdm_api, WP_NONE))){
            return 1;
        }
    }

    if(usr_period){
        printf("Setting user period: %d\n", usr_period);
        if((err=sangoma_tdm_set_usr_period(dev_fd, &tdm_api, usr_period))){
            return 1;
        }
    }

    if (rx_gain_cmd) {
        printf("Setting rx gain : %f\n", rx_gain);
        if (sangoma_set_rx_gain(dev_fd,&tdm_api,rx_gain)) {
            return 1;
        }   
    }

    if (tx_gain_cmd) {
        printf("Setting tx gain : %f\n", rx_gain);
        if (sangoma_set_tx_gain(dev_fd,&tdm_api,tx_gain)) {
            return 1;
        }
    }

    if(set_codec_slinear || usr_period || set_codec_none){
        /* display new configuration AFTER it was changed */
        if((err=sangoma_get_full_cfg(dev_fd, &tdm_api))){
            return 1;
        }
    }

    if(dtmf_enable_octasic == 1){
        poll_events_bitmap |= POLLPRI;
        /* enable dtmf detection on Octasic chip */
        if((err=sangoma_tdm_enable_dtmf_events(dev_fd, &tdm_api))){
            return 1;
        }
    }

    if(dtmf_enable_remora == 1){
        poll_events_bitmap |= POLLPRI;
        /* enable dtmf detection on Sangoma's Remora SLIC chip (A200 ONLY) */
        if((err=sangoma_tdm_enable_rm_dtmf_events(dev_fd, &tdm_api))){
            return 1;
        }
    }

    if(remora_hook == 1){
        poll_events_bitmap |= POLLPRI;
        if((err=sangoma_tdm_enable_rxhook_events(dev_fd, &tdm_api))){
            return 1;
        }
    }

    if(rbs_events == 1){
        poll_events_bitmap |= POLLPRI;
        if((err=sangoma_tdm_enable_rbs_events(dev_fd, &tdm_api, 20))){
            return 1;
        }
    }
    if (buffer_multiplier) {
        printf("Setting buffer multiplier to %i\n",buffer_multiplier);
        err=sangoma_tdm_set_buffer_multiplier(dev_fd,&tdm_api,buffer_multiplier);
        if (err) {
            return 1;
        }
    }
    if (ss7_cfg_status) {
        wan_api_ss7_cfg_status_t ss7_hw_status;
        printf("Getting ss7 cfg status\n");
        err=sangoma_ss7_get_cfg_status(dev_fd,&tdm_api,&ss7_hw_status);
        if (err) {
            return 1;
        }
        printf("SS7 HW Configuratoin\n");
        printf("SS7 hw support   = %s\n",ss7_hw_status.ss7_hw_enable?"Enabled":"Disabled");
        printf("SS7 hw mode      = %s\n",ss7_hw_status.ss7_hw_mode?"4096":"128");
        printf("SS7 hw lssu size = %d\n",ss7_hw_status.ss7_hw_lssu_size);
        printf("SS7 driver repeat= %s\n",ss7_hw_status.ss7_driver_repeat?"Enabled":"Disabled");
    }

    if (stats_test) {
        sangoma_print_stats(dev_fd);
        exit(0);
    }
    if (flush_stats_test) {
        sangoma_flush_stats(dev_fd, &tdm_api);
        sangoma_print_stats(dev_fd);
        exit(0);
    }

    if (fe_read_test) {
        uint8_t data=0;
        uint8_t prev_data=0;
        int i;
        int elapsed=0;
        int elapsed_cnt=0;


#if defined(__WINDOWS__)
        long started, ended;
         started = GetTickCount();
#else
        struct timeval started, ended;

        gettimeofday(&started, NULL);
#endif      

        for (i=0;;i++) {
            elapsed_cnt++;
            sangoma_fe_reg_read(dev_fd, 0xF8, &data);   
            prev_data=data;
            if (data==0) {
                printf("Error: Bad FE Read 0x00 cnt=%i !!!!!!!!!!! \n",i);
                exit(1);
            } else {
                data=(data>>3)&0x1F;
                if (data != 0x0C) {
                    printf("Error: Bad FE Read Prev Data = 0x%X cnt=%i !!!!!!!!!!!!\n",prev_data,i);
                    exit(1);
                }
            }

#if defined(__WINDOWS__)
            ended = GetTickCount();
#else
            gettimeofday(&ended, NULL);
#endif

#if defined(__WINDOWS__)
            elapsed =  ended - started;
#else
            elapsed = (((ended.tv_sec * 1000) + ended.tv_usec / 1000) - ((started.tv_sec * 1000) + started.tv_usec / 1000));
#endif 

            if (elapsed > 5000) {
                printf("FE Reg 0xF8 = Prev Data = 0x%X int_cnt=%08i tot_cnt %08i\n",prev_data,elapsed_cnt,i);
#if defined(__WINDOWS__)
                started = GetTickCount();
#else
                gettimeofday(&started, NULL);
#endif

                elapsed_cnt=0;
            }
        }
        exit(0);
    }

    printf("Device Config RxQ=%i TxQ=%i \n",
        sangoma_get_rx_queue_sz(dev_fd,&tdm_api),
        sangoma_get_rx_queue_sz(dev_fd,&tdm_api));

#if 0
    sangoma_set_rx_queue_sz(dev_fd,&tdm_api,20);
    sangoma_set_tx_queue_sz(dev_fd,&tdm_api,30);
#endif

    printf("Device Config RxQ=%i TxQ=%i \n",
        sangoma_get_rx_queue_sz(dev_fd,&tdm_api),
        sangoma_get_tx_queue_sz(dev_fd,&tdm_api));
    
    sangoma_flush_bufs(dev_fd,&tdm_api);

    sangoma_print_stats(dev_fd);


    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void handle_span_chan

(

int

open_device_counter

)

Write data buffer into a file.

Parameters

open_device_counter

number of opened devices

Returns

void

This function will wait on all opened devices. This example will wait for RX and EVENT signals. In case of POLLIN - rx data available In case of POLLPRI - event is available

Definition at line 576 of file sample.c.

References handle_data(), handle_tdm_event(), SANG_STATUS_APIPOLL_TIMEOUT, SANG_STATUS_SUCCESS, sangoma_wait_obj_get_fd(), SDLA_DECODE_SANG_STATUS, and TEST_NUMBER_OF_OBJECTS.

Referenced by main().

{
    int iResult, i;
    u_int32_t input_flags[TEST_NUMBER_OF_OBJECTS];
    u_int32_t output_flags[TEST_NUMBER_OF_OBJECTS];

    printf("\n\nSpan/Chan Handler: RxEnable=%s, TxEnable=%s, TxCnt=%i, TxLen=%i, rx2tx=%s\n",
        (read_enable? "Yes":"No"), (write_enable?"Yes":"No"),tx_cnt,tx_size, (rx2tx?"Yes":"No"));   

    for (i = 0; i < open_device_counter; i++) {
        input_flags[i] = poll_events_bitmap;
    }

    /* Main Rx/Tx/Event loop */
    while(!application_termination_flag) 
    {   
        iResult = sangoma_waitfor_many(sangoma_wait_objects, 
                           input_flags,
                           output_flags,
                           open_device_counter /* number of wait objects */,
                           5000 /* wait timeout, in milliseconds */);
        switch(iResult)
        {
        case SANG_STATUS_APIPOLL_TIMEOUT:
            /* timeout (not an error) */
            {
            sng_fd_t dev_fd = sangoma_wait_obj_get_fd(sangoma_wait_objects[0]);
            sangoma_print_stats(dev_fd);
            }
            printf("Timeout\n");
            continue;

        case SANG_STATUS_SUCCESS:
            for(i = 0; i < open_device_counter; i++){

                /* a wait object was signaled */
                if(output_flags[i] & POLLPRI){
                    /* got tdm api event */
                    if(handle_tdm_event(i)){
                        printf("Error in handle_tdm_event()!\n");
                        application_termination_flag=1;
                        break;
                    }
                }
                    
                if(output_flags[i] & (POLLIN | POLLOUT)){
                    /* rx data OR a free tx buffer available */
                    if(handle_data(i, output_flags[i])){
                        printf("Error in handle_data()!\n");
                        //application_termination_flag=1;
                        break;
                    }
                }
            }/* for() */
            break;

        default:
            /* error */
            printf("Error: iResult: %s (%d)\n", SDLA_DECODE_SANG_STATUS(iResult), iResult);
            return;
        }

    }/* while() */
}

Here is the call graph for this function:

Here is the caller graph for this function:

int handle_tdm_event

(

uint32_t

dev_index

)

Read Event buffer from the device.

Parameters

dev_index

device index number associated with device file descriptor

Returns

0 - Ok otherwise Error

An EVENT has occoured. Execute a system call to read the EVENT on a device.

Definition at line 513 of file sample.c.

References wanpipe_api_cmd::event, sangoma_read_event(), sangoma_wait_obj_get_fd(), and wanpipe_api::wp_cmd.

Referenced by handle_span_chan().

{
    wanpipe_api_t   tdm_api; 
    sng_fd_t        dev_fd = sangoma_wait_obj_get_fd(sangoma_wait_objects[dev_index]);

#if 0
    printf("%s(): dev_index: %d, dev_fd: 0x%p\n", __FUNCTION__, dev_index, dev_fd);
#endif

    memset(&tdm_api, 0x00, sizeof(tdm_api));

    if(sangoma_read_event(dev_fd, &tdm_api)){
        return 1;
    }

    decode_api_event(&tdm_api.wp_cmd.event);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int handle_data	(	uint32_t	dev_index,
		int	flags_out
	)

Read data buffer from the device and transmit it back down.

Parameters

dev_index

device index number associated with device file descriptor

Returns

0 - Ok otherwise Error

Read data buffer from a device.

Definition at line 391 of file sample.c.

References wp_api_hdr::data_length, MAX_NO_DATA_BYTES_IN_FRAME, and write_data().

Referenced by handle_span_chan().

{
    wp_api_hdr_t    rxhdr;
    int err=0;

    memset(&rxhdr, 0, sizeof(rxhdr));

#if 0
    printf("%s(): span: %d, chan: %d\n", __FUNCTION__,
        sangoma_wait_objects[dev_index].span, sangoma_wait_objects[dev_index].chan);
#endif

    if(flags_out & POLLIN){
        if(read_data(dev_index, &rxhdr, rxdata, MAX_NO_DATA_BYTES_IN_FRAME) == 0){
            if(rx2tx){
                /* Send back received data (create a "software loopback"), just a test. */
                return write_data(dev_index, &rxhdr, rxdata,rxhdr.data_length);
            }
        }
    }

    if( (flags_out & POLLOUT) && write_enable ){
    
        wp_api_hdr_t txhdr;
        static unsigned char tx_test_byte = 2;

        memset(&txhdr, 0, sizeof(txhdr));
        txhdr.data_length = (unsigned short)tx_size;/* use '-txsize' command line option to change 'tx_size' */

        /* set data which will be transmitted */
        memset(txdata, tx_test_byte, txhdr.data_length);
        
        err = write_data(dev_index, &txhdr, txdata, tx_size);
        if (err== 0) {
            //tx_test_byte++;
        }
    }
    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int write_data	(	uint32_t	dev_index,
		wp_api_hdr_t *	tx_hdr,
		void *	tx_data,
		int	tx_len
	)

Transmit a data buffer to a device.

Parameters

dev_index	device index number associated with device file descriptor
tx_hdr	pointer to a wp_api_hdr_t
tx_data	pointer to a data buffer
tx_len	tx data buffer len

Returns

0 - Ok otherwise Error

Definition at line 325 of file sample.c.

References sangoma_msleep, sangoma_wait_obj_get_context(), sangoma_wait_obj_get_fd(), and sangoma_writemsg().

Referenced by handle_data().

{
    sng_fd_t    dev_fd  = sangoma_wait_obj_get_fd(sangoma_wait_objects[dev_index]);
    sangoma_chan_t *chan = sangoma_wait_obj_get_context(sangoma_wait_objects[dev_index]);
    int         err;
    static int  Tx_count = 0;

    if (hdlc_repeat) {
        if (verbose){
            printf("Repeating Frame\n");
        }
        tx_hdr->wp_api_tx_hdr_hdlc_rpt_len=4;
        memset(tx_hdr->wp_api_tx_hdr_hdlc_rpt_data,Tx_count,4);
    }

    /* write a message */
    err = sangoma_writemsg(
                dev_fd,
                tx_hdr,                 /* header buffer */
                sizeof(wp_api_hdr_t),   /* header size */
                tx_buffer,              /* data buffer */
                tx_len,                 /* DATA size */
                0);

    if (err <= 0){
        printf("Span: %d, Chan: %d: Failed to send %s!\n", 
            chan->spanno, 
            chan->channo, strerror(errno));
        return -1;
    }
    
    Tx_count++;
    if (verbose){
        printf("Packet sent: counter: %i, len: %i, errors %i\n", Tx_count, err, tx_hdr->wp_api_tx_hdr_errors);
    }else{
        if(Tx_count && (!(Tx_count % 1000))){
            printf("Packet sent: counter: %i, len: %i\n", Tx_count, err);
        }
    }

    if (tx_delay) {
        sangoma_msleep(tx_delay);
    }

#if 1
    if(tx_cnt && Tx_count >= tx_cnt){
        write_enable=0;
        printf("Disabling POLLOUT...\n");
        /* No need for POLLOUT, turn it off!! If not turned off, and we
         * have nothing for transmission, sangoma_socket_waitfor() will return
         * immediately, creating a busy loop. */
        //sangoma_wait_objects[dev_index].flags_in &= (~POLLOUT);
        return 0;
    }
#endif
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int write_data_to_file	(	unsigned char *	data,
		unsigned int	data_length
	)

Write data buffer into a file.

Parameters

data	data buffer
data_length	length of a data buffer

Returns

data_length = ok otherwise error

Definition at line 649 of file sample.c.

{
    if(pRxFile == NULL){
        return 1;
    }

    return fwrite(data, 1, data_length, pRxFile);
}

void cleanup

(

void

)

Protperly shutdown single device.

Parameters

dev_no

device index number

Returns

void

Definition at line 697 of file sample.c.

References sangoma_close(), sangoma_tdm_disable_dtmf_events(), sangoma_tdm_disable_rbs_events(), sangoma_tdm_disable_rm_dtmf_events(), sangoma_tdm_disable_rxhook_events(), sangoma_wait_obj_delete(), sangoma_wait_obj_get_context(), sangoma_wait_obj_get_fd(), and TEST_NUMBER_OF_OBJECTS.

Referenced by main(), and TerminateHandler().

{
    int dev_no;
    sng_fd_t fd;
    sangoma_chan_t *chan;
    sangoma_wait_obj_t *sng_wait_object;
    wanpipe_api_t tdm_api; 

    /* do the cleanup before exiting: */
    for(dev_no = 0; dev_no < TEST_NUMBER_OF_OBJECTS; dev_no++){

        sng_wait_object = sangoma_wait_objects[dev_no];
        if(!sng_wait_object){
            continue;
        }
        chan = sangoma_wait_obj_get_context(sng_wait_object);
        printf("%s(): span: %d, chan: %d ...\n", __FUNCTION__, 
            chan->channo,
            chan->spanno);

        fd = sangoma_wait_obj_get_fd(sng_wait_object);
        memset(&tdm_api, 0x00, sizeof(tdm_api));

        if(dtmf_enable_octasic == 1){
            /* Disable dtmf detection on Octasic chip */
            sangoma_tdm_disable_dtmf_events(fd, &tdm_api);
        }

        if(dtmf_enable_remora == 1){
            /* Disable dtmf detection on Sangoma's Remora SLIC chip */
            sangoma_tdm_disable_rm_dtmf_events(fd, &tdm_api);
        }

        if(remora_hook == 1){
            sangoma_tdm_disable_rxhook_events(fd, &tdm_api);
        }

        if(rbs_events == 1){
            sangoma_tdm_disable_rbs_events(fd, &tdm_api);
        }

        sangoma_wait_obj_delete(&sng_wait_object);

        sangoma_close(&fd);

    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TerminateHandler

(

int

sig

)

Signal handler for graceful shutdown.

Parameters

sig

signal

Definition at line 679 of file sample.c.

References cleanup().

Referenced by main().

{
    printf("\nProcess terminated by user request.\n");
    application_termination_flag = 1;
    /* do the cleanup before exiting: */
    cleanup();
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function: