7 Call Forwarding-Related Services

This chapter describes supplementary services related to call forwarding. Call forwarding is a service performed at a served user (or on behalf of a served user) to reroute a call to another user.

The following supplementary services are related to call forwarding:

In an ETS 300 application, call forwarding can be accomplished in any of three ways, depending upon which entity at the served user performs the forwarding operation (See Figure 23):

Regardless of which service is used, the diverted-to user is always notified of a forwarded call, using a Notify Diversion operation.

The served user application can enquire the network of the status of the Call Diversion service for a given user, or for all users.

Another service, the Remind Diversion service, can be invoked by the network if the user has subscribed to this service. When a served user initiates an outbound call, this service "reminds" the served user if Call Diversion services have been activated for incoming calls.

Figure 23: Call Diversion and Call Deflection (ETS 300)

In a Q.SIG application, call forwarding happens as follows:

Section 7.2.5 describes how an application can perform these procedures. Since the application may be associated with the originating node, served user node, or diverted-to node, all three perspectives are considered.

Note: Q.SIG specifications identify a fourth party involved in a diversion: the node responsible for rerouting the call (the rerouting node). AG ISDN supports the combination of the originating and rerouting nodes in the same node (i.e. call diversion by rerouting). It does not support the combination of rerouting node and served user node (i.e. call diversion by forward transfer).

ETS 300 call diversion procedures can be viewed as a remote-control mechanism to manage the diversion services performed in the network. The messages are command/response transactions, where the command may be:

The response acknowledges the successful processing of the command, and may contain information requested by the command.

To activate the Call Diversion service for an address, the application sends an acu_ss_act_divert_invoke extended data structure to the stack in an ACU request message, using the ACU_MGMT_SAPI. The service header to this structure must contain:

The extended data structure must contain:

The following is a listing of the acu_ss_act_divert_invoke extended data structure:

struct acu_ss_act_divert_invoke  
{  
  struct acu_ext_hdr   ext_hdr;     /* Extension header 	*/  
  struct acu_ss_hdr    ss_hdr;      /* Supplementary serv. header 	*/  
  struct acu_address   diverted_to; /* New destination of call 	*/  
  struct acu_party_num served_user; /* User number to activate the service	*/  
                                    /* for. If not invoked,then diversion	*/  
                                    /* applies to entire NAI	*/  
  struct acu_party_num activating_user; /* User activating the diversion,	*/  
                                    /* if different from the served user	*/  
  uchar                procedure;   /* From ACU_SS_DIVERSION_ constants	*/  
  uchar                basic_service;   /* From ACU_SS_BASIC_SERVICE_	*/  
  pad6                              /* constants 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

If the invocation is successful, the stack responds with an ACU indication message using the ACU_MGMT_SAPI. This message contains an acu_ss_act_divert_ret_result extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_act_divert_ret_result extended data structure:

struct acu_ss_act_divert_ret_result  
{  
struct acu_ext_hdr  ext_hdr;   /* Extended data structure header	*/  
struct acu_ss_hdr   ss_hdr;    /* Supp. services header	*/  
};

No data is returned with this message.

If the invocation is not successful, the stack responds with an ACU indication message using the ACU_MGMT_SAPI. This message contains an acu_ss_act_divert_ret_error extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_act_divert_ret_error extended data structure:

struct acu_ss_act_divert_ret_error  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
  ushort             err_id;  /* From ACT_DIVERT_RETERR_ constants	*/  
  pad6  
};

The err_id field contains the reason for the error, from ACT_DIVERT_RETERR constants (see Appendix C).

To deactivate the Call Diversion service for an address, the application sends an ACU request message to the stack containing an acu_ss_deact_divert_invoke extended data structure, using the ACU_MGMT_SAPI. The service header to this structure must contain:

In addition, the following must be specified in the data structure:

The following is a listing of the acu_ss_deact_divert_invoke extended data structure:

