Near end hang-up (common channel signaling)

This section describes the sequence of events when Blueworx Voice Response receives a request to clear a call from the application:

Figure 1. Common channel signaling process: near-end hang-up
The graphic is a very simplified representation of the process described in detail in the next section. The graphic shows the phases that are explained there.

Error processing

Blueworx Voice Response provides error processing to ensure that a call is never left connected in the event of failure. This table shows what Blueworx Voice Response does when a channel process failure occurs at different stages during the termination of a call:

Phase

Error Processing

X

Play the technical difficulties message to the caller. This message is a prerecorded message included with Blueworx Voice Response, which says “We are experiencing technical difficulties. Please hang up and try again later”.

Send the SL_CALL_ABORT_REQ primitive to the signaling process.

Y

None.

Z

None.

Description of flows

The flows shown in Figure 1 are as follows:

  1. X: The state table issues a TerminateCall action, which is interpreted by the channel process.
  2. The channel process creates an SL_TERMINATE_CALL_REQ primitive: 
    /* Local variables */
SL_PROC_TYPE           sigProc = SL_PROC_USR1 ;
int                    iSequenceNumber ;
SL_REQUEST_ST          slRequest ;
SL_CONFIRM_ST          slConfirm ;
SL_RET_CODE            slRC ;
.
.
.
/* Build a CALL_TERMINATE_REQ primitive */
slRequest.id                            = SLID_REQUEST_ST ;
slRequest.iseq_no                       = 0 ;  /*will be allocated*/
slRequest.pidCHP                        = getpid() ;
slRequest.slCommand.id                  = SL_CALL_TERMINATE_REQ ;
slRequest.terminate_call_st.sigCallReference        = call_ref_for_this_call ;
slRequest.terminate_call_st.iChannelNo  = channel ;
slRequest.terminate_call_st.iVpackNo    = Vpack ;
.
.
.
  3. Y: The channel process sends the SL_CALL_TERMINATE_REQ primitive to the signaling process, using a signaling interface function: 
    slRC = sl_send_request( sigProc, & iSequenceNumber, &slRequest ) ;
  4. The channel process waits for a reply: 
    slRC = sl_receive_confirm( sigProc, iSequenceNumber , timeout, &slConfirm ) ;
  5. Meanwhile, the signaling process is in a wait loop, issuing sl_receive_request() and then processing the received primitives.
  6. The signaling process returns from sl_receive_request() with an SL_CALL_TERMINATE_REQ primitive.
  7. The signaling process clears the call, using the specific protocol it implements.
  8. Once the call is fully terminated, the signaling process must respond to the SL_CALL_TERMINATE_REQUEST.
  9. The signaling process creates an SL_CALL_TERMINATE_CNF primitive: 
    /* Local variables */
 SL_HANDLE              slHandle ;
 int                    iSequenceNumber ;
 SL_REQUEST_ST          slRequest ;
 SL_CONFIRM_ST          slConfirm ;
 SL_RET_CODE            slRC ;
 .
 .
 .
 
 /* Build an SL_CALL_TERMINATE_CNF */
 slConfirm.id                = SLID_CONFIRM_ST ;
 slConfirm.iseq_no           = slRequest.iseq_no ;
 slConfirm.pidCHP            = slRequest.pidCHP ;
 slConfirm.Command.id        = SL_CALL_TERMINATE_CNF ;
 slConfirm.Parms.call_terminate_confirm_st.sizetLength
        = sizeof(slConfirm.Parms.call_terminate_confirm_st) ;
 slConfirm.Parms.call_terminate_confirm_st.ReplyCode        = SL_REPLY_SUCCESS ;
 slConfirm.Parms.call_terminate_confirm_st.slCallReference
        = slRequest.Parms.call_terminate_request_st.slCallReference ;
  10. Z: The signaling process sends the SL_CALL_TERMINATE_CNF primitive to the channel process: 
    slRC = sl_send_confirm( slHandle, iSequenceNumber, &slConfirm ) ;
    11. 


  11. The channel process has been waiting for the reply to its request, by
using the sl_receive_confirm() subroutine, which
now completes.
    12. 


  12. The TerminateCall action completes and the state
table continues with the next action. 
    13. 














Parent topic: Example signaling flows