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
Defines
#define	TEST_NUMBER_OF_OBJECTS   1
	Number of wait objects to define in object array.
Typedefs
typedef sangoma_chan	sangoma_chan_t
Functions
int __cdecl	main (int argc, char *argv[])
	Main function that starts the sample code.
int	open_sangoma_device (void)
	Open a single span chan device.
void	handle_span_chan (int open_device_counter)
	Write data buffer into a file.
int	handle_tdm_event (uint32_t dev_index)
	Read Event buffer from the device.
int	handle_data (uint32_t dev_index, int flags_out)
	Read data buffer from the device and transmit it back down.
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)
	Transmit a data buffer to a device.
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.
void	cleanup (void)
	Protperly shutdown single device.
void	TerminateHandler (int)
	Signal handler for graceful shutdown.
void	print_rxdata (unsigned char *data, int datalen)
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 <davidr@sangoma.com> Nenad Corbic <ncorbic@sangoma.com>

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.

---

Define 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.

Parameters:

	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 694 of file sample.c.

References _getch, callback_functions, cleanup(), sangoma_interface::CreateSwDtmfTxThread(), DBG_MAIN, sangoma_interface::device_name, sangoma_interface::enable_rbs_monitoring(), EnterCriticalSection, sangoma_interface::flush_operational_stats(), sangoma_interface::fxo_go_off_hook(), sangoma_interface::fxo_go_on_hook(), sangoma_interface::get_adapter_type(), sangoma_interface::get_api_driver_version(), sangoma_interface::get_card_customer_id(), sangoma_interface::get_operational_stats(), sangoma_interface::get_rbs(), sangoma_interface::get_sub_media(), sangoma_interface::get_te1_56k_stat(), handle_span_chan(), INFO_MAIN, init(), InitializeCriticalSection, LeaveCriticalSection, _DRIVER_VERSION::major, MAX_NO_DATA_BYTES_IN_FRAME, _DRIVER_VERSION::minor, _DRIVER_VERSION::minor1, _DRIVER_VERSION::minor2, open_sangoma_device(), PrintCriticalSection, program_settings, pRxFile, sangoma_interface::resetFSKCID(), SANG_STATUS_SUCCESS, SANG_STATUS_TX_TIMEOUT, sangoma_msleep, sangoma_interface::sendCallerID(), sangoma_interface::sendSwDTMF(), sangoma_interface::set_fe_debug_mode(), sangoma_interface::set_lb_modes(), sangoma_interface::set_rbs(), sangoma_interface::set_tx_idle_flag(), start(), sangoma_interface::start_busy_tone(), sangoma_interface::start_congestion_tone(), sangoma_interface::start_dial_tone(), sangoma_interface::start_ring_tone(), sangoma_interface::start_ringing_phone(), stop(), sangoma_interface::stop_all_tones(), sangoma_interface::stop_ringing_phone(), sangoma_interface::tdm_disable_bri_bchan_loopback(), sangoma_interface::tdm_disable_dtmf_events(), sangoma_interface::tdm_disable_ring_detect_events(), sangoma_interface::tdm_disable_ring_trip_detect_events(), sangoma_interface::tdm_disable_rm_dtmf_events(), sangoma_interface::tdm_disable_rxhook_events(), sangoma_interface::tdm_enable_bri_bchan_loopback(), sangoma_interface::tdm_enable_dtmf_events(), sangoma_interface::tdm_enable_ring_detect_events(), sangoma_interface::tdm_enable_ring_trip_detect_events(), sangoma_interface::tdm_enable_rm_dtmf_events(), sangoma_interface::tdm_enable_rxhook_events(), sangoma_interface::tdm_front_end_activate(), sangoma_interface::tdm_front_end_deactivate(), sangoma_interface::tdm_get_front_end_status(), sangoma_interface::tdm_set_user_period(), TdmEventCriticalSection, TerminateHandler(), TEST_NUMBER_OF_OBJECTS, sangoma_interface::transmit(), TRUE, tx_file(), and WAN_BRI_BCHAN1.

{
    int proceed, i;

    proceed=init_args(argc,argv);
    if (proceed != WAN_TRUE){
        usage(argv[0]);
        return -1;
    }

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

    handle_span_chan(1 /* handle a single device */);

    /* 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 581 of file sample.c.

References sangoma_chan::channo, INVALID_HANDLE_VALUE, SANG_STATUS_SUCCESS, sangoma_channels, SANGOMA_DEVICE_WAIT_OBJ, 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_tdm_enable_dtmf_events(), sangoma_tdm_enable_rbs_events(), sangoma_tdm_enable_rm_dtmf_events(), sangoma_tdm_enable_rxhook_events(), sangoma_tdm_set_codec(), sangoma_tdm_set_usr_period(), sangoma_wait_obj_create(), sangoma_wait_obj_set_context(), and sangoma_chan::spanno.

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 */
    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(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;
        }
    }

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

    sangoma_set_rx_queue_sz(dev_fd,&tdm_api,20);
    sangoma_set_tx_queue_sz(dev_fd,&tdm_api,30);

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

    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 405 of file sample.c.

References application_termination_flag, handle_data(), handle_tdm_event(), SANG_STATUS_APIPOLL_TIMEOUT, SANG_STATUS_SUCCESS, sangoma_waitfor_many(), 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 */,
                           2000 /* wait timeout, in milliseconds */);
        switch(iResult)
        {
        case SANG_STATUS_APIPOLL_TIMEOUT:
            /* timeout (not an error) */
            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");
                    }
                }
                    
                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");
                    }
                }
            }/* 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 375 of file sample.c.

References sangoma_read_event(), and sangoma_wait_obj_get_fd().

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 255 of file sample.c.

References MAX_NO_DATA_BYTES_IN_FRAME, read_data(), and write_data().

Referenced by handle_span_chan().

{
    wp_api_hdr_t    rxhdr;

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

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

        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);
                    
        if(write_data(dev_index, &txhdr, txdata) == 0){
            tx_test_byte++;
        }
    }
    return 0;
}

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
	)

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

Returns:

0 - Ok otherwise Error

Definition at line 202 of file sample.c.

References sangoma_chan::channo, sangoma_wait_obj_get_context(), sangoma_wait_obj_get_fd(), sangoma_writemsg(), and sangoma_chan::spanno.

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;

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

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

#if 0
    if(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);
    }
#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 470 of file sample.c.

References pRxFile.

Referenced by read_data().

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

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

Here is the caller graph for this function:

void cleanup

(

void

)

Protperly shutdown single device.

Parameters:

dev_no

device index number

Returns:

void

Definition at line 518 of file sample.c.

References sangoma_chan::channo, 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(), sangoma_chan::spanno, 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 500 of file sample.c.

References application_termination_flag, and 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:

---