struct acu_ss_deact_divert_invoke  
{  
  struct acu_ext_hdr   ext_hdr;       /* Extension header 	*/  
  struct acu_ss_hdr    ss_hdr;        /* Supplementary serv. header	*/  
  struct acu_party_num served_user;   /* User to deactivate diversion for	*/  
  struct acu_party_num deactivating_user; /* User initiating the 	*/  
                                      /* deactivation	*/  
  uchar                procedure;     /* From ACU_SS_DIVERSION_ constants	*/  
  uchar                basic_service; /* From ACU_SS_BASIC_SERVICE_	*/  
  pad6                                /* constants 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

If the request is successful, the stack responds with an acu_ss_deact_divert_ret_result extended data structure in an ACU indication message using the ACU_MGMT_SAPI. The service header to this structure contains:

The following is a listing of the acu_ss_deact_divert_ret_result extended data structure:

struct acu_ss_act_divert_ret_result  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
};

No data is returned with this message.

If the request is unsuccessful, the stack responds with an acu_ss_deact_divert_ret_error extended data structure in an ACU indication message message using the ACU_MGMT_SAPI. The service header to this structure contains:

The following is a listing of the acu_ss_deact_divert_ret_error extended data structure:

struct acu_ss_act_divert_ret_error  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
  ushort             err_id;  /* From DEACT_DIVERT_RETERR_ constants	*/  
  pad6  
};

The err_id field contains the reason for the error, from DEACT_DIVERT_RETERR constants (see Appendix C).

An application can query the network, to obtain the following Call Diversion service information:

To query the network for status information, the application sends an acu_ss_enquire_divert_invoke extended data structure to the stack in an ACU request message, using the ACU_MGMT_SAPI. The service header to this structure must contain:

The following is a listing of the acu_ss_enquire_divert_invoke extended data structure:

struct acu_ss_enquire_divert_invoke  
{  
  struct acu_ext_hdr   ext_hdr;     /* Extension header 	*/  
  struct acu_ss_hdr    ss_hdr;      /* Supp. services header 	*/  
  struct acu_party_num served_user; /* Leave uninvoked to get information	*/  
                                    /* on all served numbers	*/  
  struct acu_party_num enquiring_user; /* For remote Q.SIG 	*/   
  uchar                procedure;   /* From ACU_SS_DIVERSION_ constants	*/  
  uchar                basic_service;  /* From SS_BASIC_SERVICE_ constants	*/  
  pad6  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

If a basic service is specified using the basic_service field in the structure, information will be returned just for Call Diversion services activated for that service type.

The served_user field determines whether detailed information about one user or a list of all users is returned. If the served_user field is not invoked, the network supplies a list of users. If a served user is specified in the served_user field, detailed information about the user is returned.

If the Enquire Diversion operation invocation succeeds, the network does one of the following:

Figure 24: Enquire Diversion (Single Served User)

Figure 25: Enquire Diversion (All Served Users)

The following is a listing of the acu_ss_enquire_divert_ret_result extended data structure:

struct acu_ss_enquire_divert_ret_result  
{  
  struct acu_ext_hdr   ext_hdr;        /* Extension header 	*/  
  struct acu_ss_hdr    ss_hdr;         /* Supp. services header 	*/  
  struct op_byte_field remote_enabled; /*ON/OFF indicates remotely enabled	*/  
  struct op_byte_field procedure;      /* From SS_DIVERSION_ constants	*/  
  struct op_byte_field basic_service;  /* From SS_BASIC_SERVICE_ constants	*/  
  struct acu_address   diverted_to;    /* Address that served user is 	*/  
                                       /* forwarded to 	*/  
  struct acu_party_num served_user;    /* Served user's address 	*/  
  uchar                complete;       /* ON when no more messages	*/  
                                       /* coming, OFF if more coming 	*/  
                                       /* Note: when ON, other fields 	*/  
  pad7                                 /* might not be invoked 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

If the network encounters an error, an acu_ss_enquire_divert_ret_error extended data structure is returned in an ACU indication message. The service header to this structure contains:

The following is a listing of the acu_ss_enquire_divert_ret_error extended data structure:

struct acu_ss_deact_divert_ret_error  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
  ushort             err_id;  /* From DEACT_DIVERT_RETERR_ constants	*/  
  pad6  
};

The err_id field contains the cause for the error, from ENQUIRE_DIVERT_RETERR constants (see Appendix C).

The stack notifies the application when it learns that an inbound or outbound call has been diverted.

The connection id of the outbound call is included in the data structure.

The following is a listing of the acu_ss_notify_diversion_invoke extended data structure:

struct acu_ss_notify_diversion_invoke  
{  
  struct acu_ext_hdr    ext_hdr;         /* Extension header 	*/  
  struct acu_ss_hdr     ss_hdr;          /* Supp. services header 	*/  
  struct op_byte_field  reason;          /* Reason for diversion, from	*/  
                                         /* ACU_SS_DIVERSION_constants 	*/  
  struct op_byte_field  basic_service;   /* From ACU_SS_BASIC_SERVICE_...	*/  
                                         /* constants	*/  
  struct acu_conn_id    related_conn_id; /* Identifies related connection	*/  
  struct op_byte_field  subscription;    /* Subscription option for 	*/  
                                         /* presentation 	*/  
  struct acu_party_num  redir_nb;        /* At directed-to user, number	*/  
                                         /* doing redirection	*/  
  struct acu_party_num  orig_redir_nb;   /* At directed-to user, first	*/  
                                         /* number doing redirection	*/  
  struct acu_party_num  nominated_nb;    /* Indicates new destination	*/  
                                         /* number to calling user	*/  
  struct acu_party_name redir_name;      /* Name of user invoking the	*/  
                                         /* diversion 	*/  
  struct acu_party_name orig_redir_name; /* At diverted-to user, first	*/  
                                         /* name doing redirection	*/  
  uchar                 completed;       /* ON  = diversion completed, 	*/  
                                         /* OFF = diversion in progress 	*/  
  uchar                 diversion_count; /* Passed up to application in	*/  
  pad6                                   /* acu_ss_divert_invoke 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

Multiple diversion operations may cause several of these primitives to be sent to the application, as additional information is provided by the network. (See Figure 26.) If the offered call is diverted multiple times, then the fields within the primitive may contain new information which should supersede previous information.

Figure 26: Notification That an Outbound Call Has Been Diverted

When an inbound call has been diverted by the network, the application is notified. An ACU_FACILITY_IN message is sent to the application using the ACU_SAPI_MGT SAPI using a dummy connection id. This message contains an acu_ss_divert_ret_result extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_divert_ret_result extended data structure:

struct acu_ss_divert_ret_result  
{  
  struct acu_ext_hdr   ext_hdr;          /* Extension header 	*/  
  struct acu_ss_hdr    ss_hdr;           /* Supp. services header 	*/  
  struct op_byte_field reason;           /* Reason for diversion, from,	*/  
                                         /* ACU_SS_DIVERSION_... macros 	*/  
  struct op_byte_field basic_service;    /* Applies in CC->APP in some	*/  
                                         /* variants. From BASIC_SERVICE	*/  
                                         /* constants 	*/  
  struct acu_address   calling_party;    /* Calling party	*/  
  struct acu_address   served_user;      /* Served user	*/  
  struct acu_party_num orig_called;      /* Original called number	*/  
  struct acu_party_num last_redirecting; /* Last redirecting number	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

Figure 27: Result of an Inbound Call Which Has Been Diverted

AreIf the served user has activated Call Diversion services, whenever the served user initiates an outbound call, the Remind Diversion services can "remind" the application that Call Diversion services are activated. If the Remind Diversion service is active, an acu_ss_reminder_diversion_invoke supplementary service structure is returned to the application in the first incoming call control message. The service header to this structure contains:

The following is a listing of the acu_ss_reminder_diversion_invoke extended data structure:

struct acu_ss_reminder_diversion_invoke  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
};

No additional data is sent.

Any incoming call control message can carry the Remind Diversion message (ACU_CONN_CO, ACU_ALERT_IN, etc.)

Remind Diversion can optionally be activated when the user first subscribes to PRI services. It cannot be remotely activated or invoked by the application.

If the application has activated Call Diversion only for calls of a specific basic service type, the Remind Diversion message is returned only when the served user makes an outbound call of that service type. For example, if the application has activated Call Diversion only for teletex calls, the Remind Diversion message is returned only when the served user makes a teletex call.

Figure 28: Remind Diversion

Q.SIG describes interactions between nodes in a network. This section describes how call diversion services work from three perspectives:

Figure 29: Originating, Served User and Diverted-To Nodes

It is important for the developer to recognize that the application layer must participate in the diversion by interworking the events on the A<->B and A<->C legs of the call.

The following is a state diagram for the Call Diversion service in the AG ISDN Q.SIG implementation (from the originating user's perspective):

Figure 30: Call Diversion Service State Diagram (Q.SIG)

With the AG ISDN Q.SIG implementation, the application at the originating node is responsible for attempting to reroute a call if it is requested to do so by the served user node's application. When the originating node offers a call to the served user node, the served user application requests the diversion by sending an acu_ss_diversion_invoke extended data structure to the stack in an ACU request message. The service header to this structure must contain:

The following is a listing of the acu_ss_diversion_invoke structure:

struct acu_ss_divert_invoke  
{  
  struct acu_ext_hdr    ext_hdr;          /* Extension header 	*/  
  struct acu_ss_hdr     ss_hdr;           /* Supp. services header 	*/  
  struct acu_address    divert_to_nb;     /* Number of new called party	*/  
  struct acu_party_num  divert_from_nb;   /* No. called in last setup, if	*/  
                                          /*different from orig_called_nb	*/  
  struct acu_party_num  orig_called_nb;   /* Number called in first setup	*/  
  struct acu_address    calling_nb;       /* Calling number in last setup 	*/  
  struct acu_party_name calling_name;     /* Calling name in last setup 	*/  
  struct acu_party_name redir_name;       /* Name of user invoking this	*/  
                                          /* diversion 	*/  
  struct acu_party_name orig_called_name; /* Name of orig. called party	*/  
  uchar                 procedure;        /* From ACU_SS_DIVERSION_...	*/  
                                          /* constants	*/  
  uchar                 diversion_count;  /* Passed to app, meaningless	*/  
                                          /* from application 	*/  
  uchar                 subscription;     /* From SS_SUBSCRIPTION_ 	*/  
  pad5                                    /* constants 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

After the alert, the originating node offers the call to the diverted-to node by sending an ACU_CONN_RQ message to the stack, containing an acu_ss_notify_diversion_invoke extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_notify_diversion_invoke extended data structure:

struct acu_ss_notify_diversion_invoke  
{  
  struct acu_ext_hdr    ext_hdr;         /* Extension header 	*/  
  struct acu_ss_hdr     ss_hdr;          /* Supp. services header 	*/  
  struct op_byte_field  reason;          /* Reason for diversion, from	*/  
                                         /* ACU_SS_DIVERSION_ constants 	*/  
  struct op_byte_field  basic_service;   /* From ACU_SS_BASIC_SERVICE_	*/  
                                         /* constants	*/  
  struct acu_conn_id    related_conn_id; /* Identifies related connection	*/  
  struct op_byte_field  subscription;    /* Subscription option for 	*/  
                                         /* presentation 	*/  
  struct acu_party_num  redir_nb;        /* At directed-to user, number	*/  
                                         /* doing redirection	*/  
  struct acu_party_num  orig_redir_nb;   /* At directed-to user, first	*/  
                                         /* number doing redirection	*/  
  struct acu_party_num  nominated_nb;    /* Indicates new destination	*/  
                                         /* number to calling user	*/  
  struct acu_party_name redir_name;      /* Name of user invoking the	*/  
                                         /* diversion 	*/  
  struct acu_party_name orig_redir_name; /* At diverted-to user, first	*/  
                                         /* name doing redirection	*/  
  uchar                 completed;       /* ON  = diversion completed,	*/  
                                         /* OFF = diversion in progress 	*/  
  uchar                 diversion_count; /* Passed up to application in	*/  
  pad6                                   /* acu_ss_divert_invoke 	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

When the diverted-to node receives this request, it responds with an acu_ss_notify_diversion_ret_result extended data structure. This may be carried in an ACU_FACILITY_IN, ACU_CONN_CO, or ACU_ALERT_IN message. The message may also contain the presentation restrictions concerning the diverted-to party. (See Figure 31.)

The following is a listing of the acu_ss_notify_diversion_ret_result extended data structure:

struct acu_ss_notify_diversion_ret_result  
{  
  struct acu_ext_hdr    ext_hdr;      /* Extension header 	*/  
  struct acu_ss_hdr     ss_hdr;       /* Supp. services header 	*/  
  struct acu_party_name redir_name;   /* Redirection Name 	*/  
  ushort                pres_allowed; /* Indicates whether diverted-to	*/  
  pad6                                /* number can be presented(ON/OFF)	*/  
};

The following is a list of the fields in this structure (other than the header fields), and when they are used.

Figure 31: Q.SIG Diversion Notification

If a diversion is unsuccessful, the diverted-to node sends the originating node an ACU request message containing an acu_ss_divert_ret_error extended data structure. The structure's header contains:

The following is a listing of the acu_ss_divert_ret_error extended data structure:

struct acu_ss_divert_ret_error  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
  ushort             err_id;  /* From DIVERT_RETERR constants 	*/  
  pad6  
};

The err_id field contains the reason for the error, from DIVERT_RETERR constants listed in Appendix C.

The following sections illustrate the sequence of messages passed between the three nodes in the following scenarios:

The diagrams in the following sections are based on Figures C.1, C.2 and C.3 in Appendix C of ISO/IEC 13873. The ACU interface is made to resemble the interaction between the SS-DIV control entity with the user. However, certain modifications are necessary to take into account the "real" Q reference point is in the application, and not in the stack. Therefore, some data that would not be sent to the user is sent to the application.

Also, Figures C.1 and C.2 of the ISO/IEC specification have been combined into a single ACU interface, because the diversion services will always be invoked on the originating node (i.e. diversion by forward switching is not supported).

The following diagram illustrates the message types passed between nodes when a Call Forward - Unconditional succeeds.

In this scenario, the application on PINX 2 has been set up to forward all calls destined for user B to user C.

Note: This scenario is identical for Call Forward - Busy (CFB) except for the operation ids.

Figure 32: Successful Call Forward - Unconditional

The following diagram illustrates the message types passed between nodes when a Call Forward - Unconditional fails, because the diverted-to node rejects the call or returns an error.

In this scenario, the application on PINX 2 has been set up to forward all calls destined for user B to user C.

Note: This scenario is identical for Call Forward - Busy (CFB) except for the operation ids.

Figure 33: Failed Call Forward - Unconditional

The following diagram illustrates the message types passed between nodes when a Call Forward - No Response succeeds.

In this scenario, the application on PINX 2 has been set up to forward all calls destined for user B to user C if user B does not respond within a period of time.

Figure 34: Successful Call Forward - No Response

The following diagram illustrates the message types passed between nodes when a Call Forward - No Response fails, because the diverted-to node rejects the call or returns an error.

In this scenario, the application on PINX 2 has been set up to forward all calls destined for user B to user C if user B does not respond within a period of time.

Figure 35: Unsuccessful Call Forward - No Response

The following diagram illustrates the message types passed between nodes when a Call Forward - No Response is aborted during the forwarding attempt, because the served user node senses that the user to whom the call was originally destined has answered.

In this scenario, the application on PINX 2 has been set up to forward all calls destined for user B to user C if user B does not respond within a period of time.

Figure 36: Aborted Call Forward - No Response

Call Deflection services allow calls presented to the served user to be rerouted to a different address. Call deflection is a service which is only applicable to user/network type interfaces such as ETS 300, and not to peer-to-peer interfaces such as Q.SIG.

An ETS 300 served user application can use the Call Deflection service in either of two ways:

Regardless of which service is used, the diverted-to user is always notified of a forwarded call, using a Notify Diversion operation.

Activation of the call deflection service has only local significance (i.e. no signaling information is exchanged with the remote peer). It applies only to activation/deactivation on an NAI basis, for all served users.

To activate call deflection for an NAI, the application sends an ACU request message to the stack to the ACU_MGMT_SAPI, containing an acu_ss_activate_deflect_invoke extended data structure. The service header to this structure must contain:

The following is a listing of the acu_ss_activate_deflect_invoke extended data structure:

struct acu_ss_activate_deflect_invoke  
{  
  struct acu_ext_hdr ext_hdr;    /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;     /* Supp. services header 	*/  
  struct acu_address deflect_to; /* Address to deflect all calls to 	*/  
};

The deflect_to field is mandatory. It contains the address to which the number is deflected.

If call deflection is successfully activated, the stack returns an ACU indication message to the application, containing an acu_ss_activate_deflect_ret_result extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_activate_deflect_ret_result extended data structure:

struct acu_ss_activate_deflect_ret_result  
{  
  struct acu_ext_hdr ext_hdr;    /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;     /* Supp. services header 	*/  
};

No additional data is sent in this structure.

Figure 37: Activation of Call Deflection

If Call Deflection is not successfully activated, the stack returns an ACU indication message to the application, containing an acu_ss_reject extended data structure. The service header to this structure contains:

For more information about the acu_ss_reject structure, see Section 3.9.

If Call Deflection is activated for all calls on an NAI, the application receives a notification when a call has been deflected, via the ACU_MGMT_SAPI. The stack returns an ACU indication message to the application, containing an acu_ss_deflect_ret_result extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_deflect_ret_result extended data structure:

struct acu_ss_deflect_ret_result  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
};

No additional data is sent in this structure.

Figure 38 shows the exchange of messages that takes place when Call Deflection is activated for an NAI. In this scenario, user A is calling user B, and user B (i.e. PBX) deflects the call to user C.

Figure 38: Deflect All Calls at Served User

To deactivate call deflection for an NAI, the application sends an ACU request message to the stack to the ACU_MGMT_SAPI, containing an acu_ss_deactivate_deflect_invoke extended data structure. The service header to this structure must contain:

The following is a listing of the acu_ss_deactivate_deflect_invoke extended data structure:

struct acu_ss_deactivate_deflect_invoke  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
};

No additional data is sent in this structure.

If call deflection is successfully deactivated, the stack returns an ACU indication message to the application, containing an acu_ss_deactivate_deflect_ret_result extended data structure. The service header to this structure contains:

The following is a listing of the acu_ss_activate_deflect_ret_result extended data structure:

struct acu_ss_deactivate_deflect_ret_result  
{  
  struct acu_ext_hdr ext_hdr; /* Extension header 	*/  
  struct acu_ss_hdr  ss_hdr;  /* Supp. services header 	*/  
};

No additional data is sent in this structure.

If call deflection is not successfully deactivated, the stack returns an ACU indication message to the application, containing an acu_ss_reject extended data structure. The service header to this structure contains:

For more information about the acu_ss_reject structure, see Section 3.9.

The call deflection service can be invoked by the served user on an incoming call if the call state is WAIT_INCOMING.

The stack must not be configured to automatically send the ALERT on incoming calls. Otherwise, the deflection will fail due to invalid states at the network side.

Note: Note that the ALERT is sent by default on the user side when no structure is passed to isdnStartProtocol. To change this behavior, change the settings of the CC_VOICE_ALERT_RQ and CC_DATA_ALERT_RQ bits in the in_calls_behavior substructure (described in the AG ISDN Messaging API Developer's Reference Manual). You can cause the stack to send a PROC RQ instead by setting the CC_SEND_CALL_PROC_RQ bit.

To invoke call deflection for a call, the application sends an ACU request message to the stack, containing an acu_ss_deflect_invoke extended data structure. The service header to this structure must contain: