Compare Revisions

The credentials to download the source code are:
 Username: svnusers
 Password: svnusers

Ignore whitespace Rev 207 → Rev 208

/tags/v3.0.0/ttcn/LibIms_Interface.ttcn
0,0 → 1,22
/**
* @author STF471
* @version $Id$
* @desc This module provides the component type for SIP-IMS tests.
* This module is part of LibImsV3.
*/
module LibIms_Interface {
// LibSip
import from LibSip_Interface all;
// LibIms
import from LibIms_SIPTypesAndValues all;
 
group adressTypes {
 
type component ImsComponent extends SipComponent {
// general variables
var ImsInterfaceProfile vc_interfaceprofile;
} // end ImsComponent
 
 
} // end group AdressTypes
} // end module LibIms_TestSystem
Property changes:
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: tags/v3.0.0/ttcn/LibIms_Steps.ttcn
===================================================================
--- tags/v3.0.0/ttcn/LibIms_Steps.ttcn (nonexistent)
+++ tags/v3.0.0/ttcn/LibIms_Steps.ttcn (revision 208)
@@ -0,0 +1,1492 @@
+/**
+ * @author STF471
+ * @version $Id$
+ * @desc This module provides the steps used by the test component for SIP-IMS tests.
+ * This module is part of LibImsV3.
+ */
+module LibIms_Steps {
+ // LibSip
+ import from LibSip_SIPTypesAndValues all;
+ import from LibSip_Templates all;
+ import from LibSip_Steps all;
+ import from LibSip_PIXITS all;
+ import from LibSip_Interface all;
+ import from LibSip_MessageBodyTypes all;
+ // LibIms
+ import from LibIms_Templates all;
+ import from LibIms_Interface all;
+ import from LibIms_SIPTypesAndValues all;
+
+ group externalfunctions {
+ } // end group externalfunctions
+ group parameterOperations {
+
+ /**
+ * @desc Adds new Via parameter
+ * @param p_message (request) SIP message to be used to prepair via header
+ */
+ function f_addNewViaParameter(
+ in Request p_message
+ ) runs on ImsComponent {
+ var integer v_intVia;
+ var integer i := 0;
+ if (isvalue(p_message.msgHeader.via)) {
+
+ v_intVia := lengthof(p_message.msgHeader.via.viaBody);
+ while (i < v_intVia) {
+ p_message.msgHeader.via.viaBody[v_intVia] := p_message.msgHeader.via.viaBody[v_intVia - 1];
+ v_intVia := v_intVia - 1;
+ }
+ vc_branch := c_branchCookie & f_getRndTag();
+ p_message.msgHeader.via.viaBody[0] := valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile));
+ vc_via := p_message.msgHeader.via;
+ }
+ }
+
+ /**
+ * @desc Removes own Via parameter
+ * @param p_message (request) SIP message to be used to prepair via header
+ */
+ function f_removeOwnViaParameter(
+ in Response p_message
+ ) runs on ImsComponent {
+ var integer v_intVia;
+ var Via v_via := c_empty_Via;
+ var integer i := 0;
+
+ if (ispresent(p_message.msgHeader.via)) {
+
+ v_intVia := lengthof(p_message.msgHeader.via.viaBody) - 1;
+
+ for (i := 0; i < v_intVia; i := i + 1) {
+ v_via.viaBody[i] := p_message.msgHeader.via.viaBody[i + 1];
+ }
+ vc_via := v_via;
+ }
+ }
+
+ /**
+ * @desc Adds new RecordRoute parameter and removes Route parameter
+ * @param p_message (request) SIP message to be used to prepair via header
+ */
+ function f_addNewRecordRouteAndRemoveRoutParameter(
+ in Request p_message
+ ) runs on ImsComponent {
+ var integer v_intRoute, v_intRecordRoute;
+ var integer i := 1;
+ var RouteBody v_route1;
+ var Route v_newRoute;
+ v_newRoute.fieldName := ROUTE_E;
+ if (isvalue(p_message.msgHeader.route)) {
+ v_intRoute := lengthof(p_message.msgHeader.route.routeBody);
+ v_route1 := p_message.msgHeader.route.routeBody[0];
+ while (i < v_intRoute) {
+ v_newRoute.routeBody[i - 1] := p_message.msgHeader.route.routeBody[i];
+ i := i + 1;
+ }
+ vc_route := v_newRoute;
+ }
+
+ if (isvalue(p_message.msgHeader.recordRoute)) {
+
+ v_intRecordRoute := lengthof(p_message.msgHeader.recordRoute.routeBody);
+ while (0 < v_intRecordRoute) {
+ p_message.msgHeader.recordRoute.routeBody[v_intRecordRoute] := p_message.msgHeader.recordRoute.routeBody[v_intRecordRoute - 1];
+ v_intRecordRoute := v_intRecordRoute - 1;
+ }
+ p_message.msgHeader.recordRoute.routeBody[0] := v_route1;
+ vc_recordRoute := valueof(p_message.msgHeader.recordRoute);
+ }
+ }
+
+ /**
+ * @desc Adds new RecordRoute parameter (IMS)
+ * @param p_rr The recordRoute parameter to add
+ */
+ function f_addNewRecordRouteIMS(
+ in RecordRoute p_rr
+ ) runs on ImsComponent
+ return template RecordRoute {
+ var integer v_intRecordRoute;
+ var template RecordRoute v_recordRoute := omit;
+
+ v_intRecordRoute := lengthof(p_rr.routeBody);
+ if (v_intRecordRoute > 0) {
+ while (0 < v_intRecordRoute) {
+ p_rr.routeBody[v_intRecordRoute] := p_rr.routeBody[v_intRecordRoute - 1];
+ v_intRecordRoute := v_intRecordRoute - 1;
+ }
+ p_rr.routeBody[0] := valueof(m_routeBody_currIpAddr(vc_userprofile));
+ vc_recordRoute := p_rr;
+ return vc_recordRoute;
+ }
+ else {
+ return (v_recordRoute);
+ }
+ }
+
+ } // end group parameterOperations
+
+ group fieldOperations {
+
+ /**
+ * @desc Sets BYE header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersBYE(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ vc_route := f_route(); // update the route header field depending on vc_boo_route
+ vc_recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
+ LibSip_Steps.f_setHeadersBYE(p_cSeq_s);
+ } // end f_setHeadersBYE
+
+ /**
+ * @desc Sets CANCEL header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ */
+ function f_setHeadersCANCEL(
+ inout CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ vc_route := f_route(); // update the route header field depending on vc_boo_route
+ vc_recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
+ LibSip_Steps.f_setHeadersCANCEL(p_cSeq_s);
+ } // end f_setHeadersCANCEL
+
+ /**
+ * @desc Sets headers for forward request from AS in case if AS acts as Proxy
+ * @param p_cSeq_s The current cSeq
+ * @param p_proxyMode true = proxyMode, false = B2BMode
+ */
+ function f_setHeadersForwardRequestFromAS(
+ inout CSeq p_cSeq_s,
+ boolean p_proxyMode
+ ) runs on ImsComponent {
+ var Request v_request;
+ v_request := vc_request;
+
+ if (p_proxyMode) {
+ vc_requestUri2 := v_request.requestLine.requestUri;
+ vc_to := v_request.msgHeader.toField;
+ vc_contact := v_request.msgHeader.contact;
+ f_addNewViaParameter(v_request);
+ f_addNewRecordRouteAndRemoveRoutParameter(v_request);
+ }
+ else {
+ // B2Bmode
+ vc_contact := m_Contact(m_SipUrl_contactIpaddr(vc_userprofile));
+ vc_callId := {
+ fieldName := CALL_ID_E,
+ callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
+ };
+ }
+ } // end function f_setHeadersForwardRequest
+
+ /**
+ * @desc Sets header fields for forward request from AS in case if AS acts as Proxy
+ */
+ function f_setHeadersForwardResponseFromAS(
+ ) runs on ImsComponent {
+ var Response v_response;
+ v_response := vc_response;
+
+ vc_caller_To := v_response.msgHeader.toField;
+ vc_to := v_response.msgHeader.toField;
+ vc_contact := v_response.msgHeader.contact;
+
+ if (ispresent(v_response.msgHeader.recordRoute)) {
+ vc_recordRoute := v_response.msgHeader.recordRoute;
+ }
+ f_removeOwnViaParameter(v_response);
+ } // end function f_setHeadersForwardResponse
+
+ /**
+ * @desc Sets Invite header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersINVITE(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ if (vc_boo_route) {
+ vc_route := m_route_interface(vc_interfaceprofile);
+ }
+ if (vc_boo_recordRoute) {
+ vc_recordRoute := m_recordRoute_currIpAddr(vc_userprofile);
+ }
+
+ LibSip_Steps.f_setHeadersINVITE(p_cSeq_s);
+ } // end f_setHeadersINVITE
+
+ /**
+ * @desc Sets Invite header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersUPDATE(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ if (vc_boo_route) {
+ vc_route := m_route_interface(vc_interfaceprofile);
+ }
+ if (vc_boo_recordRoute) {
+ vc_recordRoute := m_recordRoute_currIpAddr(vc_userprofile);
+ }
+
+ LibSip_Steps.f_setHeadersUPDATE(p_cSeq_s);
+ } // end f_setHeadersUPDATE
+
+ /**
+ * @desc Sets Message header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersMESSAGE(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ LibSip_Steps.f_setHeadersMESSAGE(p_cSeq_s);
+ } // end f_setHeadersMESSAGE
+
+ /**
+ * @desc Sets Notify header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersNOTIFY(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ LibSip_Steps.f_setHeadersNOTIFY(p_cSeq_s);
+
+ vc_branch := c_branchCookie & f_getRndTag();
+ vc_via := {
+ fieldName := VIA_E,
+ viaBody := {valueof(m_ViaBody_virtual_XCSCF(vc_branch, vc_userprofile))}
+ };
+
+ vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ // contact header initialization for sending of NOTIFY from CSCF component
+ vc_contact := m_Contact(m_SipUrl_currIpaddr_CSCF(vc_userprofile));
+ } // end f_setHeadersNOTIFY
+
+ /**
+ * @desc Sets Publish header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersPUBLISH(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ LibSip_Steps.f_setHeadersPUBLISH(p_cSeq_s);
+
+ vc_branch := c_branchCookie & f_getRndTag();
+ vc_via := {
+ fieldName := VIA_E,
+ viaBody := {valueof(m_ViaBody_virtual_XCSCF(vc_branch, vc_userprofile))}
+ };
+
+ vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ if (vc_boo_route) {
+ vc_route := m_route_interface(vc_interfaceprofile);
+ }
+ if (vc_boo_recordRoute) {
+ vc_recordRoute := m_recordRoute_currIpAddr(vc_userprofile);
+ }
+
+ // contact header initialization for sending of PUBLISH from CSCF component
+ vc_contact := m_Contact(m_SipUrl_currIpaddr_CSCF(vc_userprofile));
+ } // end f_setHeadersPUBLISH
+
+ /**
+ * @desc Sets Subscribe header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersSUBSCRIBE(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_to := {
+ fieldName := TO_E,
+ addressField := {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := p_to_user // SipUrl
+ }
+ }, // end addressField
+ toParams := omit
+ };
+ vc_from := f_initFromHeader(p_to_user, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ LibSip_Steps.f_setHeadersSUBSCRIBE(p_cSeq_s);
+ } // end f_setHeadersSUBSCRIBE
+
+ /**
+ * @desc Sets headers for ReINVITE method
+ * @param p_cSeq_s The current cSeq
+ * @param p_orginatingSide true in case of Re-INVITE is send from the orgination endpoint otherwise false.
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersReINVITE(
+ inout CSeq p_cSeq_s,
+ in boolean p_orginatingSide,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ var integer v_tmp, i, j, v_nbroute;
+ var Request v_request;
+ v_request := vc_request;
+
+ f_setHeadersGeneral(p_cSeq_s, "INVITE"); // cseq, contact, branch, via
+ vc_reqHostPort := vc_requestUri.components.sip.hostPort;
+
+ vc_requestUri := p_to_user;
+
+ if (p_orginatingSide) {
+ vc_to := vc_caller_To;
+ vc_from := vc_caller_From;
+ }
+ else {
+ vc_to := vc_callee_To;
+ vc_from := vc_callee_From;
+
+ // get route from previous ACK request
+ // Route Management
+ if (isvalue(v_request.msgHeader.recordRoute)) {
+ vc_recordRoute := valueof(v_request.msgHeader.recordRoute);
+ v_nbroute := lengthof(vc_recordRoute.routeBody);
+ // copy and reverse the order of the routes in route header
+ for (i := 0; i <= (v_nbroute - 1); i := i + 1) {
+ j := v_nbroute - 1 - i;
+ vc_route.routeBody[j] := vc_recordRoute.routeBody[i];
+ }
+ vc_route.fieldName := ROUTE_E;
+ vc_boo_recordRoute := true;
+ vc_boo_route := true;
+ }
+ else {
+ vc_boo_recordRoute := false;
+ vc_boo_route := false;
+ }
+ }
+
+ v_tmp := str2int(vc_sdp_local.origin.session_id);
+ vc_sdp_local.origin.session_id := int2str(v_tmp + 1);
+ v_tmp := str2int(vc_sdp_local.origin.session_version);
+ vc_sdp_local.origin.session_version := int2str(v_tmp + 1);
+ } // end function f_setHeadersReINVITE
+
+ /**
+ * @desc Sets component variables related to message header fields when sending requests from the home I-CSCF (TS) to the visited P-CSCF (SUT) (message type independent: CSeq, contact, via), function uses information from userprofile and interfaceprofile
+ * @param p_cSeq_s The CSeq parameter
+ * @param p_method The method name for cSeq header field
+ */
+ function f_setHeadersGeneral_ICSCF(
+ inout CSeq p_cSeq_s,
+ in charstring p_method
+ ) runs on SipComponent {
+ p_cSeq_s.fieldName := CSEQ_E;
+ p_cSeq_s.seqNumber := p_cSeq_s.seqNumber + 1;
+ p_cSeq_s.method := p_method;
+ vc_cSeq := p_cSeq_s;
+
+ vc_contact := m_Contact(m_SipUrl_contactIpaddr(vc_userprofile));
+
+ vc_branch := c_branchCookie & f_getRndTag();
+ vc_branch_ICSCF := c_branchCookie & f_getRndTag();
+
+ vc_via := {
+ fieldName := VIA_E,
+ viaBody := {
+ valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile)),
+ valueof(m_ViaBody_virtualUEinPCSCF(vc_branch_ICSCF, vc_userprofile))
+ }
+ };
+ } // end function f_setHeadersGeneral_ICSCF
+
+ /**
+ * @desc Sets header field for the next outgoing REGISTER message from the visited P-CSCF to the home I-CSCF
+ * @param p_cSeq_s The CSeq parameter to be applied
+ */
+ function f_setHeaders_REGISTER_PCSCF(
+ inout CSeq p_cSeq_s
+ ) runs on SipComponent {
+ var SemicolonParam_List v_params;
+
+ f_setHeadersGeneral(p_cSeq_s, "REGISTER"); // cseq, contact, branch, via
+ vc_requestUri := {
+ scheme := c_sipScheme,
+ components := {
+ sip := {
+ userInfo := omit,
+ hostPort := {
+ host := vc_userprofile.registrarDomain,
+ portField := omit
+ }
+ }
+ },
+ urlParameters := omit,
+ headers := omit
+ };
+
+ vc_reqHostPort := vc_requestUri.components.sip.hostPort;
+
+ vc_callId := {
+ fieldName := CALL_ID_E,
+ callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
+ };
+ vc_callIdReg := vc_callId;
+
+ vc_to := valueof(m_To(m_SipUrl_currDomain(vc_userprofile)));
+ v_params := {
+ {
+ id := c_tagId,
+ paramValue := {
+ tokenOrHost := f_getRndTag()
+ }
+ }
+ };
+ vc_from := {
+ fieldName := FROM_E,
+ addressField := vc_to.addressField,
+ fromParams := v_params
+ };
+
+ if (not vc_firstREGISTER_sent) {
+ v_params := {
+ {
+ id := c_expiresId,
+ paramValue := {
+ tokenOrHost := c_shortRegistration
+ }
+ }
+ };
+ vc_contact.contactBody.contactAddresses[0].contactParams := v_params;
+ }
+
+ vc_firstREGISTER_sent := true; // f_setHeaders_Register is called in deREGISTER function
+ vc_authorization := {
+ fieldName := AUTHORIZATION_E,
+ body := {f_calculatecCredentials_empty(vc_userprofile)}
+ };
+ } // end function setHeaders_REGISTER_PCSCF
+
+ /**
+ * @desc Sets REFER header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_to_user The selected user's SIP URL
+ */
+ function f_setHeadersREFER(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user
+ ) runs on ImsComponent {
+ vc_requestUri := p_to_user; // Request URI of Invite is identical with To header
+ if (vc_boo_route) {
+ vc_route := m_route_interface(vc_interfaceprofile);
+ }
+ if (vc_boo_recordRoute) {
+ vc_recordRoute := m_recordRoute_currIpAddr(vc_userprofile);
+ }
+
+ LibSip_Steps.f_setHeadersREFER(p_cSeq_s);
+ } // end f_setHeadersREFER
+
+ /**
+ * @desc Sets REFER header fields (IMS addresses) extension of general settings from LibSip basic function
+ * @param p_cSeq_s The current cSeq
+ * @param p_uri The SipUrl for request URI and To header
+ */
+ function f_setHeadersREFER_conf(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_uri
+ ) runs on ImsComponent {
+ vc_to := {
+ fieldName := TO_E,
+ addressField := {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := p_uri // SipUrl
+ }
+ }, // end addressField
+ toParams := omit
+ };
+
+ vc_from := f_initFromHeader(p_uri, f_getRndTag()); // init of vc_from using userProfile identifier
+ vc_requestUri := p_uri; // Request URI of Invite is identical with To header
+ if (vc_boo_route) {
+ vc_route := m_route_interface(vc_interfaceprofile);
+ }
+ if (vc_boo_recordRoute) {
+ vc_recordRoute := m_recordRoute_currIpAddr(vc_userprofile);
+ }
+
+ LibSip_Steps.f_setHeadersREFER(p_cSeq_s);
+ } // end f_setHeadersREFER_conf
+
+ } // end group fieldOperations
+
+ group awaitingMessage {
+ }
+
+ group sendMessage {
+
+ /**
+ * @desc Sends PRACK message
+ * @param p_mb The message body of the PRACK message
+ * @param p_rack_cseq The cSeq of the PRACK message
+ */
+ function f_sendPRACK_sdp(
+ template(value) MessageBody p_mb,
+ CSeq p_rack_cseq
+ ) runs on SipComponent {
+ var integer v_responseNum := 1;
+ var template(value) PRACK_Request v_prackReq;
+
+ f_setHeadersGeneral(vc_cSeq, "PRACK"); // cseq, contact, branch, via
+ if (isvalue(vc_response.msgHeader.rSeq.responseNum)) {
+ v_responseNum := vc_response.msgHeader.rSeq.responseNum;
+ }
+ vc_rAck := m_RAck(v_responseNum, p_rack_cseq.seqNumber, p_rack_cseq.method);
+
+ v_prackReq := m_PRACK_Request_sdp(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via, vc_rAck, p_mb);
+
+ // added route header if required
+ if (isvalue(vc_response.msgHeader.recordRoute)) {
+ v_prackReq.msgHeader.route := f_route();
+ }
+
+ SIPP.send(v_prackReq) to vc_sent_label;
+ }
+
+ }
+ group globalSteps {
+
+ //NOTE STF471: removed function f_init_userprofile, have to move up to specific ATS
+
+ /**
+ * @desc Initializes the To header
+ * @param p_user Identifies the selected user's SIP URL
+ * @return The To header
+ */
+ function f_initToHeader(
+ in SipUrl p_user
+ ) runs on ImsComponent
+ return To {
+ var To v_to := c_empty_To;
+ v_to := {
+ fieldName := TO_E,
+ addressField := {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := p_user // SipUrl
+ }
+ }, // end addressField
+ toParams := omit
+ };
+ return (v_to);
+ }
+
+ /**
+ * @desc Initializes the From header
+ * @param p_user Identifies the selected user' SIP URL
+ * @param p_tag_str The string value of the tag id
+ * @return The From header
+ */
+ function f_initFromHeader(
+ in SipUrl p_user,
+ charstring p_tag_str
+ ) runs on ImsComponent
+ return From {
+ var From v_from := c_empty_From;
+ v_from := {
+ fieldName := FROM_E,
+ addressField := {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := p_user // SipUrl
+ }
+ }, // end addressField
+ fromParams := {
+ {
+ id := c_tagId,
+ paramValue := {
+ tokenOrHost := p_tag_str
+ }
+ }
+ }
+ };
+ return v_from;
+ }
+
+ //NOTE STF471: removed function f_initSipUrl, have to move up to specific ATS
+
+ //NOTE STF471: removed function f_init_interfaceprofile, have to move up to specific ATS
+
+ /**
+ * @desc Retrieves user DomainPort value of the user profile
+ * @param p_userProfile Identifies the selected user profile
+ * @return The Domain HostPort
+ */
+ function f_get_userDomainPort(
+ in SipUserProfile p_userProfile
+ ) runs on ImsComponent
+ return HostPort {
+ return
+ {
+ p_userProfile.homeDomain,
+ p_userProfile.currPort
+ };
+ }
+
+ /**
+ * @desc Retrieves HostPort value of the interface profile
+ * @param p_interface Identifies the selected interface
+ * @return The HostPort
+ */
+ function f_get_interfaceHostPort(
+ in ImsInterfaceProfile p_interface
+ ) runs on ImsComponent
+ return HostPort {
+ return
+ {
+ p_interface.SUTIpaddr,
+ p_interface.SUTPort
+ };
+ }
+
+ /**
+ * @desc Retrieves DomainPort value of the interface profile
+ * @param p_interface Identifies the selected interface
+ * @return The Domain HostPort
+ */
+ function f_get_interfaceDomainPort(
+ in ImsInterfaceProfile p_interface
+ ) runs on ImsComponent
+ return HostPort {
+ return
+ {
+ p_interface.SUTHomeDomain,
+ p_interface.SUTPort
+ };
+ }
+
+ /**
+ * @desc Gets the receive template for the NameAddr of the interface
+ * @param p_interface Identifies the selected interface
+ * @return The NameAddr template
+ */
+ function f_get_interfaceNameAddr(
+ in ImsInterfaceProfile p_interface
+ ) runs on ImsComponent
+ return template NameAddr {
+ return mw_SipUrl_SUTinterface(p_interface.SUTIpaddr, p_interface.SUTPort);
+ }
+
+ }
+
+ group registration {
+
+ /**
+ * @desc Registration and authentication
+ * @param p_cSeq_s The current cseq
+ * @param p_auth flag indicating if authentication is needed
+ * @param p_host P-CSCF domain name (formerly value from module parameter PX_IMS_TS_PCSCF_HOME_DOMAIN)
+ * @param p_port P-CSCF port number (formerly value from module parameter PX_IMS_TS_PCSCF_PORT)
+ */
+ function f_Registration_IMS(
+ inout CSeq p_cSeq_s,
+ in boolean p_auth,
+ template(value) charstring p_host,
+ template(value) integer p_port
+ ) runs on SipComponent {
+ f_setHeaders_REGISTER(p_cSeq_s);
+ f_SendREGISTER(m_REGISTER_Request_IMS(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via_REG, vc_contact, m_add_Authorization_digest(vc_authorization, {c_Integrity_protected_no}), p_host, p_port)); // LibSip
+ // awaiting of 401 and sending 2nd REGISTER and awaiting 200 OK REGISTER
+ if (p_auth) {
+ // receiving 401 Unauthorized response.
+ // and Re-send REGISTER request with Authorization header
+ tc_ack.start;
+ alt {
+ [] SIPP.receive(mw_Response_Base(c_statusLine401, vc_callId, p_cSeq_s)) -> value vc_response {
+ tc_ack.stop;
+ // set headers via, cseq and authorization
+ f_setHeaders_2ndREGISTER(p_cSeq_s);
+ f_SendREGISTER(m_REGISTER_Request_IMS(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via_REG, vc_contact, m_add_Authorization_digest(vc_authorization, {c_Integrity_protected_yes}), p_host, p_port)); // LibSip
+ // awaiting 200 OK REGISTER
+ f_awaitingOkResponse(p_cSeq_s);
+ f_getServiceRouteMapIntoRouteInRegistration(vc_response);
+ }
+ [] SIPP.receive(mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) {
+ tc_ack.stop;
+ log("*** " & __SCOPE__ & ": INCONC: Authorization was not requested as expected ***");
+ setverdict(inconc);
+ }
+ }
+ }
+ else {
+ f_awaitingOkResponse(p_cSeq_s);
+ f_getServiceRouteMapIntoRouteInRegistration(vc_response);
+ }
+ } // end function f_Registration_IMS
+
+ /**
+ * @desc awaiting UE1 registration (with authentication)
+ * @param p_cSeq_s The current cseq
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ * @param p_register The expected REGISTER_Request - default: mw_REGISTER_authorizedRequest_IMS
+ */
+ function f_awaitingRegistration_IMS(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user,
+ in charstring p_qop,
+ in template(present) REGISTER_Request p_register :=
+ mw_REGISTER_authorizedRequest_IMS(
+ mw_Authorization_digest(
+ mw_digestResponse(
+ (c_Integrity_protected_yes, c_Integrity_protected_ip_assoc_pending)
+ )
+ )
+ )
+ ) runs on ImsComponent {
+ var SipUrl v_passociated_url;
+
+ // Awaiting 1st REGISTER
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 401 response
+ f_sendResponse(
+ m_Response_WWWauthenticate_IMS(
+ c_statusLine401,
+ vc_callId,
+ p_cSeq_s,
+ vc_caller_From,
+ vc_caller_To,
+ vc_via,
+ m_wwwAuthenticate(
+ f_calculatecChallenge_forWWWAuthorization(
+ p_qop,
+ valueof(vc_authorization.body[0].digestResponse)
+ )
+ )
+ )
+ );
+
+ // Awaiting 2nd REGISTER with authorization header
+ f_awaitingREGISTER(p_register);
+
+ // 200OK to complete the request
+ if (isvalue(vc_request.msgHeader.contact)) {
+ vc_contact := valueof(vc_request.msgHeader.contact);
+ vc_contact.contactBody.contactAddresses[0].contactParams := {
+ {
+ "expires",
+ {
+ tokenOrHost := int2str(3600)
+ }
+ }
+ };
+ }
+ v_passociated_url := vc_caller_From.addressField.nameAddr.addrSpec;
+ f_sendResponse(m_Response_2xxonREGISTER_IMS(c_statusLine200, vc_callId, p_cSeq_s, vc_callee_From, vc_callee_To, vc_via, vc_contact, p_to_user, v_passociated_url));
+ } // end function f_awaitingRegistration_IMS
+
+ /**
+ * @desc Awaiting UE1 registration (with authentication, without security headers)
+ * @param p_cSeq_s The current cseq
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ */
+ function f_awaitingRegistration_IMS_gm(
+ inout CSeq p_cSeq_s,
+ in SipUrl p_to_user,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ vc_ignore_subscribe := true; // handle SUBSCRIBE during the call
+
+ f_awaitingRegistration_IMS(p_cSeq_s, p_to_user, p_qop, mw_REGISTER_authorizedRequest_wo_securityheaders_IMS);
+
+ vc_DeregDone := false;
+ } // end function f_awaitingRegistration_IMS_gm
+
+ /**
+ * @desc Remove registration
+ * @param p_cSeq_s The current cseq
+ * @param p_host P-CSCF domain name (formerly value from module parameter PX_IMS_TS_PCSCF_HOME_DOMAIN)
+ * @param p_port P-CSCF port number (formerly value from module parameter PX_IMS_TS_PCSCF_PORT)
+ */
+ function f_removeRegistration_IMS(
+ inout CSeq p_cSeq_s,
+ template(value) charstring p_host,
+ template(value) integer p_port
+ ) runs on SipComponent {
+ var template(value) REGISTER_Request v_request;
+
+ if (PX_SIP_REGISTRATION) {
+ f_setHeaders_deREGISTER(p_cSeq_s);
+ v_request := m_REGISTER_Request_expires_IMS(vc_requestUri, vc_callIdReg, p_cSeq_s, vc_from, vc_to, vc_via, vc_contact, vc_authorization, p_host, p_port, "0");
+ v_request.msgHeader.route := f_route();
+
+ f_SendREGISTER(v_request);
+ if (PX_SIP_REGISTER_AUTHENTICATION_ENABLED) {
+ // receiving 401 Unauthorized response.
+ // and Re-send REGISTER request with Authorization header
+ tc_ack.start;
+ alt {
+ [] SIPP.receive(mw_Response_Base(c_statusLine401, vc_callIdReg, p_cSeq_s)) -> value vc_response {
+ tc_ack.stop;
+ // set headers via, cseq and authorization
+ f_setHeaders_2ndREGISTER(p_cSeq_s);
+ v_request := m_REGISTER_Request_expires_IMS(vc_requestUri, vc_callIdReg, p_cSeq_s, vc_from, vc_to, vc_via, vc_contact, vc_authorization, p_host, p_port, "0");
+ v_request.msgHeader.route := f_route();
+ // Re-send protected REGISTER
+ f_SendREGISTER(v_request); // LibSip
+ // awaiting 200 OK REGISTER
+ f_awaitingResponse(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq_s));
+ }
+ [] SIPP.receive(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq_s)) -> value vc_response {
+ tc_ack.stop;
+ f_setHeadersOnReceiptOfResponse(vc_response);
+ log("*** " & __SCOPE__ & ": INFO: Authorization was not requested as expected ***");
+ }
+ }
+ }
+ else {
+ f_awaitingResponse(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq_s));
+ }
+ }
+ } // end f_RemoveRegistration_IMS
+
+ } // end group registration
+
+ group preambles {
+
+ /**
+ * @desc Sets variables and default initialization for user profile where proxy role is present
+ * @param p_userprofile User profile of call
+ * @param p_cSeq_s The current cseq
+ */
+ function f_IMS_preamble_MGCF(
+ inout CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ vc_boo_recordRoute := true;
+ vc_boo_route := true;
+ //NOTE STF471: removed f_init_interfaceprofile(c_interfaceProfile_IMS_SUT_MGCF);
+
+ f_IMS_preamble_woRegistration(p_cSeq_s);
+ }
+
+ /**
+ * @desc Sets variables and default initialization for user profile
+ * @param p_cSeq_s The current cseq
+ */
+ function f_IMS_preamble_woRegistration(
+ inout CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ // avoid deregistration in default behavior
+ vc_DeregDone := true;
+ vc_boo_route := true;
+ vc_boo_recordRoute := true;
+
+ // Variables & defaults initialization
+ LibSip_Steps.f_init_component(p_cSeq_s);
+
+ // Preamble
+ //NOTE STF471: removed f_init_userprofile(p_userprofile); // assignment of PIXIT values to component variable
+ vc_sdp_local := valueof(m_SDP_bandwidth(m_media_dynPT(PX_SIP_SDP_DYN, PX_SIP_SDP_ENCODING, PX_SIP_SDP_CLOCKRATE, omit), vc_userprofile));
+ vc_contact := m_Contact(m_SipUrl_contactIpaddr(vc_userprofile));
+ }
+
+ //NOTE STF471 added
+ /**
+ * @desc Sets variables and default initialization for user profile
+ * @param p_cSeq_s The current cseq
+ */
+ function f_IMS_preamble_woRegistration_as(
+ inout CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ // avoid deregistration in default behavior
+ vc_DeregDone := true;
+ vc_boo_route := true;
+ vc_boo_recordRoute := true;
+
+ // Variables & defaults initialization
+ LibSip_Steps.f_init_component(p_cSeq_s);
+
+ // Preamble
+ //NOTE STF471: removed f_init_userprofile(p_userprofile); // assignment of PIXIT values to component variable
+ vc_sdp_local := valueof(m_SDP_bandwidth(m_media_dynPT(PX_SIP_SDP_DYN, PX_SIP_SDP_ENCODING, PX_SIP_SDP_CLOCKRATE, omit), vc_userprofile));
+ }
+
+ /**
+ * @desc Sets variables and default initialization for user profile and handle registration and authentication with MD5
+ * @param p_cSeq_s The current cseq
+ * @param p_register Register template
+ */
+ function f_IMS_preamble_withEmergencyRegistration(
+ inout CSeq p_cSeq_s,
+ template REGISTER_Request p_register
+ ) runs on ImsComponent {
+
+ //NOTE STF471: removed f_init_interfaceprofile(p_interface);
+ // Variables & defaults initialization
+ f_IMS_preamble_woRegistration(p_cSeq_s);
+ // Preamble
+ f_Registration(p_cSeq_s, p_register, PX_SIP_REGISTER_AUTHENTICATION_ENABLED, true);
+
+ // deregistration in case of successful registration
+ vc_DeregDone := false;
+ }
+
+ /**
+ * @desc Sets variables and default initialization for user profile and handle registration and authentication with MD5
+ * @param p_cSeq_s The current cseq
+ * @param p_register Register template
+ */
+ function f_IMS_preamble_withRegistration(
+ inout CSeq p_cSeq_s,
+ out template REGISTER_Request p_register
+ ) runs on ImsComponent {
+
+ //NOTE STF471: removed f_init_interfaceprofile(p_interface);
+ // Variables & defaults initialization
+ f_IMS_preamble_woRegistration(p_cSeq_s);
+
+ // Preamble
+ f_Registration(p_cSeq_s, p_register, PX_SIP_REGISTER_AUTHENTICATION_ENABLED);
+
+ // deregistration in case of successful registration
+ vc_DeregDone := false;
+
+ f_setHeaders_SUBSCRIBE(p_cSeq_s);
+ f_Subscription(p_cSeq_s, m_SUBSCRIBE_Request_UE(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via, vc_contact, vc_route_REG));
+ }
+
+ //NOTE STF471 added
+ /**
+ * @desc Sets variables and default initialization for user profile and handle registration and authentication with MD5
+ * @param p_cSeq_s The current cseq
+ * @param p_register Register template
+ */
+ function f_IMS_preamble_withRegistrationWoSubscription(
+ inout CSeq p_cSeq_s,
+ out template REGISTER_Request p_register
+ ) runs on ImsComponent {
+ //NOTE STF471: removed f_init_interfaceprofile(p_interface);
+
+ // Variables & defaults initialization
+ f_IMS_preamble_woRegistration(p_cSeq_s);
+
+ // Preamble
+ f_Registration(p_cSeq_s, p_register, PX_SIP_REGISTER_AUTHENTICATION_ENABLED);
+
+ // deregistration in case of successful registration
+ vc_DeregDone := false;
+ }
+
+ /**
+ * @desc Sets variables and default initialization for user profile and handle registration and authentication with MD5 (basic registration template)
+ * @param p_cSeq_s The current cseq
+ * @param p_host P-CSCF domain name (formerly value from module parameter PX_IMS_TS_PCSCF_HOME_DOMAIN)
+ * @param p_port P-CSCF port number (formerly value from module parameter PX_IMS_TS_PCSCF_PORT)
+ */
+ function f_IMS_preamble_withRegistrationBasic(
+ inout CSeq p_cSeq_s,
+ template(value) charstring p_host,
+ template(value) integer p_port
+ ) runs on ImsComponent {
+ //NOTE STF471: removed f_init_interfaceprofile(p_interface);
+ // Variables & defaults initialization
+ f_IMS_preamble_woRegistration(p_cSeq_s);
+
+ // Preamble
+ f_Registration_IMS(p_cSeq_s, PX_SIP_REGISTER_AUTHENTICATION_ENABLED, p_host, p_port);
+ f_setHeaders_SUBSCRIBE(p_cSeq_s);
+ f_Subscription(p_cSeq_s, m_SUBSCRIBE_Request_UE(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via, vc_contact, vc_route_REG));
+ }
+
+ /**
+ * @desc Sets variables and default initialization for user profile and handle registration and authentication with MD5 (basic registration template)
+ * @param p_cSeq_s The current cseq
+ */
+ function f_IMS_preamble_AS(
+ inout CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ // avoid deregistration in default behavior
+ vc_DeregDone := true;
+ vc_boo_route := true;
+ vc_boo_recordRoute := true;
+ vc_cSeq := p_cSeq_s;
+
+ // Defaults
+ vc_def_catchSyncStop := activate(a_Sip_catchSyncStop());
+ vc_default := activate(a_altstep_AS());
+
+ // Preamble
+ //NOTE STF471: removed f_init_interfaceprofile(p_interface);
+ //NOTE STF471: removed f_init_userprofile(p_userprofile); // assignment of PIXIT values to component variable
+ vc_sdp_local := valueof(m_SDP_bandwidth(m_media_dynPT(PX_SIP_SDP_DYN, PX_SIP_SDP_ENCODING, PX_SIP_SDP_CLOCKRATE, omit), vc_userprofile));
+ vc_contact := m_Contact(m_SipUrl_contactIpaddr(vc_userprofile));
+ }
+
+ } // end group preambles
+
+ group postambles {
+
+ /**
+ * @desc Terminates component and handles deregistration
+ * @param p_cSeq_s The current cseq
+ */
+ function f_IMS_postamble_withDeRegistration(
+ CSeq p_cSeq_s
+ ) runs on ImsComponent {
+ f_RemoveRegistration(p_cSeq_s);
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Terminates component and optionally handles deregistration on AS as TS
+ * @param p_deRegistration Handle deregistration?
+ */
+ function f_IMS_postamble_AS_withDeRegistration(
+ boolean p_deRegistration
+ ) runs on ImsComponent {
+
+ if (p_deRegistration == true) {
+ f_awaitingREGISTER_sendReply(mw_REGISTER_Request_Base, true);
+ }
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Terminates component without registration
+ */
+ function f_SIP_postamble_IMS1_withoutRegistration(
+ ) runs on ImsComponent {
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Terminates component without de-registration
+ */
+ function f_IMS_postamble_withoutDeRegistration(
+ ) runs on ImsComponent {
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Terminates component with de-registration
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ */
+ function f_SIP_postamble_IMS1_awaitDeRegistration(
+ in SipUrl p_to_user,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ var SipUrl v_passociated_url;
+ // Awaiting 1st REGISTER
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 401 response
+ f_sendResponse(m_Response_WWWauthenticate_IMS(c_statusLine401, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, m_wwwAuthenticate(f_calculatecChallenge_forWWWAuthorization(p_qop, valueof(vc_authorization.body[0].digestResponse)))));
+
+ // Awaiting 2nd REGISTER with authorization header
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 200OK to complete the request
+ v_passociated_url := vc_caller_From.addressField.nameAddr.addrSpec;
+ f_sendResponse(m_Response_2xxonREGISTER_IMS(c_statusLine200, vc_callId, vc_cSeq, vc_callee_From, vc_callee_To, vc_via, vc_contact, p_to_user, v_passociated_url));
+
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Terminates component with de-registration
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ */
+ function f_IMS_postamble_awaitDeRegistration(
+ in SipUrl p_to_user,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ var SipUrl v_passociated_url;
+ // Awaiting 1st REGISTER
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 401 response
+ f_sendResponse(m_Response_WWWauthenticate_IMS(c_statusLine401, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, m_wwwAuthenticate(f_calculatecChallenge_forWWWAuthorization(p_qop, valueof(vc_authorization.body[0].digestResponse)))));
+
+ // Awaiting 2nd REGISTER with authorization header
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 200OK to complete the request
+ v_passociated_url := vc_caller_From.addressField.nameAddr.addrSpec;
+ f_sendResponse(m_Response_2xxonREGISTER_IMS(c_statusLine200, vc_callId, vc_cSeq, vc_callee_From, vc_callee_To, vc_via, vc_contact, p_to_user, v_passociated_url));
+
+ f_terminate_component();
+ }
+
+
+ /**
+ * @desc Awaits de-registration
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ */
+ function f_IMS_awaitDeRegistration(
+ in SipUrl p_to_user,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ var SipUrl v_passociated_url;
+ // Awaiting 1st REGISTER
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 401 response
+ f_sendResponse(m_Response_WWWauthenticate_IMS(c_statusLine401, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, m_wwwAuthenticate(f_calculatecChallenge_forWWWAuthorization(p_qop, valueof(vc_authorization.body[0].digestResponse)))));
+
+ // Awaiting 2nd REGISTER with authorization header
+ f_awaitingREGISTER(mw_REGISTER_unauthorizedRequest_IMS);
+
+ // 200OK to complete the request
+ v_passociated_url := vc_caller_From.addressField.nameAddr.addrSpec;
+ f_sendResponse(m_Response_2xxonREGISTER_IMS(c_statusLine200, vc_callId, vc_cSeq, vc_callee_From, vc_callee_To, vc_via, vc_contact, p_to_user, v_passociated_url));
+ }
+
+ //NOTE STF471: renamed f_SIP_postamble_UE(1|2)_withoutRegistration to f_SIP_postamble_UE_withoutRegistration
+ /**
+ * @desc Terminates component without registration
+ */
+ function f_SIP_postamble_UE_withoutRegistration(
+ ) runs on ImsComponent {
+ f_terminate_component();
+ }
+
+ /**
+ * @desc Sends BYE and awaits response (IMS)
+ * @param p_requestUri The Request URI
+ * @param p_callId CallId parameter for outgoing BYE
+ * @param p_cSeq_s CSeq parameter for outgoing BYE
+ * @param p_from From parameter for outgoing BYE
+ * @param p_to To parameter for outgoing BYE
+ */
+ function f_terminateCall_IMS(
+ SipUrl p_requestUri,
+ CallId p_callId,
+ inout CSeq p_cSeq_s,
+ From p_from,
+ template(value) To p_to
+ ) runs on ImsComponent {
+ LibSip_Steps.f_setHeadersBYE(p_cSeq_s);
+ // Sending of a BYE request to release the call and expect a final response
+ f_SendBYE(m_BYE_Request_IMS(p_requestUri, p_callId, p_cSeq_s, p_from, p_to, vc_via, vc_route));
+
+ tc_resp.start;
+ alt {
+ [] SIPP.receive(mw_Response_Base(mw_statusLine1xx, p_callId, p_cSeq_s)) {
+ repeat;
+ }
+ [] SIPP.receive(mw_Response_Base(mw_statusLineFinal, p_callId, p_cSeq_s)) {
+ tc_resp.stop;
+ }
+ // timeout should be handled in default_alt_step
+ }
+ } // end function f_terminateCall_IMS
+
+ /**
+ * @desc Sends BYE and awaits response (UE)
+ * @param p_requestUri The Request URI
+ * @param p_callId CallId parameter for outgoing BYE
+ * @param p_cSeq_s CSeq parameter for outgoing BYE
+ * @param p_from From parameter for outgoing BYE
+ * @param p_to To parameter for outgoing BYE
+ * @param p_recordRoute RecordRoute parameter for outgoing BYE - default: omit
+ */
+ function f_terminateCall_UE(
+ SipUrl p_requestUri,
+ CallId p_callId,
+ inout CSeq p_cSeq_s,
+ From p_from,
+ template(value) To p_to,
+ template RecordRoute p_recordRoute := omit
+ ) runs on ImsComponent {
+ var Route v_route;
+ LibSip_Steps.f_setHeadersBYE(p_cSeq_s);
+ // Sending of a BYE request to release the call and expect a final response
+ if (ispresent(p_recordRoute)) {
+ v_route := {ROUTE_E, valueof(p_recordRoute.routeBody)};
+ f_SendBYE(m_BYE_Request_UE(p_requestUri, p_callId, p_cSeq_s, p_from, valueof(p_to), vc_via, v_route));
+ }
+ else {
+ f_SendBYE(m_BYE_Request_UE(p_requestUri, p_callId, p_cSeq_s, p_from, valueof(p_to), vc_via, vc_route));
+ }
+
+ tc_resp.start;
+ alt {
+ [] SIPP.receive(mw_Response_Base(mw_statusLine1xx, p_callId, p_cSeq_s)) {
+ repeat;
+ }
+ [] SIPP.receive(mw_Response_Base(mw_statusLineFinal, p_callId, p_cSeq_s)) {
+ tc_resp.stop;
+ }
+ // timeout should be handled in default_alt_step
+ }
+ } // end function f_terminateCall_UE
+
+ /**
+ * @desc Sends BYE and awaits response and De-registration
+ * @param p_requestUri The Request URI
+ * @param p_callId CallId parameter for outgoing BYE
+ * @param p_cSeq_s CSeq parameter for outgoing BYE
+ * @param p_from From parameter for outgoing BYE
+ * @param p_to To parameter for outgoing BYE
+ * @param p_qop of the peer UE (alternatively)
+ */
+ function f_terminateCall_UE_withDeReg(
+ SipUrl p_requestUri,
+ CallId p_callId,
+ inout CSeq p_cSeq_s,
+ From p_from,
+ template(value) To p_to,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ LibSip_Steps.f_setHeadersBYE(p_cSeq_s);
+ // Sending of a BYE request to release the call and expect a final response
+ f_SendBYE(m_BYE_Request_UE(p_requestUri, p_callId, p_cSeq_s, p_from, p_to, vc_via, vc_route));
+
+ tc_resp.start;
+ alt {
+ [] SIPP.receive(mw_Response_Base(mw_statusLine1xx, p_callId, p_cSeq_s)) {
+ repeat;
+ }
+ [] SIPP.receive(mw_Response_Base(mw_statusLineFinal, p_callId, p_cSeq_s)) {
+ tc_resp.stop;
+ }
+ // timeout should be handled in default_alt_step
+ }
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_requestUri, p_qop);
+ } // end function f_terminateCall_UE_withDeReg
+
+ }
+ group defaults {
+
+ /**
+ * @desc Altstep for clearing registration (IMS user)
+ * @param p_to_user The selected user's SIP URL
+ * @param p_qop of the peer UE (alternatively)
+ * @verdict fail for all unexpected branches
+ */
+ altstep a_clearRegistration_IMSuser(
+ in SipUrl p_to_user,
+ in charstring p_qop
+ ) runs on ImsComponent {
+ var Response v_response;
+ var Request v_request;
+ var CSeq v_cSeq;
+ [] any timer.timeout {
+ log("*** " & testcasename() & ": FAIL: Timeout while waiting for message. ***");
+ setverdict(fail);
+ all timer.stop;
+ vc_callId := vc_callIdReg;
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ // allow repeated INVITEs
+ [vc_ignore_invite] SIPP.receive(mw_INVITE_Request_Base) {
+ repeat;
+ }
+ // allow repeated BYEs after ack of the first BYE
+ [vc_ignore_bye] SIPP.receive(mw_BYE_Request_Base(?)) {
+ repeat;
+ }
+ [] SIPP.receive(mw_ACK_Request_Base(?)) {
+ repeat;
+ }
+ // allow 100 replies
+ [] SIPP.receive(mw_Response_Base(c_statusLine100, ?, ?)) {
+ repeat;
+ }
+ // ignore 181 if flag is set (following TS 183004 §4.5.2.1)
+ [vc_ignore181] SIPP.receive(mw_Response_Base(c_statusLine181, vc_callId, vc_cSeq)) -> value v_response sender vc_sent_label {
+ v_cSeq := valueof(v_response.msgHeader.cSeq);
+ f_setHeadersOnReceiptOfResponse(v_response);
+ repeat;
+ }
+ // according to SIP chap.8.1.3.2
+ [] SIPP.receive(mw_Response_Base(c_statusLine183, vc_callId, vc_cSeq)) {
+ repeat;
+ }
+ // ignore 484 if flag is set
+ [vc_ignore484] SIPP.receive(mw_Response_Base(c_statusLine484, vc_callId, vc_cSeq)) {
+ repeat;
+ }
+ [vc_ignore4xx] SIPP.receive(mw_Response_Base(mw_statusLine4xx, vc_callId, ?)) -> value v_response sender vc_sent_label {
+ v_cSeq := valueof(v_response.msgHeader.cSeq);
+ f_setHeadersOnReceiptOfResponse(v_response);
+ f_SendACK(m_ACK_Request_route(vc_requestUri, vc_callId, v_response.msgHeader.cSeq, vc_from, vc_to, vc_via, vc_route));
+ repeat;
+ }
+ [vc_ignore200OKinv] SIPP.receive(mw_Response_Base(c_statusLine200, vc_callId, ?)) {
+ repeat;
+ }
+ [] SIPP.receive(mw_INFO_Request_Base(vc_callId)) -> value v_request sender vc_sent_label {
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_send200OK();
+ repeat;
+ }
+ // awaiting of Notify
+ [] SIPP.receive(mw_NOTIFY_Request_Base(vc_callId)) -> value v_request sender vc_sent_label {
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_send200OK();
+ repeat;
+ }
+ // awaiting of subscribe from UE
+ [vc_ignore_subscribe] SIPP.receive(mw_SUBSCRIBE_Request_Base) -> value v_request sender vc_sent_label {
+ f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
+ f_send200OK();
+ repeat;
+ }
+ // awaiting of subscribe on proxy
+ [] SIPP.receive(mw_SUBSCRIBE_Request_Base) -> value v_request sender vc_sent_label {
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_sendResponse(m_Response_Contact(c_statusLine200, vc_callId, vc_cSeq, vc_callee_From, vc_callee_To, vc_via, vc_contact));
+ f_SendNOTIFY(m_NOTIFY_Request_contact(v_request.msgHeader.contact.contactBody.contactAddresses[0].addressField.nameAddr.addrSpec, vc_callId, vc_cSeq, vc_callee_From, vc_callee_To, vc_via, vc_contact));
+ f_awaitingOkResponse(vc_cSeq);
+ repeat;
+ }
+ // unexpected BYE is acknowledged to avoid retransmissions
+ [] SIPP.receive(mw_BYE_Request_Base(?)) -> value v_request sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected BYE message received. ***");
+ setverdict(fail);
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_send200OK();
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ // unexpected CANCEL is acknowledged to avoid retransmissions
+ [] SIPP.receive(mw_CANCEL_Request_Base(?)) -> value v_request sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected CANCEL message received. ***");
+ setverdict(fail);
+ f_setHeadersOnReceiptOfRequest(v_request);
+ // Answer to the CANCEL
+ f_send200OK();
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ // catch 4xx response
+ [] SIPP.receive(mw_Response_Base(mw_statusLine4xx, vc_callId, ?)) -> value v_response sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected 4xx response received. ***");
+ setverdict(fail);
+ v_cSeq := valueof(v_response.msgHeader.cSeq);
+ f_setHeadersOnReceiptOfResponse(v_response);
+ LibSip_Steps.f_setHeadersACK();
+ f_SendACK(m_ACK_Request_route(vc_requestUri, vc_callId, v_response.msgHeader.cSeq, vc_from, vc_to, vc_via, vc_route));
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ // catch 5xx response
+ [] SIPP.receive(mw_Response_Base(mw_statusLine5xx, vc_callId, ?)) -> value v_response sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected 5xx response received. ***");
+ setverdict(fail);
+ v_cSeq := valueof(v_response.msgHeader.cSeq);
+ f_setHeadersOnReceiptOfResponse(v_response);
+ LibSip_Steps.f_setHeadersACK();
+ f_SendACK(m_ACK_Request_route(vc_requestUri, vc_callId, v_response.msgHeader.cSeq, vc_from, vc_to, vc_via, vc_route));
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ // catch invalid REGISTER
+ [] SIPP.receive(mw_REGISTER_Request_Base) -> value v_request sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected REGISTER received. ***");
+ setverdict(fail);
+ f_componentStop();
+ }
+ // any
+ [] SIPP.receive {
+ log("*** " & testcasename() & ": FAIL: Unexpected message received. ***");
+ setverdict(fail);
+ all timer.stop;
+ action("Please de-register");
+ f_IMS_awaitDeRegistration(p_to_user, p_qop);
+ f_componentStop();
+ }
+ }
+
+ /**
+ * @desc Main default altstep to handle unexpected messages and timeout
+ * @verdict fail for all unexpected branches
+ */
+ altstep a_altstep_AS(
+ ) runs on SipComponent {
+ var Request v_request;
+ [] any timer.timeout {
+ log("*** " & testcasename() & ": FAIL: Timeout while waiting for message. ***");
+ setverdict(fail);
+ all timer.stop;
+ }
+ // allow repeated INVITEs
+ [vc_ignore_invite] SIPP.receive(mw_INVITE_Request_Base) {
+ repeat;
+ }
+ // handle REGISTER requests
+ [] SIPP.receive(mw_REGISTER_Request_Base) -> value v_request sender vc_sent_label {
+ f_setHeadersOnReceiptOfREGISTER(v_request);
+ // vc_contact := vc_request.msgHeader.contact;
+ f_sendResponse(m_Response_Contact(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via, vc_contact));
+ repeat;
+ }
+ // according to SIP chap.8.1.3.2
+ [] SIPP.receive(mw_Response_Base(c_statusLine183, vc_callId, vc_cSeq)) {
+ repeat;
+ }
+ // unexpected CANCEL is acknowledged to avoid retransmissions
+ [] SIPP.receive(mw_CANCEL_Request_Base(?)) -> value v_request sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected CANCEL message received. ***");
+ setverdict(fail);
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_send200OK();
+ }
+ // unexpected BYE is acknowledged to avoid retransmissions
+ [] SIPP.receive(mw_BYE_Request_Base(?)) -> value v_request sender vc_sent_label {
+ log("*** " & testcasename() & ": FAIL: Unexpected BYE message received. ***");
+ setverdict(fail);
+ f_setHeadersOnReceiptOfRequest(v_request);
+ f_send200OK();
+ }
+ [] SIPP.receive(mw_Response_Base(?, vc_callId, vc_cSeq)) -> value vc_response {
+ log("*** " & testcasename() & ": FAIL: Unexpected response message in " & __SCOPE__ & " received. ***");
+ setverdict(fail);
+ repeat;
+ }
+ // any
+ [] SIPP.receive {
+ log("*** " & testcasename() & ": FAIL: Unexpected message received. ***");
+ setverdict(fail);
+ all timer.stop;
+ }
+ }
+ }
+} // module LibIms_Steps
\ No newline at end of file
/tags/v3.0.0/ttcn/LibIms_Steps.ttcn
Property changes:
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: tags/v3.0.0/ttcn/LibIms_Templates.ttcn
===================================================================
--- tags/v3.0.0/ttcn/LibIms_Templates.ttcn (nonexistent)
+++ tags/v3.0.0/ttcn/LibIms_Templates.ttcn (revision 208)
@@ -0,0 +1,4610 @@
+/**
+ * @author STF471
+ * @version $Id$
+ * @desc This module provides the templates used by the test component for SIP-IMS tests.
+ * This module is part of LibImsV3.
+ */
+module LibIms_Templates {
+ // LibCommon
+ import from LibCommon_DataStrings all;
+
+ // LibSip
+ import from LibSip_SIPTypesAndValues all;
+ import from LibSip_Templates all;
+ import from LibSip_Steps all;
+ import from LibSip_PIXITS all;
+ import from LibSip_XMLTypes all;
+ import from LibSip_MessageBodyTypes all;
+
+ // LibIms
+ import from LibIms_SIPTypesAndValues all;
+
+ // LibXMLTypes
+ import from XSD all;
+
+ import from urn_ietf_params_xml_ns_resource_lists language "XSD" all
+ with {
+ extension "File:../xsd/ResourceList.xsd";
+ }
+
+ import from urn_ietf_params_xml_ns_reginfo language "XSD" all except {type Contact;}
+ with {
+ extension "File:../xsd/regInfo.xsd";
+ }
+
+ import from http_uri_etsi_org_ngn_params_xml_simservs_xcap language "XSD" all
+ with {
+ extension "File:../xsd/SupplementaryServices.xsd";
+ }
+
+ import from http_uri_etsi_org_ngn_params_xml_simservs_mcid language "XSD" all
+ with {
+ extension "File:../xsd/MCID.xsd";
+ }
+
+ import from NoTargetNamespace language "XSD" all
+ with {
+ extension "File:../xsd/Ims3gpp.xsd";
+ }
+
+ import from urn_ietf_params_xml_ns_conference_info language "XSD" all
+ with {
+ extension "File:../xsd/CONF.xsd";
+ }
+
+ import from http_uri_etsi_org_ngn_params_xml_simservs_pstn language "XSD" all
+ with {
+ extension "File:../xsd/PSTN.xsd";
+ }
+
+ import from urn_ietf_params_xml_ns_common_policy language "XSD" all
+ with {
+ extension "File:../xsd/common-policy.xsd";
+ }
+
+ import from http_uri_etsi_org_ngn_params_xml_comm_div_info language "XSD" all
+ with {
+ extension "File:../xsd/CDIVN.xsd";
+ }
+
+ import from urn_3gpp_ns_cw_1_0 language "XSD" all
+ with {
+ extension "File:../xsd/cw.xsd";
+ }
+
+ template(present) charstring mw_international_number_format := pattern "\\+\d+";
+
+ template(present) NameAddr mw_SipUrl_SUTinterface(
+ template(present) charstring p_host := ?,
+ template(present) integer p_port := ?
+ ) := {
+ displayName := *,
+ addrSpec := {
+ scheme := "sip:",
+ components := {
+ sip := {
+ userInfo := *,
+ hostPort := mw_hostPort(p_host, p_port)
+ }
+ },
+ urlParameters := *,
+ headers := *
+ }
+ }
+
+ template(present) Addr_Union mw_UE1_Addr_display(
+ template(present) charstring p_displayName
+ ) := {
+ nameAddr := {
+ displayName := p_displayName,
+ addrSpec := ?
+ }
+ }
+
+ group subfields {
+
+ template(value) SipUrl m_SipUrl_currIpaddr_CSCF(
+ template(value) SipUserProfile p_userprofile
+ ) := {
+ scheme := c_sipScheme, //* contains "sip"
+ components := {
+ sip := {
+ userInfo := omit, //* optional
+ hostPort := {
+ host := p_userprofile.currIpaddr, //* hostname, IPv4 or IPv6 as a charstring
+ portField := p_userprofile.currPort //* optional integer
+ }
+ }
+ },
+ urlParameters := omit,
+ headers := omit
+ }
+
+ template(present) SemicolonParam_List mw_semicolonParams_realm(
+ template GenValue p_realm
+ ) :=
+ superset(
+ {
+ "realm",
+ p_realm
+ },
+ {
+ "nonce",
+ ?
+ },
+ {
+ "algorithm",
+ { tokenOrHost := "AKAv1-MD5" }
+ },
+ {
+ "ik",
+ ?
+ },
+ {
+ "ck",
+ ?
+ }
+ );
+
+ template(value) SemicolonParam_List m_semicolonParams_language(
+ template(omit) GenValue p_language := omit
+ ) := {
+ {
+ "language",
+ p_language
+ }
+ }
+
+ template(present) SemicolonParam_List mw_semicolonParams_language(
+ template GenValue p_language
+ ) := {
+ {
+ "language",
+ p_language
+ }
+ }
+
+ template(value) SemicolonParam_List m_semicolonParams_isub(
+ template(omit) GenValue p_address := omit
+ ) := {
+ {
+ "isub",
+ p_address
+ }
+ }
+ }
+
+ group headerFieldTemplates {
+
+ template(value) MinSE m_minSE(
+ template(value) DeltaSec p_ds
+ ) := {
+ fieldName := MIN_SE_E,
+ deltaSec := p_ds,
+ minSeParam := omit
+ }
+
+ template(present) PathValue mw_pathvalue(
+ template(present) SipUrl p_sipUrl := ?
+ ) := {
+ nameAddr := {
+ displayName := *, // optional charstring
+ addrSpec := p_sipUrl // SipUrl
+ },
+ rrParam := *
+ }
+
+ template(value) Path m_path(
+ template(value) charstring p_host,
+ template(value) integer p_port,
+ template(value) SipUrl p_sipUrl
+ ) modifies m_path_TS := {
+ pathValues := {
+ {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := p_sipUrl // SipUrl
+ },
+ rrParam := omit
+ }
+ }
+ }
+
+ template(value) Path m_path_TS(
+ template(value) charstring p_host,
+ template(value) integer p_port
+ ) := {
+ fieldName := PATH_E,
+ pathValues := {
+ {
+ nameAddr := {
+ displayName := omit, // optional charstring
+ addrSpec := {
+ scheme := c_sipScheme,
+ components := {
+ sip := {
+ userInfo := {
+ userOrTelephoneSubscriber := "registrar",
+ password := omit
+ },
+ hostPort := {p_host, p_port}
+ }
+ },
+ urlParameters := {
+ {
+ id := "lr",
+ paramValue := omit
+ }
+ },
+ headers := omit
+ }
+ },
+ rrParam := omit
+ }
+ }
+ }
+
+ /**
+ * @desc Path header field expectation with at least one path value
+ * @param p_sipUrl value of the last element in the list of path values
+ */
+ template(present) Path mw_path(
+ template(present) SipUrl p_sipUrl := ?
+ ) := {
+ fieldName := PATH_E,
+ pathValues := {mw_pathvalue(p_sipUrl)} // any number of SipUrl may occur before p_sipUrl
+ }
+
+ template(value) PAccessNetworkInfo m_pAccessNetworkInfo_IEEE_11a := {
+ fieldName := P_ACCESS_NETWORK_INFO_E,
+ accessType := "IEEE-802.11a",
+ genericParams := {
+ {
+ id := "extension-access-info",
+ paramValue := { tokenOrHost := "192.1.1.20" }
+ }
+ }
+ }
+
+ template(value) PAssertedService m_pAssertedService(
+ template(value) PAssertedServiceValue p_pAssertedServiceValue
+ ) := {
+ fieldName := P_ASSERTED_SERVICE_E,
+ pAssertedServiceValue := p_pAssertedServiceValue
+ }
+
+ template(value) PChargingFunctionAddresses m_pChargingFunctionAddresses_fixedValue := {
+ fieldName := P_CHARGING_FUNCTION_ADDRESSES_E,
+ chargeAddrParams := {
+ {
+ id := "ccf",
+ paramValue := { tokenOrHost := "192.1.1.1" }
+ }, // value is fixed because it is deleted on proxy
+ {
+ id := "ecf",
+ paramValue := { tokenOrHost := "192.1.1.2" }
+ } // value is fixed because it is deleted on proxy
+ }
+ }
+
+ template(value) PChargingVector m_pChargingVector(
+ template(value) charstring p_icidValue,
+ template(omit) SemicolonParam_List p_chargeParams := omit
+ ) modifies m_pChargingVector_icid_TS := {
+ icidValue := p_icidValue,
+ chargeParams := p_chargeParams
+ }
+
+ // NOTE STF471 change: icidValue extracted from chargeParams, chargeParams removed
+ template(value) PChargingVector m_pChargingVector_icid_TS := {
+ fieldName := P_CHARGING_VECTOR_E,
+ icidValue := c_icid_value,
+ chargeParams := omit
+ }
+
+ template(value) PChargingVector m_pChargingVector_origIoi_fixedValue(
+ template(value) GenValue p_homeDomain
+ ) modifies m_pChargingVector_icid_TS := {
+ chargeParams := {
+ {
+ id := c_icid_generated_at,
+ paramValue := { tokenOrHost := "192.1.1.10" }
+ },
+ {
+ id := c_orig_ioi,
+ paramValue := p_homeDomain
+ }
+ }
+ }
+
+ template(value) PChargingVector m_pChargingVector_termIoi_fixedValue(
+ template(value) GenValue p_homeDomain
+ ) modifies m_pChargingVector_icid_TS := {
+ chargeParams := {
+ {
+ id := c_icid_generated_at,
+ paramValue := { tokenOrHost := "192.1.1.10" }
+ },
+ {
+ id := c_term_ioi,
+ paramValue := p_homeDomain
+ }
+ }
+ }
+
+ template(value) PChargingVector m_pChargingVector_accessNetwInfo(
+ template(value) GenValue p_homeDomain
+ ) modifies m_pChargingVector_icid_TS := {
+ chargeParams := {
+ {
+ id := c_term_ioi,
+ paramValue := p_homeDomain
+ },
+ {
+ id := c_access_network_charging_info,
+ paramValue := { tokenOrHost := "192.1.1.10" }
+ }
+ }
+ }
+
+ // NOTE STF471 change: icidValue added
+ template(present) PChargingVector mw_pChargingVector(
+ template(present) charstring p_id := ?,
+ template GenValue p_paramValue
+ ) := {
+ fieldName := P_CHARGING_VECTOR_E,
+ icidValue := ?,
+ chargeParams :=
+ superset(
+ {
+ id := p_id,
+ paramValue := p_paramValue
+ }
+ )
+ }
+
+ template(value) PMediaAuthorization m_pMediaAuthorization_fixedValue := {
+ fieldName := P_MEDIA_AUTHORIZATION_E,
+ pMediaAuthorizations := {"A"} // example
+ }
+
+
+ template(value) PEarlyMedia m_pEarlyMedia_sup := {
+ fieldName := P_EARLY_MEDIA_E,
+ em_param := {"supported"}
+ }
+
+
+ template(value) ProxyRequire m_proxyRequire_secAgree := {
+ fieldName := PROXY_REQUIRE_E,
+ optionsTags := {"sec-agree"}
+ }
+
+ template(value) PVisitedNetworkID m_pVisitedNetworkID_TS := {
+ fieldName := P_VISITED_NETWORK_E,
+ vNetWorkSpec := {
+ {
+ vNetworkSpecToken := "Visited ETSI 1",
+ genericParams := omit
+ }
+ }
+ }
+
+ template(present) PVisitedNetworkID mw_pVisitedNetworkID(
+ template(present) charstring p_vNetworkSpecToken
+ ) modifies m_pVisitedNetworkID_TS := {
+ vNetWorkSpec := {
+ {
+ vNetworkSpecToken := p_vNetworkSpecToken,
+ genericParams := *
+ }
+ }
+ }
+
+ template(value) RecordRoute m_recordRoute_notmatching := {
+ fieldName := RECORD_ROUTE_E,
+ routeBody := {
+ {
+ nameAddr := {
+ displayName := omit,
+ addrSpec := {
+ scheme := c_sipScheme, // contains "sip"
+ components := {
+ sip := {
+ userInfo := {
+ userOrTelephoneSubscriber := "unknown",
+ password := omit
+ },
+ hostPort := {
+ host := "unknown.domain.name", // hostname, IPv4 or IPv6 as a charstring
+ portField := omit
+ }
+ }
+ },
+ urlParameters := omit,
+ headers := omit
+ }
+ },
+ rrParam := omit
+ }
+ }
+ }
+
+ template(value) Require m_require := {
+ fieldName := REQUIRE_E,
+ optionsTags := {}
+ }
+
+ template(value) Require m_require_secAgree
+ modifies m_require := {
+ optionsTags := {"sec-agree"}
+ }
+
+ template(present) Require mw_require_path
+ modifies m_require := {
+ optionsTags := superset("path")
+ }
+
+ template(value) Route m_route_interface(
+ template(value) ImsInterfaceProfile p_interfaceprofile
+ ) modifies m_route_notmatching := {
+ routeBody := {
+ {
+ nameAddr := {
+ displayName := omit,
+ addrSpec := {
+ scheme := c_sipScheme, // contains "sip"
+ components := {
+ sip := {
+ userInfo := omit,
+ hostPort := {
+ host := p_interfaceprofile.SUTHomeDomain,
+ portField := omit
+ }
+ }
+ },
+ urlParameters := omit,
+ headers := omit
+ }
+ },
+ rrParam := omit
+ }
+ }
+ }
+
+ template(value) Route m_route_notmatching := {
+ fieldName := ROUTE_E,
+ routeBody := {
+ {
+ nameAddr := {
+ displayName := omit,
+ addrSpec := {
+ scheme := c_sipScheme, // contains "sip"
+ components := {
+ sip := {
+ userInfo := {
+ userOrTelephoneSubscriber := "unknown",
+ password := omit
+ },
+ hostPort := {
+ host := "unknown.domain.name", // hostname, IPv4 or IPv6 as a charstring
+ portField := omit
+ }
+ }
+ },
+ urlParameters := omit,
+ headers := omit
+ }
+ },
+ rrParam := omit
+ }
+ }
+ }
+
+
+ template(value) SessionExpires m_se(
+ template(value) DeltaSec p_ds
+ ) modifies mw_se := {
+ deltaSec := p_ds
+ }
+
+ template(present) SessionExpires mw_se := {
+ fieldName := SESSION_EXPIRES_E,
+ deltaSec := ?,
+ seParam := omit
+ }
+
+ template(value) Supported m_supported := {
+ fieldName := SUPPORTED_E,
+ optionsTags := {}
+ }
+
+ template(value) Supported m_supported_timer
+ modifies m_supported := {
+ optionsTags := {"timer"}
+ }
+
+ template(value) Supported m_supported_histinfo
+ modifies m_supported := {
+ optionsTags := {"histinfo"}
+ }
+
+
+ template(value) Supported m_supported_fromChange
+ modifies m_supported := {
+ optionsTags := {"from-change"}
+ }
+
+ template(value) To m_To_targetRefreshRequest(
+ template(value) To p_To
+ ) := {
+ fieldName := TO_E,
+ addressField := {
+ nameAddr := {
+ displayName := p_To.addressField.nameAddr.displayName,
+ addrSpec := p_To.addressField.nameAddr.addrSpec
+ }
+ }, // end addressField
+ toParams := {
+ {
+ id := c_tagId,
+ paramValue := { tokenOrHost := f_getRndTag() }
+ }
+ }
+ }
+
+ template(value) ViaBody m_ViaBody_virtualUEinPCSCF(
+ template(value) charstring p_branch_val,
+ template(value) SipUserProfile p_userprofile
+ ) := {
+ sentProtocol := m_SentProtocol(PX_SIP_TRANSPORT),
+ sentBy := {
+ host := p_userprofile.contactIpaddr,
+ portField := p_userprofile.contactPort
+ },
+ viaParams := {
+ {
+ id := c_branchId,
+ paramValue := {
+ tokenOrHost := p_branch_val
+ }
+ }
+ }
+ }
+
+ template(value) ViaBody m_ViaBody_virtual_XCSCF(
+ template(value) charstring p_branch_val,
+ template(value) SipUserProfile p_userprofile
+ ) modifies m_ViaBody_virtualUEinPCSCF := {
+ sentBy := {
+ host := p_userprofile.currIpaddr,
+ portField := p_userprofile.currPort
+ }
+ }
+
+ template(value) Via m_via_notmatching := {
+ fieldName := VIA_E,
+ viaBody := {
+ {
+ sentProtocol := m_SentProtocol("UDP"),
+ sentBy := {
+ host := "unknown.domain.name",
+ portField := 10000
+ },
+ viaParams := {
+ {
+ id := c_branchId,
+ paramValue := { tokenOrHost := "abcd0000" }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @desc WWW-Authenticate header field
+ * @param p_challenge value
+ */
+ template(value) WwwAuthenticate m_wwwAuthenticate(
+ template(value) Challenge p_challenge
+ ) := {
+ fieldName := WWW_AUTHENTICATE_E,
+ challenge := p_challenge
+ }
+
+ /**
+ * @desc WWW-Authenticate header field
+ * @param p_challenge value
+ */
+ template(present) WwwAuthenticate mw_wwwAuthenticate(
+ template(present) SemicolonParam_List p_semicolonParam_List := ?
+ ) := {
+ fieldName := WWW_AUTHENTICATE_E,
+ challenge := {
+ digestCln := p_semicolonParam_List // set of GenericParam
+ }
+ }
+
+ template(present) SemicolonParam_List mw_challenge := superset(mw_ck, mw_ik);
+
+ template(present) GenericParam mw_ck := {
+ "ck", *
+ }
+
+ template(present) GenericParam mw_ik := {
+ "ik", *
+ }
+
+ /**
+ * @desc AcceptContact header field
+ * @param p_semicolonParam_List value
+ */
+ template(value) AcceptContact m_acceptContact(
+ template(omit) SemicolonParam_List p_semicolonParam_List := omit
+ ) := {
+ fieldName := ACCEPT_CONTACT_E,
+ acValues := {
+ {
+ wildcard := c_WILDCARD,
+ acRcParams := p_semicolonParam_List // set of GenericParam
+ }
+ }
+ }
+
+ /**
+ * @desc Authenticate header field
+ * @param p_semicolonParam_List value
+ */
+ template(present) AcceptContact mw_acceptContact(
+ template SemicolonParam_List p_semicolonParam_List
+ ) := {
+ fieldName := ACCEPT_CONTACT_E,
+ acValues := {
+ {
+ wildcard := c_WILDCARD,
+ acRcParams := p_semicolonParam_List // set of GenericParam
+ }
+ }
+ }
+
+ template(present) SubscriptionState mw_subscriptionState(
+ template(present) charstring p_state := ?
+ ) := {
+ fieldName := SUBSCRIPTION_STATE_E,
+ subState := p_state,
+ substateParams := omit
+ }
+
+ // [3455/5.1 ]
+ template(value) PAssociatedURI m_pAssociatedURI(
+ template(value) NameAddr p_nameAddr
+ ) := {
+ fieldName := P_ASSOCIATED_URI_E,
+ nameAddrList := {
+ {
+ nameAddr := p_nameAddr,
+ genericParams := omit
+ }
+ }
+ }
+
+ template(present) SecurityServer mw_securityServer(
+ template(present) SecurityMechanism_List p_securityMechanism_List := ?
+ ) := {
+ fieldName := SECURITY_SERVER_E,
+ securityMech := p_securityMechanism_List
+ }
+
+ template(value) SecurityClient m_securityClient(
+ template(value) SecurityMechanism_List p_securityMechanism_List
+ ) := {
+ fieldName := SECURITY_CLIENT_E,
+ securityMech := p_securityMechanism_List
+ }
+
+ template(value) SecurityVerify m_securityVerify(
+ template(value) SecurityMechanism_List p_securityMechanism_List
+ ) := {
+ fieldName := SECURITY_VERIFY_E,
+ securityMech := p_securityMechanism_List
+ }
+
+ template(value) RSeq m_rseq9999 := {
+ fieldName := RSEQ_E,
+ responseNum := 9999 // Ref: ES 283 003 V2.5.1 ch:A.2.1.4.7
+ }
+
+ template(value) Expires m_expires(
+ template(value) integer p_deltaSec
+ ) := {
+ fieldName := EXPIRES_E,
+ deltaSec := int2str(valueof(p_deltaSec))
+ }
+
+
+ } // end group headerFieldTemplates
+
+ group messageBodyTemplates {
+
+ group xmlTemplates {
+
+ template(value) XmlBody m_XmlBody_ConfInfo(
+ template(value) Conference_type p_confInfo
+ ) := {
+ conference := p_confInfo
+ }
+
+ template(value) XmlBody m_XmlBody_CW(
+ template(value) Ims_cw p_cw
+ ) := {
+ cw := p_cw
+ }
+
+ template(value) XmlBody m_XmlBody_CUG(
+ template(value) Cug p_cug
+ ) := {
+ cug := p_cug
+ }
+
+ template(value) XmlBody m_XmlBody_MCID(
+ template(value) Mcid p_mcid
+ ) := {
+ mcid := p_mcid
+ }
+
+ template(value) XmlBody m_XmlBody_PSTNTransit(
+ template(value) PSTN_transit p_pstn
+ ) := {
+ pstnTransit := p_pstn
+ }
+
+ template(value) XmlBody m_XmlBody_simservs(
+ template(value) Simservs p_simservs
+ ) := {
+ simservs := p_simservs
+ }
+
+ template(value) XmlBody m_XmlBody_ACR_ICB(
+ template(value) Incoming_communication_barring p_icb
+ ) := {
+ simservs := {
+ attr := omit,
+ absServiceGroup_list := {},
+ extensions := {
+ elem_list := valueof(p_icb.attr)
+ }
+ }
+ }
+
+ template(value) XmlBody m_XmlBody_ACR_OCB(
+ template(value) Outgoing_communication_barring p_ocb
+ ) := {
+ simservs := {
+ attr := omit,
+ absServiceGroup_list := {},
+ extensions := {
+ elem_list := valueof(p_ocb.attr)
+ }
+ }
+ }
+
+ template(value) XmlBody m_XmlBody_CDIVN(
+ template(value) Comm_div_info_type p_cdivn
+ ) := {
+ cdivn := p_cdivn
+ }
+
+ template(value) XmlBody m_XmlBody_Reginfo(
+ template(value) Reginfo p_regInfo
+ ) := {
+ regInfo := p_regInfo
+ }
+
+ template(value) MessageBody m_messageBodyXML(
+ template(value) XmlBody p_xmlBody
+ ) := {
+ xmlBody := p_xmlBody
+ }
+
+ template(value) Reginfo m_reginfo(
+ template(value) XSD.AnyURI p_user
+ ) := {
+ full,
+ 0,
+ {m_registration(p_user)},
+ {}
+ }
+
+ template(value) Registration m_registration(
+ template(value) XSD.AnyURI p_user
+ ) := {
+ p_user, // XSD.anyURI aor
+ "a7", // XSD.string id
+ init, // enumerated {active,init,terminated} state,
+ {}, // record of Contact contact_list optional,
+ {} // record of anytype elem_list optional
+ }
+
+ template(present) XmlBody mw_XmlBody_ConfInfo(
+ template(present) Conference_type p_confInfo := ?
+ ) := {
+ conference := p_confInfo
+ }
+
+ template(present) XmlBody mw_XmlBody_CUG(
+ template(present) Cug p_cug := ?
+ ) := {
+ cug := p_cug
+ }
+
+ template(present) XmlBody mw_XmlBody_MCID(
+ template(present) Mcid p_mcid := ?
+ ) := {mcid := p_mcid}
+
+ template(present) XmlBody mw_XmlBody_PSTNTransit(
+ template(present) PSTN_transit p_pstn := ?
+ ) := {
+ pstnTransit := p_pstn
+ }
+
+ template(present) XmlBody mw_XmlBody_CDIVN(
+ template(present) Comm_div_info_type p_cdivn := ?
+ ) := {
+ cdivn := p_cdivn
+ }
+
+ template(present) XmlBody mw_XmlBody_simservs(
+ template(present) Simservs p_simservs := ?
+ ) := {
+ simservs := p_simservs
+ }
+
+ template(present) XmlBody mw_XmlBody_ResourceLists(
+ template(present) Resource_lists p_resourceLists := ?
+ ) := {
+ resourceLists := p_resourceLists
+ }
+
+ template(present) XmlBody mw_XmlBody_Reginfo(
+ template(present) Reginfo p_regInfo := ?
+ ) := {
+ regInfo := p_regInfo
+ }
+
+
+ } // end group xmlTemplates
+
+ group acrCbTemplates {
+
+ template(value) Incoming_communication_barring m_ICB(
+ template(value) RuleType p_ruleType
+ ) := {
+ active := omit,
+ attr := omit,
+ ruleset := {
+ {p_ruleType}
+ }
+ }
+
+ template(value) Outgoing_communication_barring m_OCB(
+ template(value) RuleType p_ruleType
+ ) := {
+ active := omit,
+ attr := omit,
+ ruleset := {
+ {p_ruleType}
+ }
+ }
+
+ template(value) RuleType m_ruleType_actionFalse(
+ template(value) ConditionsType p_condition
+ ) := {
+ id := "rule66",
+ conditions := p_condition,
+ actions := {
+ elem_list := {"<false/>"}
+ },
+ transformations := omit
+ }
+
+ template(value) ConditionsType m_conditionsType_identity(
+ template(value) charstring p_id
+ ) := {
+ {
+ {
+ identity_list := {
+ {
+ {
+ {
+ one := {
+ id := p_id,
+ elem := omit
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+ } // end group acr_cbTemplates
+
+ group cugTemplates {
+
+ template(value) Cug m_CUG(
+ template(omit) CugRequestType p_crt := omit,
+ template(omit) NetworkIdentityType p_nit := omit,
+ template(omit) SixteenbitType p_cibc := omit,
+ template(omit) TwobitType p_cci := omit
+ ) := {
+ active := omit,
+ attr := omit,
+ cugCallOperation := p_crt,
+ networkIndicator := p_nit,
+ cugInterlockBinaryCode := p_cibc,
+ cugCommunicationIndicator := p_cci
+ }
+
+ template(present) Cug mw_CUG(
+ template CugRequestType p_crt,
+ template NetworkIdentityType p_nit,
+ template SixteenbitType p_cibc,
+ template TwobitType p_cci
+ ) := {
+ active := omit,
+ attr := *,
+ cugCallOperation := p_crt,
+ networkIndicator := p_nit,
+ cugInterlockBinaryCode := p_cibc,
+ cugCommunicationIndicator := p_cci
+ }
+
+ template(value) CugRequestType m_cugReqType(
+ template(value) boolean p_outAccessRequest,
+ template(value) CugIndexType p_cugIndex
+ ) := {
+ outgoingAccessRequest := p_outAccessRequest,
+ cugIndex := p_cugIndex
+ }
+
+ template(present) CugRequestType mw_cugReqType(
+ template(present) boolean p_outAccessRequest := ?,
+ template(present) CugIndexType p_cugIndex := ?
+ ) := {
+ outgoingAccessRequest := p_outAccessRequest,
+ cugIndex := p_cugIndex
+ }
+
+ } // end group cugTemplates
+
+ group cwTemplates {
+
+ template(value) Ims_cw m_CW(
+ template(value) TEmptyType p_cwi
+ ) := {
+ attr := omit,
+ communication_waiting_indication := p_cwi,
+ elem_list := {}
+ }
+
+ template(present) Ims_cw mw_ims_cw(
+ template(present) TEmptyType p_cwi := ?
+ ) := {
+ attr := *,
+ communication_waiting_indication := p_cwi,
+ elem_list := ?
+ }
+
+ } // end group cwTemplates
+
+ group mcidTemplates {
+
+ template(value) Mcid m_mcid_request_mcidIndicatorTrue := {
+ choice := {
+ request := {
+ mcidRequestIndicator := "1",
+ holdingIndicator := "0"
+ }
+ }
+ }
+
+ template(value) Mcid m_mcid_request_mcidIndicatorTrue_holdIndTrue
+ modifies m_mcid_request_mcidIndicatorTrue := {
+ choice := {
+ request := {
+ holdingIndicator := "1"
+ }
+ }
+ }
+
+ template(present) Mcid mw_mcid_request_mcidIndicatorTrue
+ modifies m_mcid_request_mcidIndicatorTrue := {
+ choice := {
+ request := {
+ holdingIndicator := ?
+ }
+ }
+ }
+
+ template(value) Mcid m_mcid_response_mcidIndicatorTrue := {
+ choice := {
+ response := {
+ mcidResponseIndicator := "1",
+ holdingProvidedIndicator := "0"
+ }
+ }
+ }
+
+ template(present) Mcid mw_mcid_response_mcidIndicatorTrue
+ modifies m_mcid_response_mcidIndicatorTrue := {
+ choice := {
+ response := {
+ holdingProvidedIndicator := ?
+ }
+ }
+ }
+
+ template(present) Mcid mw_mcid_response_mcidIndicatorTrue_holdProvIndFalse
+ modifies mw_mcid_response_mcidIndicatorTrue := {
+ choice := {
+ response := {
+ holdingProvidedIndicator := "0"
+ }
+ }
+ }
+
+ template(present) Mcid mw_mcid_response_mcidIndicatorTrue_holdProvIndTrue
+ modifies mw_mcid_response_mcidIndicatorTrue := {
+ choice := {
+ response := {
+ holdingProvidedIndicator := "1"
+ }
+ }
+ }
+
+ } // end group mcidTemplates
+
+ group pstnTemplates {
+
+ template(value) PSTN_transit m_PSTN_transit_BC1(
+ template(value) BearerCapabilityType p_bct
+ ) := {
+ bearerInfomationElement_list := {p_bct},
+ highLayerCompatibility_list := {},
+ lowLayerCompatibility := omit,
+ progressIndicator_list := {},
+ display_list := {}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC2(
+ template(value) BearerCapabilityType p_bct,
+ template(value) BearerCapabilityType p_bct2
+ ) modifies m_PSTN_transit_BC1 := {
+ bearerInfomationElement_list := {p_bct, p_bct2}
+ }
+
+ template(present) PSTN_transit mw_PSTN_transit_bc(
+ template(present) BearerCapabilityType p_bct := ?,
+ template(present) BearerCapabilityType p_bct2 := ?
+ ) := {
+ bearerInfomationElement_list := {p_bct, p_bct2},
+ highLayerCompatibility_list := {*, *},
+ lowLayerCompatibility := *,
+ progressIndicator_list := ?,
+ display_list := ?
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_HLC1(
+ template(value) BearerCapabilityType p_bct,
+ template(value) HighLayerCompatibilityType p_hlc
+ ) modifies m_PSTN_transit_BC1 := {
+ highLayerCompatibility_list := {p_hlc}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_HLC2(
+ template(value) BearerCapabilityType p_bct,
+ template(value) HighLayerCompatibilityType p_hlc,
+ template(value) HighLayerCompatibilityType p_hlc2
+ ) modifies m_PSTN_transit_BC1_HLC1 := {
+ highLayerCompatibility_list := {p_hlc, p_hlc2}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_LLC(
+ template(value) BearerCapabilityType p_bct,
+ template(value) LowLayerCompatibilityType p_llc
+ ) modifies m_PSTN_transit_BC1 := {
+ lowLayerCompatibility := p_llc
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_PI1(
+ template(value) BearerCapabilityType p_bct,
+ template(value) ProgressIndicatorType p_pi1
+ ) modifies m_PSTN_transit_BC1 := {
+ progressIndicator_list := {p_pi1}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_PI2(
+ template(value) BearerCapabilityType p_bct,
+ template(value) ProgressIndicatorType p_pi1,
+ template(value) ProgressIndicatorType p_pi2
+ ) modifies m_PSTN_transit_BC1_PI1 := {
+ progressIndicator_list := {p_pi1, p_pi2}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_PI3(
+ template(value) BearerCapabilityType p_bct,
+ template(value) ProgressIndicatorType p_pi1,
+ template(value) ProgressIndicatorType p_pi2,
+ template(value) ProgressIndicatorType p_pi3
+ ) modifies m_PSTN_transit_BC1_PI2 := {
+ progressIndicator_list := {p_pi1, p_pi2, p_pi3}
+ }
+
+ template(value) PSTN_transit m_PSTN_transit_BC1_HLC1_PI1(
+ template(value) BearerCapabilityType p_bct,
+ template(value) HighLayerCompatibilityType p_hlc,
+ template(value) ProgressIndicatorType p_pi1
+ ) modifies m_PSTN_transit_BC1_HLC1 := {
+ progressIndicator_list := {p_pi1}
+ }
+
+ template(value) BearerCapabilityType m_BearerCapabilityType(
+ template(value) Bit5 p_InfoTrfCap
+ ) := {
+ bCoctet3 := {
+ codingStandard := "00", // Coding standard = CCITT standardized coding
+ informationTransferCabability := bit2str(valueof(p_InfoTrfCap)) // Information transfer capability
+ },
+ bCoctet4 := {
+ transferMode := "00", // Coding standard = CCITT standardized coding
+ informationTransferRate := "10000" // Information transfer rate = 64 kbit/s
+ },
+ bCoctet4_1 := omit,
+ bCoctet5 := omit,
+ bCoctet5a := omit,
+ bCoctet5bV110 := omit,
+ bCoctet5bV120 := omit,
+ bCoctet5c := omit,
+ bCoctet5d := omit,
+ bCoctet6 := omit,
+ bCoctet7 := omit,
+ bCoctet7a := omit,
+ bCoctet7b := omit
+ }
+
+ template(present) BearerCapabilityType mw_BearerCapabilityType(
+ template(present) BCOctet3Type p_BCOctet3Type := ?,
+ template(present) BCOctet4Type p_BCOctet4Type := ?
+ ) := {
+ bCoctet3 := p_BCOctet3Type,
+ bCoctet4 := p_BCOctet4Type,
+ bCoctet4_1 := *,
+ bCoctet5 := *,
+ bCoctet5a := *,
+ bCoctet5bV110 := *,
+ bCoctet5bV120 := *,
+ bCoctet5c := *,
+ bCoctet5d := *,
+ bCoctet6 := *,
+ bCoctet7 := *,
+ bCoctet7a := *,
+ bCoctet7b := *
+ }
+
+ template(present) BearerCapabilityType mw_BearerCapabilityType_TrfCap(
+ template(value) Bit5 p_InfoTrfCap
+ ) modifies m_BearerCapabilityType := {
+ bCoctet4_1 := *,
+ bCoctet5 := *,
+ bCoctet5a := *,
+ bCoctet5bV110 := *,
+ bCoctet5bV120 := *,
+ bCoctet5c := *,
+ bCoctet5d := *,
+ bCoctet6 := *,
+ bCoctet7 := *,
+ bCoctet7a := *,
+ bCoctet7b := *
+ }
+
+ template(value) ProgressIndicatorType m_ProgressIndicatorType(
+ template(value) Bit7 p_progDesc
+ ) := {
+ progressOctet3 := {
+ codingStandard := "00",
+ location := "0000"
+ },
+ progressOctet4 := {
+ progressDescription := bit2str(valueof(p_progDesc))
+ }
+ }
+
+ template(present) ProgressIndicatorType mw_ProgressIndicatorType(
+ template(present) ProgressOctet3Type p_ProgressOctet3Type := ?,
+ template(present) ProgressOctet4Type p_ProgressOctet4Type := ?
+ ) := {
+ progressOctet3 := p_ProgressOctet3Type,
+ progressOctet4 := p_ProgressOctet4Type
+ }
+
+ template(value) LowLayerCompatibilityType m_LowLayerCompatibilityType(
+ template(value) Bit5 p_InfoTrfCap
+ ) := {
+ lLOctet3 := {
+ codingStandard := "00", // Coding standard = CCITT standardized coding
+ informationTransferCapability := bit2str(valueof(p_InfoTrfCap)) // Information transfer capability
+ },
+ lLOctet3a := omit,
+ lLOctet4 := {
+ transferMode := "00", // Coding standard = CCITT standardized coding
+ informationTransferRate := "10000" // Information transfer rate = 64 kbit/s
+ },
+ lLOctet4_1 := omit,
+ lLOctet5 := omit,
+ lLOctet5a := omit,
+ lLOctet5bV110 := omit,
+ lLOctet5bV120 := omit,
+ lLOctet5c := omit,
+ lLOctet5d := omit,
+ lLOctet6 := omit,
+ lLOctet6aHDLC := omit,
+ lLOctet6aUserSpecific := omit,
+ lLOctet6b := omit,
+ lLOctet7 := {
+ layer3Identification := "11",
+ userInfoLayer3Protocol := "00010"
+ },
+ lLOctet7aUserSpecific := omit,
+ lLOctet7aX25 := omit,
+ lLOctet7bX25 := omit,
+ lLOctet7c := omit,
+ lLOctet7aTR9577 := omit,
+ lLOctet7bTR9577 := omit
+ }
+
+ template(present) LowLayerCompatibilityType mw_LowLayerCompatibilityType(
+ template(present) LLOctet3Type p_LLOctet3 := ?,
+ template(present) LLOctet4Type p_LLOctet4 := ?,
+ template(present) LLOctet7Type p_LLOctet7 := ?
+ ) := {
+ lLOctet3 := p_LLOctet3,
+ lLOctet3a := *,
+ lLOctet4 := p_LLOctet4,
+ lLOctet4_1 := *,
+ lLOctet5 := *,
+ lLOctet5a := *,
+ lLOctet5bV110 := *,
+ lLOctet5bV120 := *,
+ lLOctet5c := *,
+ lLOctet5d := *,
+ lLOctet6 := *,
+ lLOctet6aHDLC := *,
+ lLOctet6aUserSpecific := *,
+ lLOctet6b := *,
+ lLOctet7 := p_LLOctet7,
+ lLOctet7aUserSpecific := *,
+ lLOctet7aX25 := *,
+ lLOctet7bX25 := *,
+ lLOctet7c := *,
+ lLOctet7aTR9577 := *,
+ lLOctet7bTR9577 := *
+ }
+
+ template(value) HighLayerCompatibilityType m_HighLayerCompatibilityType(
+ template(value) Bit7 p_HLOctet4
+ ) := {
+ hLOctet3 := {
+ codingStandard := "00",
+ interpretation := "100",
+ presentationMethod := "01"
+ },
+ hLOctet4 := {
+ highLayerCharacteristics := bit2str(valueof(p_HLOctet4))
+ },
+ hLOctet4aMaintenance := omit,
+ hLOctet4Audio := omit
+ }
+
+ template(present) HighLayerCompatibilityType mw_HighLayerCompatibilityType(
+ template(present) HLOctet3Type p_HLOctet3 := ?,
+ template(present) HLOctet4Type p_HLOctet4 := ?
+ ) := {
+ hLOctet3 := p_HLOctet3,
+ hLOctet4 := p_HLOctet4,
+ hLOctet4aMaintenance := *,
+ hLOctet4Audio := *
+ }
+
+ } // end group pstnTemplates
+
+ group cdivnTemplates {
+
+ /* general CDIVN subscription */
+ template(value) Comm_div_info_type m_CDIVN_sub := {
+ entity := "comm-div-info",
+ comm_div_subs_info := {
+ attr := omit,
+ comm_div_selection_criteria := {
+ attr := omit,
+ originating_user_selection_criteria := omit,
+ diverting_user_selection_criteria := omit,
+ diverted_to_user_selection_criteria := omit,
+ diversion_time_selection_criteria := omit,
+ diversion_reason_selection_criteria := omit,
+ elem_list := {}
+ },
+ comm_div_ntfy_trigger_criteria := omit,
+ comm_div_info_selection_criteria := omit,
+ elem_list := {}
+ },
+ comm_div_ntfy_info := omit,
+ elem_list := {}
+ }
+
+ } // end group cdivnTemplates
+
+ group resourceListsTemplates {
+
+ template(value) Resource_lists m_ResourceList_2Users(
+ template(value) EntryType p_user1,
+ template(value) EntryType p_user2
+ ) := {
+ sequence_list := {
+ {
+ list := {
+ name := omit,
+ attr := omit,
+ display_name := omit,
+ sequence_list := {
+ {
+ choice := {
+ entry := p_user1
+ }
+ },
+ {
+ choice := {
+ entry := p_user2
+ }
+ }
+ },
+ elem_list := {}
+ }
+ }
+ }
+ }
+
+ template(value) EntryType m_EntryUser(
+ template(value) SipUrl p_user
+ ) := {
+ uri :=
+ p_user.components.sip.userInfo.userOrTelephoneSubscriber
+ & "@"
+ & p_user.components.sip.hostPort.host,
+ attr := omit,
+ display_name := omit,
+ elem_list := {}
+ }
+
+ } // end group resourceListsTemplates
+
+ group ims3GppTemplates {
+
+ template(present) TIMS3GPP mw_Ims_3gpp_CW := {
+ version := 1.0,
+ attr := *,
+ choice := {
+ alternative_service := {
+ attr := *,
+ type_ := ?,
+ reason := ?,
+ elem_list := ?
+ }
+ },
+ elem_list := ?
+ }
+
+ } // end group ims3gppTemplates
+
+ group confTemplates {
+
+ template(value) XSD.Boolean m_boolXSD_true := true;
+
+ template(value) XSD.Boolean m_boolXSD_false := false;
+
+ template(value) urn_ietf_params_xml_ns_conference_info.Media_type m_mediatype_status(
+ template(value) Media_status_type p_status
+ ) := {
+ id := "1",
+ attr := omit,
+ display_text := omit,
+ type_ := omit,
+ label_ := omit,
+ src_id := omit,
+ status := p_status,
+ elem_list := {}
+ }
+
+ template(value) Endpoint_type m_endpoint(
+ template(omit) charstring p_Uri := omit,
+ template(omit) Endpoint_status_type p_epStatus := omit,
+ template(omit) Joining_type p_joinMethod := omit,
+ template(omit) Disconnection_type p_discMethod := omit,
+ template(value) urn_ietf_params_xml_ns_conference_info.Media_type p_mediastatus
+ ) := {
+ entity := p_Uri,
+ state := full,
+ attr := omit,
+ display_text := omit,
+ referred := omit,
+ status := p_epStatus,
+ joining_method := p_joinMethod,
+ joining_info := omit,
+ disconnection_method := p_discMethod,
+ disconnection_info := omit,
+ media_list := {p_mediastatus}, // optional,
+ call_info := omit,
+ elem_list := {}
+ }
+
+ template(value) User_type m_1user(
+ template(omit) charstring p_Uri := omit,
+ template(value) Endpoint_type p_endpoint
+ ) := {
+ entity := p_Uri,
+ state := full,
+ attr := omit,
+ display_text := omit,
+ associated_aors := omit,
+ roles := omit,
+ languages := omit,
+ cascaded_focus := omit,
+ endpoint_list := {p_endpoint}, // optional,
+ elem_list := {}
+ }
+
+ template(value) Users_type m_users_1user_full(
+ template(value) User_type p_user
+ ) := {
+ state := full,
+ attr := omit,
+ user_list := {p_user},
+ elem_list := {}
+ }
+
+ template(value) Users_type m_users_2user_full(
+ template(value) User_type p_user,
+ template(value) User_type p_user2
+ ) modifies m_users_1user_full := {
+ user_list := {p_user, p_user2}
+ }
+
+ template(value) Conference_state_type m_conference_state(
+ template(value) UnsignedInt p_nUsers,
+ template(value) boolean p_active,
+ template(value) boolean p_locked
+ ) := {
+ attr := omit,
+ user_count := p_nUsers,
+ active := p_active,
+ locked := p_locked,
+ elem_list := {}
+ }
+
+ template(value) Conference_type m_ci_cUri_cState_userEntity(
+ template(value) charstring p_cUri,
+ template(value) Conference_state_type p_cState,
+ template(value) Users_type p_users
+ ) := {
+ entity := p_cUri,
+ state := full,
+ version := 1,
+ attr := omit,
+ conference_description := omit,
+ host_info := omit,
+ conference_state := p_cState,
+ users := p_users,
+ sidebars_by_ref := omit,
+ sidebars_by_val := omit,
+ elem_list := {}
+ }
+
+ template(present) Conference_type mw_conferenceInfo_active := {
+ entity := ?,
+ state := *,
+ version := *,
+ attr := *,
+ conference_description := *,
+ host_info := *,
+ conference_state := ?,
+ users := {
+ state := ?,
+ attr := *,
+ user_list := {
+ {
+ entity := *,
+ state := *,
+ attr := *,
+ display_text := *,
+ associated_aors := *,
+ roles := *,
+ languages := *,
+ cascaded_focus := *,
+ endpoint_list := {
+ {
+ entity := *,
+ state := *,
+ attr := *,
+ display_text := *,
+ referred := *,
+ status := connected,
+ joining_method := dialed_in,
+ joining_info := *,
+ disconnection_method := *,
+ disconnection_info := *,
+ media_list := ?,
+ call_info := *,
+ elem_list := ?
+ }
+ },
+ elem_list := ?
+ }
+ },
+ elem_list := ?
+ },
+ sidebars_by_ref := *,
+ sidebars_by_val := *,
+ elem_list := ?
+ }
+ }
+
+ } // end group messageBodyTemplates
+
+ group messageTemplates {
+
+ group modifiedTemplates {
+
+ group requestSend {
+
+ template(value) ACK_Request m_ACK_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit
+ ) modifies m_ACK_Request_Base := {
+ msgHeader := {route := p_route}
+ }
+
+ template(value) ACK_Request m_ACK_Request_AS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit
+ ) modifies m_ACK_Request_IMS := {
+ msgHeader := {
+ route := p_route,
+ recordRoute := p_recordRoute
+ }
+ }
+
+ template(value) ACK_Request m_ACK_Request_sdp_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb,
+ template(omit) Route p_route := omit
+ ) modifies m_ACK_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ route := p_route
+ },
+ messageBody := p_mb
+ }
+
+ template(value) ACK_Request m_ACK_Request_Mime_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) MessageBody p_mb,
+ template(omit) Route p_route := omit
+ ) modifies m_ACK_Request_Base := {
+ msgHeader := {
+ contentLength := {
+ fieldName := CONTENT_LENGTH_E,
+ len := f_MessageBodyLength(valueof(p_mb))
+ },
+ contentType := {
+ fieldName := CONTENT_TYPE_E,
+ mediaType := c_mimeMultipart
+ },
+ route := p_route
+ },
+ messageBody := p_mb
+ }
+
+ template(value) BYE_Request m_BYE_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit
+ ) modifies m_BYE_Request_Base := {
+ msgHeader := {
+ route := p_route,
+ recordRoute := p_recordRoute // used in case of AS as TS - for ISC interface
+ }
+ } // end of temlate m_BYE_Request_IMS
+
+ template(value) BYE_Request m_BYE_Request_Reason_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(value) GenValue p_cause
+ ) modifies m_BYE_Request_Base := {
+ msgHeader := {
+ reason := mw_Reason(p_cause),
+ route := p_route
+ }
+ }
+
+ template(value) BYE_Request m_BYE_Request_UserToUser_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(value) UserToUser.uuiData p_U2UData
+ ) modifies m_BYE_Request_Base := {
+ msgHeader := {
+ route := p_route,
+ userToUser := m_UserToUserData(p_U2UData)
+ }
+ }
+
+ template(value) BYE_Request m_BYE_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit
+ ) modifies m_BYE_Request_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ route := p_route
+ }
+ }
+
+ template(value) CANCEL_Request m_CANCEL_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit
+ ) modifies m_CANCEL_Request_Base := {
+ msgHeader := {route := p_route}
+ }
+
+ template(value) CANCEL_Request m_CANCEL_Request_Reason_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(value) integer p_cause
+ ) modifies m_CANCEL_Request_IMS := {
+ msgHeader := {reason := m_Reason(p_cause)}
+ }
+
+ template(value) CANCEL_Request m_CANCEL_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit
+ ) modifies m_CANCEL_Request_IMS := {
+ }
+
+ /**
+ * @desc INFO message
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_mb
+ */
+ template(value) INFO_Request m_INFO_Request_IMS_Base(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb
+ ) modifies m_INFO_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb))
+ },
+ messageBody := p_mb
+ }
+
+ /**
+ * @desc INFO message
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_mb
+ */
+ template(value) INFO_Request m_INFO_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb
+ ) modifies m_INFO_Request_IMS_Base := {
+ msgHeader := {
+ contentType := m_contentType(c_sdpApplication)
+ }
+ }
+
+ /**
+ * @desc INFO message
+ * @desc
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_mb
+ */
+ template(value) INFO_Request m_INFO_Request_Mime_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb
+ ) modifies m_INFO_Request_IMS_Base := {
+ msgHeader := {
+ contentType := m_contentType(c_mimeMultipart)
+ }
+ }
+
+ template(value) INFO_Request m_INFO_Request_Xml_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb
+ ) modifies m_INFO_Request_IMS_Base := {
+ msgHeader := {
+ contentType := m_contentType(c_xmlApplication)
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_noBody_UE := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication)
+ },
+ messageBody := p_mb
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_noBody_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ require := p_require,
+ route := p_route,
+ supported := p_supported
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_Allow_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb,
+ template(value) LibSip_SIPTypesAndValues.Allow p_allow
+ ) modifies m_INVITE_Request_UE := {
+ msgHeader := {allow := p_allow}
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_noBody_Allow_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) LibSip_SIPTypesAndValues.Allow p_allow
+ ) modifies m_INVITE_Request_noBody_UE := {
+ msgHeader := {allow := p_allow}
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) INVITE_Request m_INVITE_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := p_mb
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ * @param p_historyInfo
+ */
+ template(value) INVITE_Request m_INVITE_Request_HistoryInfo_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb,
+ template(value) HistoryInfo p_historyInfo
+ ) modifies m_INVITE_Request_IMS := {
+ msgHeader := {
+ historyInfo := p_historyInfo
+ }
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) INVITE_Request m_INVITE_Request_Mime_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_IMS := {
+ msgHeader := {
+ contentType := m_contentType(c_mimeMultipart)
+ }
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ */
+ template(value) INVITE_Request m_INVITE_Request_IMS_noBody(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ require := p_require,
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ supported := p_supported
+ }
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ * @param p_pAssertedID
+ * @param p_privacy
+ */
+ template(value) INVITE_Request m_INVITE_Request_Mime_PAsserted_Privacy_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb,
+ template(value) PAssertedID p_pAssertedID,
+ template(value) Privacy p_privacy
+ ) modifies m_INVITE_Request_Mime_IMS := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ privacy := p_privacy
+ }
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_acceptContact
+ * @param p_pAssertedID
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) INVITE_Request m_INVITE_Request_PAsserted_AcceptContact_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) AcceptContact p_acceptContact,
+ template(value) PAssertedID p_pAssertedID,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ acceptContact := p_acceptContact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ pAssertedID := p_pAssertedID,
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := p_mb
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_pAssertedID
+ * @param p_privacy
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) INVITE_Request m_INVITE_Request_PAsserted_Privacy_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) PAssertedID p_pAssertedID,
+ template(value) Privacy p_privacy,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ pAssertedID := p_pAssertedID,
+ pChargingVector := p_pChargingVector,
+ privacy := p_privacy,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := p_mb
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ * @param p_pAssertedService
+ */
+ template(value) INVITE_Request m_INVITE_Request_PAssertedService_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb,
+ template(value) PAssertedService p_pAssertedService
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ pChargingVector := p_pChargingVector,
+ route := p_route,
+ supported := p_supported,
+ pAssertedService := p_pAssertedService
+ },
+ messageBody := p_mb
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) INVITE_Request m_INVITE_Request_PEarlyMedia_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_INVITE_Request_IMS := {
+ msgHeader := {
+ pEarlyMedia := m_pEarlyMedia_sup
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_PPreferred_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb,
+ template(value) PPreferredID p_pPreferredID
+ ) modifies m_INVITE_Request_UE := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_PPreferred_Privacy_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb,
+ template(value) PPreferredID p_pPreferredID,
+ template(value) Privacy p_privacy
+ ) modifies m_INVITE_Request_UE := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID,
+ privacy := p_privacy
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_SessionExpires_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb,
+ template(value) SessionExpires p_se
+ ) modifies m_INVITE_Request_UE := {
+ msgHeader := {
+ sessionExpires := p_se
+ }
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_minSE_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb,
+ template(value) MinSE p_minSE
+ ) modifies m_INVITE_Request_UE := {
+ msgHeader := {
+ minSE := p_minSE
+ }
+ }
+
+ /**
+ * @desc INVITE message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_contact
+ * @param p_require
+ * @param p_route
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ * @param p_minSE
+ */
+ template(value) INVITE_Request m_INVITE_Request_minSE_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb,
+ template(value) MinSE p_minSE
+ ) modifies m_INVITE_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ pChargingVector := p_pChargingVector,
+ route := p_route,
+ supported := p_supported,
+ minSE := p_minSE
+ },
+ messageBody := p_mb
+ }
+
+ template(value) INVITE_Request m_INVITE_Request_User2UserData_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Contact p_contact,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb,
+ template(value) UserToUser.uuiData p_U2UData
+ ) modifies m_INVITE_Request_IMS := {
+ msgHeader := {
+ userToUser := m_UserToUserData(p_U2UData)
+ }
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_MBody_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_MESSAGE_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(m_MBody_longPlainText)),
+ contentType := m_contentType(c_plainText),
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ require := p_require,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := p_mb
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_NoBody_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit
+ ) modifies m_MESSAGE_Request_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ require := p_require,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := omit
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_PCharging_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) GenValue p_homeDomain
+ ) modifies m_MESSAGE_Request_NoBody_UE := {
+ msgHeader := {
+ pChargingFunctionAddresses := m_pChargingFunctionAddresses_fixedValue,
+ pChargingVector := m_pChargingVector_origIoi_fixedValue(p_homeDomain)
+ }
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_PCharging_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit
+ ) modifies m_MESSAGE_Request_NoBody_UE := {
+ msgHeader := {
+ pAccessNetworkInfo := omit,
+ pChargingFunctionAddresses := m_pChargingFunctionAddresses_fixedValue,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_PMediaAuth_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit
+ ) modifies m_MESSAGE_Request_NoBody_UE := {
+ msgHeader := {
+ pMediaAuthorization := m_pMediaAuthorization_fixedValue
+ }
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_PPreferred_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit,
+ template(value) PPreferredID p_pPreferredID
+ ) modifies m_MESSAGE_Request_NoBody_UE := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ template(value) MESSAGE_Request m_MESSAGE_Request_1300Bytes_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) Supported p_supported := omit
+ ) modifies m_MESSAGE_Request_NoBody_UE := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(m_MBody_longPlainText)),
+ contentType := m_contentType(c_plainText)
+ },
+ messageBody := m_MBody_longPlainText
+ }
+
+ template(value) NOTIFY_Request m_NOTIFY_Request_Xml_IMS_Conference(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) MessageBody p_mb
+ ) modifies m_NOTIFY_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_xmlApplication),
+ event := {
+ fieldName := EVENT_E,
+ eventType := "conference",
+ eventParams := omit
+ },
+ subscriptionState := {
+ fieldName := SUBSCRIPTION_STATE_E,
+ subState := "active",
+ substateParams := omit
+ },
+ expires := m_expires(3600)
+ },
+ messageBody := p_mb
+ }
+
+ template(value) NOTIFY_Request m_NOTIFY_Request_Xml_IMS_RegInfo(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_NOTIFY_Request_Base := {
+ msgHeader := {
+ contact := p_contact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_xmlreginfoApplication),
+ event := m_Event_reg,
+ subscriptionState := m_SubscriptionState_active,
+ expires := m_expires(3600)
+ },
+ messageBody := p_mb
+ }
+
+ template(value) PRACK_Request m_PRACK_Request_sdp(
+ template(value) SipUrl p_requestUri,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) RAck p_RAck,
+ template(value) MessageBody p_mb
+ ) modifies m_PRACK_Request_Base := {
+ requestLine := {requestUri := p_requestUri},
+ msgHeader := {
+ callId := p_callId,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ cSeq := m_cSeq(p_cSeq.seqNumber, "PRACK"),
+ fromField := p_from,
+ rAck := p_RAck,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := p_mb
+ }
+
+ template(value) PUBLISH_Request m_PUBLISH_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Event p_event := omit,
+ template(omit) RAck p_RAck := omit,
+ template(value) MessageBody p_mb,
+ template(omit) Route p_route := omit
+ ) modifies m_PUBLISH_Request_Base := {
+ requestLine := {requestUri := p_requestUri},
+ msgHeader := {
+ callId := p_callId,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_plainText /*c_sdpApplication*/),
+ cSeq := m_cSeq(p_cSeq.seqNumber, "PUBLISH"),
+ event := p_event,
+ fromField := p_from,
+ route := p_route,
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := p_mb
+ }
+
+ template(value) PUBLISH_Request m_PUBLISH_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Event p_event := omit,
+ template(omit) RAck p_RAck := omit,
+ template(value) MessageBody p_mb,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) PChargingVector p_pChargingVector := omit
+ ) modifies m_PUBLISH_Request_UE := {
+ msgHeader := {
+ recordRoute := p_recordRoute,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ /**
+ * @desc REFER message exchanged at Mw
+ * @param p_requestUri
+ * @param p_callId
+ * @param p_cSeq
+ * @param p_contact
+ * @param p_from
+ * @param p_to
+ * @param p_via
+ * @param p_referTo
+ * @param p_referredBy
+ * @param p_require
+ * @param p_route
+ * @param p_recordRoute
+ * @param p_supported
+ * @param p_pChargingVector
+ * @param p_mb
+ */
+ template(value) REFER_Request m_REFER_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(omit) Contact p_contact := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) ReferTo p_referTo,
+ template(omit) ReferredBy p_referredBy := omit,
+ template(omit) Require p_require := omit,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(omit) Supported p_supported := omit,
+ template(omit) PChargingVector p_pChargingVector := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_REFER_Request_Base := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ referredBy := p_referredBy,
+ referTo := p_referTo,
+ require := p_require,
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ supported := p_supported
+ },
+ messageBody := p_mb
+ }
+
+ template(value) REGISTER_Request m_REGISTER_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) Authorization p_authorization := omit,
+ template(omit) ProxyRequire p_proxyRequire := omit,
+ template(omit) Require p_require := omit,
+ template(omit) SecurityClient p_securityClient := omit,
+ template(omit) SecurityVerify p_securityVerify := omit,
+ template(omit) Supported p_supported := omit
+ ) modifies m_REGISTER_Request_Base := {
+ requestLine := {
+ method := REGISTER_E,
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ authorization := p_authorization,
+ callId := p_callId,
+ contact := p_contact,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ proxyRequire := p_proxyRequire,
+ require := p_require,
+ securityClient := p_securityClient,
+ securityVerify := p_securityVerify,
+ supported := p_supported,
+ toField := p_to,
+ via := p_via
+ }
+ }
+
+
+ template(value) REGISTER_Request m_REGISTER_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) Authorization p_authorization := omit,
+ template(value) charstring p_host,
+ template(value) integer p_port
+ ) modifies m_REGISTER_Request_Base := {
+ requestLine := {
+ method := REGISTER_E,
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ authorization := p_authorization,
+ callId := p_callId,
+ contact := p_contact,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ path := m_path_TS(p_host, p_port),
+ pChargingVector := m_pChargingVector_icid_TS,
+ pVisitedNetworkID := m_pVisitedNetworkID_TS,
+ require := {
+ fieldName := REQUIRE_E,
+ optionsTags := {"path"}
+ },
+ toField := p_to,
+ via := p_via
+ }
+ }
+
+ template(value) REGISTER_Request m_REGISTER_Request_IMS_3party(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) Authorization p_authorization := omit,
+ template(value) charstring p_host,
+ template(value) integer p_port,
+ template(omit) Path p_path := omit
+ ) modifies m_REGISTER_Request_IMS := {
+ msgHeader := {path := p_path}
+ }
+
+ template(value) REGISTER_Request m_REGISTER_Request_expires_IMS(
+ template(value) SipUrl p_requestUri,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) Authorization p_authorization := omit,
+ template(value) charstring p_host,
+ template(value) integer p_port,
+ template(value) DeltaSec p_deltaSec
+ ) modifies m_REGISTER_Request_IMS := {
+ msgHeader := {
+ expires := m_expires(str2int(valueof(p_deltaSec)))
+ }
+ }
+
+ template(value) SUBSCRIBE_Request m_SUBSCRIBE_Request_UE(
+ template(value) SipUrl p_requestUri,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) Route p_route := omit
+ ) modifies m_SUBSCRIBE_Request_Base := {
+ requestLine := {
+ method := SUBSCRIBE_E,
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ contact := p_contact,
+ cSeq := m_cSeq(p_cSeq.seqNumber, "SUBSCRIBE"),
+ event := m_Event_reg,
+ expires := m_Expires_600000,
+ route := p_route
+ }
+ }
+
+ template(value) SUBSCRIBE_Request m_SUBSCRIBE_Request_mb_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_SUBSCRIBE_Request_Base := {
+ requestLine := {
+ method := SUBSCRIBE_E,
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a,
+ contact := p_contact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ cSeq := m_cSeq(p_cSeq.seqNumber, "SUBSCRIBE"),
+ event := m_Event_reg,
+ expires := m_Expires_600000
+ },
+ messageBody := p_mb
+ }
+
+ template(value) SUBSCRIBE_Request m_SUBSCRIBE_Request_mb_event_UE(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb,
+ template(value) Event p_event,
+ template(value) charstring p_contentType
+ ) modifies m_SUBSCRIBE_Request_mb_UE := {
+ msgHeader := {
+ contentType := m_contentType(p_contentType),
+ event := p_event
+ }
+ }
+
+ template(value) SUBSCRIBE_Request m_SUBSCRIBE_Request_IMS(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_SUBSCRIBE_Request_Base := {
+ requestLine := {
+ method := SUBSCRIBE_E,
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ contact := p_contact,
+ cSeq := m_cSeq(p_cSeq.seqNumber, "SUBSCRIBE"),
+ event := m_Event_reg,
+ expires := m_Expires_600000
+ }
+ }
+
+ template(value) SUBSCRIBE_Request m_SUBSCRIBE_Request_Event(
+ template(value) SipUrl p_requestUri,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) Event p_event
+ ) modifies m_SUBSCRIBE_Request_IMS := {
+ msgHeader := {
+ event := p_event
+ }
+ }
+
+ } // end group requestSend
+
+ group requestReceive {
+
+ template(present) ACK_Request mw_ACK_Request_noPaccessNetworkInfo(
+ template CallId p_callId
+ ) modifies mw_ACK_Request_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := omit
+ }
+ }
+
+ template(present) ACK_Request mw_ACK_Request_PchargingVector(
+ template CallId p_callId,
+ template(present) PChargingVector p_pChargingVector := ?
+ ) modifies mw_ACK_Request_Base := {
+ msgHeader := {
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(present) BYE_Request mw_BYE_Request_noPChargingFunction_UE(
+ template CallId p_callId
+ ) modifies mw_BYE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit,
+ pChargingVector := omit
+ }
+ }
+
+ template(present) BYE_Request mw_BYE_Request_via_PChargingVector_UE(
+ template CallId p_callId,
+ template(present) PChargingVector p_pChargingVector := ?,
+ template(present) Via p_via := ?
+ ) modifies mw_BYE_Request_Base := {
+ msgHeader := {
+ pChargingVector := p_pChargingVector,
+ via := p_via
+ }
+ }
+
+ template(present) BYE_Request mw_BYE_Request_via_UE(
+ template CallId p_callId,
+ template(present) Via p_via := ?
+ ) modifies mw_BYE_Request_Base := {
+ msgHeader := {
+ via := p_via
+ }
+ }
+
+ template(present) BYE_Request mw_BYE_Request_route(
+ template CallId p_callId,
+ template(present) Route p_route := ?
+ ) modifies mw_BYE_Request_Base := {
+ msgHeader := {
+ route := p_route
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_noPChargingFunction
+ modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_PChargingFunction
+ modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := ?
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_NoPCharging
+ modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit,
+ pChargingVector := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_NoPChargingPreferred
+ modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit,
+ pChargingVector := omit,
+ pPreferredID := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_PAsserted_noPPreferred(
+ template(present) PAssertedID p_pAssertedID := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ pPreferredID := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_PAsserted_AcceptContact(
+ template(present) PAssertedID p_pAssertedID := ?,
+ template(present) AcceptContact p_acceptContact := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ acceptContact := p_acceptContact
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_RecordRoute_Via(
+ template(present) RecordRoute p_recordRoute := ?,
+ template(present) Via p_via := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ recordRoute := p_recordRoute,
+ via := p_via
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_route(
+ template(present) Route p_route := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ route := p_route
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_require(
+ template(present) Require p_require := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ require := p_require
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_supported(
+ template(present) Supported p_supported := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ supported := p_supported
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_SessionExpires(
+ template(present) SessionExpires p_sessionExpires := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ sessionExpires := p_sessionExpires
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_User2UserData(
+ template(present) UserToUser.uuiData p_U2UData := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ userToUser := mw_UserToUserData(p_U2UData)
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ via := p_via
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_requestLine(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via,
+ template(present) SipUrl p_requestUri := ?
+ ) modifies mw_INVITE_Request_IMS := {
+ requestLine := {
+ requestUri := p_requestUri
+ },
+ msgHeader := {
+ pChargingVector := p_pChargingVector,
+ recordRoute := p_recordRoute,
+ route := p_route,
+ via := p_via
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_PAsserted_noPPreferred(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via,
+ template(present) PAssertedID p_pAssertedID := ?
+ ) modifies mw_INVITE_Request_IMS := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ pPreferredID := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_mb(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via
+ ) modifies mw_INVITE_Request_IMS := {
+ messageBody := ?
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_cug(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via,
+ template(present) Cug p_cug := ?
+ ) modifies mw_INVITE_Request_IMS := {
+ messageBody := (
+ mw_MBody_XML(mw_XmlBody_CUG(p_cug)),
+ mw_MBody_MIMESdpXml(?, mw_XmlBody_CUG(p_cug))
+ )
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_noCug(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via
+ ) modifies mw_INVITE_Request_IMS := {
+ messageBody := (
+ mw_MBody_XML(complement(mw_XmlBody_CUG(?))),
+ mw_MBody_MIMESdpXml(?, complement(mw_XmlBody_CUG(?)))
+ )
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_IMS_pstn(
+ template PChargingVector p_pChargingVector,
+ template RecordRoute p_recordRoute,
+ template Route p_route,
+ template Via p_via,
+ template(present) PSTN_transit p_pstn := ?
+ ) modifies mw_INVITE_Request_IMS := {
+ messageBody := (
+ mw_MBody_XML(mw_XmlBody_PSTNTransit(p_pstn)),
+ mw_MBody_MIMESdpXml(?, mw_XmlBody_PSTNTransit(p_pstn))
+ )
+ }
+
+ /**
+ * @desc Await INVITE using topology hiding
+ */
+ template(present) INVITE_Request mw_INVITE_Request_TH
+ modifies mw_INVITE_Request_TH_R10 := {
+ msgHeader := {
+ pChargingVector := omit
+ }
+ }
+
+ template(present) INVITE_Request mw_INVITE_Request_TH_R10
+ modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit
+ }
+ }
+
+ /**
+ * @desc Await INVITE without PAsserted and Privacy
+ * @param p_from
+ */
+ template(present) INVITE_Request mw_INVITE_Request_noPasserted_noPrivacy(
+ template From p_from
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ fromField := p_from,
+ pAssertedID := omit,
+ pPreferredID := omit
+ }
+ }
+
+
+ /**
+ * @desc Await INVITE with PAsserted and Privacy
+ * @param p_from
+ * @param p_pAssertedID
+ * @param p_privacy
+ */
+ template(present) INVITE_Request mw_INVITE_Request_PassertedPrivacy(
+ template From p_from,
+ template(present) PAssertedID p_pAssertedID := ?,
+ template(present) Privacy p_privacy := ?
+ ) modifies mw_INVITE_Request_noPasserted_noPrivacy := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ privacy := p_privacy
+ }
+ }
+
+ /**
+ * @desc Await INVITE with PAsserted and Privacy
+ * @param p_from
+ * @param p_pAssertedID
+ * @param p_privacy
+ */
+ template(present) INVITE_Request mw_INVITE_Request_Passerted_ifPrivacy(
+ template From p_from,
+ template PAssertedID p_pAssertedID,
+ template(present) Privacy p_privacy := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ fromField := p_from,
+ pAssertedID := p_pAssertedID,
+ privacy := p_privacy ifpresent
+ }
+ }
+
+ /**
+ * @desc Await INVITE with history info
+ * @param p_historyInfo
+ */
+ template(present) INVITE_Request mw_INVITE_Request_HistoryInfo(
+ template(present) HistoryInfo p_historyInfo := ?
+ ) modifies mw_INVITE_Request_Base := {
+ msgHeader := {
+ historyInfo := p_historyInfo
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_noPchargingFunction_UE
+ modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit,
+ pChargingVector := omit
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_noPchargingFunctionPrefId_UE
+ modifies mw_MESSAGE_Request_noPchargingFunction_UE := {
+ msgHeader := {
+ pPreferredID := omit
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_noPchargingFunction_IMS :=
+ mw_MESSAGE_Request_noPchargingFunction_UE;
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_PAsserted_noPPreferred(
+ template CallId p_callId,
+ template(present) PAssertedID p_pAssertedID := ?
+ ) modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ callId := p_callId,
+ pAssertedID := p_pAssertedID,
+ pPreferredID := omit
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_route(
+ template CallId p_callId,
+ template(present) Route p_route := ?
+ ) modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ callId := p_callId,
+ route := p_route
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_via(
+ template CallId p_callId,
+ template(present) Via p_via := ?
+ ) modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ callId := p_callId,
+ via := p_via
+ }
+ }
+
+ template(present) NOTIFY_Request mw_NOTIFY_Request(
+ template CallId p_callId,
+ template(present) charstring p_state := ?,
+ template(present) charstring p_contentType := ?,
+ template Event p_event,
+ template MessageBody p_mb
+ ) modifies mw_NOTIFY_Request_Base := {
+ msgHeader := {
+ subscriptionState := mw_subscriptionState(p_state),
+ contentType := mw_contentType(p_contentType),
+ event := p_event
+ },
+ messageBody := p_mb
+ }
+
+ template(present) PRACK_Request mw_PRACK_Request_sdp(
+ template CallId p_callId,
+ template MessageBody p_mb
+ ) modifies mw_PRACK_Request_Base := {
+ msgHeader := {
+ callId := p_callId
+ },
+ messageBody := p_mb
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_PchargingVector(
+ template(present) charstring p_id := ?,
+ template GenValue p_paramValue
+ ) modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ pChargingVector := mw_pChargingVector(p_id, p_paramValue)
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_noPaccessNetworkInfo
+ modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := omit
+ }
+ }
+
+ template(present) MESSAGE_Request mw_MESSAGE_Request_noPMediaAuthorization
+ modifies mw_MESSAGE_Request_Base := {
+ msgHeader := {
+ pMediaAuthorization := omit
+ }
+ }
+
+ template(present) PUBLISH_Request mw_PUBLISH_Request_PchargingVector(
+ template CallId p_callId,
+ template(present) PChargingVector p_pChargingVector := ?
+ ) modifies mw_PUBLISH_Request_Base := {
+ msgHeader := {
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_Request_IMS(
+ template Path p_Path,
+ template PChargingVector p_pChargingVector,
+ template PVisitedNetworkID p_pVisitedNetworkID
+ ) modifies mw_REGISTER_Request_Base := {
+ msgHeader := {
+ authorization := ?,
+ path := p_Path,
+ pChargingVector := p_pChargingVector,
+ pVisitedNetworkID := p_pVisitedNetworkID,
+ require := mw_require_path,
+ securityClient := omit,
+ securityVerify := omit
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_authorizedRequest_IMS(
+ template(present) Authorization p_authorization := ?
+ ) modifies mw_REGISTER_Request_Base := {
+ msgHeader := {
+ authorization := p_authorization
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_authorizedRequest_wo_securityclient_IMS(
+ template(present) Authorization p_authorization := ?
+ ) modifies mw_REGISTER_authorizedRequest_IMS := {
+ msgHeader := {
+ securityClient := omit
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_auth_via_nosecclient_IMS(
+ template(present) Authorization p_authorization := ?,
+ template(present) Via p_via
+ ) modifies mw_REGISTER_authorizedRequest_wo_securityclient_IMS := {
+ msgHeader := {
+ via := p_via
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_authorizedRequest_wo_securityheaders_IMS
+ modifies mw_REGISTER_Request_Base := {
+ msgHeader := {
+ securityVerify := omit,
+ securityClient := omit
+ }
+ }
+
+ template(present) REGISTER_Request mw_REGISTER_unauthorizedRequest_IMS
+ modifies mw_REGISTER_Request_Base := {
+ msgHeader := {
+ authorization := *
+ }
+ }
+
+ template(present) SUBSCRIBE_Request mw_SUBSCRIBE_Request_IMS(
+ template(present) From p_from := ?,
+ template(present) To p_to := ?,
+ template PAssertedID p_pAssertedID,
+ template PChargingVector p_pChargingVector
+ ) modifies mw_SUBSCRIBE_Request_Base := {
+ requestLine := {
+ method := SUBSCRIBE_E
+ },
+ msgHeader := {
+ fromField := p_from,
+ toField := p_to,
+ event := m_Event_reg,
+ pAccessNetworkInfo := *,
+ pAssertedID := p_pAssertedID,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(present) UPDATE_Request mw_UPDATE_Request_fromChange(
+ template CallId p_callId,
+ template(present) From p_from := ?
+ ) modifies mw_UPDATE_Request_Base := {
+ msgHeader := {
+ callId := p_callId,
+ fromField := p_from
+ }
+ }
+
+ } // end group requestReceive
+
+ group responseSend {
+
+ group responseSend1xx {
+
+ template(value) Response m_Response_18x_Base(
+ template(value) StatusLine_18x p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_Dummy := {
+ statusLine := p_statusLine,
+ msgHeader := {
+ callId := p_callId,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ maxForwards := omit,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := omit,
+ payload := omit
+ }
+
+ template(value) Response m_Response_18XonINVITE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ contact := p_contact // mandatory field due to 24 229 rel 7.9
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_AlertInfo(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) AlertInfo p_alertInfo
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ alertInfo := p_alertInfo
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_sdp_require(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb,
+ template(omit) Require p_require := omit
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ contact := p_contact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ require := p_require,
+ rSeq := m_rseq9999
+ },
+ messageBody := p_mb
+ }
+
+ template(value) Response m_Response_18XonINVITE_AS(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ contact := p_contact,
+ recordRoute := p_recordRoute
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ contact := p_contact,
+ rSeq := m_rseq9999
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_HistoryInfo_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) HistoryInfo p_historyInfo
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ historyInfo := p_historyInfo
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_PchargingVector(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) PChargingVector p_pChargingVector
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ contact := p_contact,
+ pChargingFunctionAddresses := m_pChargingFunctionAddresses_fixedValue,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_pEearlyMedia(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) PEarlyMedia p_pEarlyMedia
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ pEarlyMedia := p_pEarlyMedia
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_pPreferred_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) PPreferredID p_pPreferredID
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_pAsserted_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) PAssertedID p_pAssertedID
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_pAsserted_privacy_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) PAssertedID p_pAssertedID,
+ template(value) Privacy p_privacy
+ ) modifies m_Response_18XonINVITE_pAsserted_UE := {
+ msgHeader := {
+ privacy := p_privacy
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_privacy_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) Privacy p_privacy
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ privacy := p_privacy
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_supported and p_privacy to be able to modify from m_Response_18XonINVITE_privacy_UE
+ template(value) Response m_Response_18XonINVITE_supported_privacy_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) Privacy p_privacy,
+ template(value) Supported p_supported
+ ) modifies m_Response_18XonINVITE_privacy_UE := {
+ msgHeader := {
+ supported := p_supported
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_recordRoute_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) RecordRoute p_recordRoute
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ recordRoute := p_recordRoute // for INVITE response
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_Require(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) Require p_require
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ require := p_require
+ }
+ }
+
+ // NOTE STF471: removed m_Response_18XonINVITE_Require_ifpresent as it is same as m_Response_18XonINVITE_Require
+ template(value) Response m_Response_18XonINVITE_UserToUser(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) UserToUser.uuiData p_U2UData
+ ) modifies m_Response_18x_Base := {
+ msgHeader := {
+ userToUser := m_UserToUserData(p_U2UData)
+ }
+ }
+
+ template(value) Response m_Response_18XonINVITE_Xml(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_18XonINVITE_UE := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_xmlApplication)
+ },
+ messageBody := p_mb
+ }
+
+ template(value) Response m_Response_18XonINVITE_sdp_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_18XonINVITE_Xml := {
+ msgHeader := {
+ contentType := m_contentType(c_sdpApplication)
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_require and p_mb to be able to modify from m_Response_18XonINVITE_sdp_UE
+ template(value) Response m_Response_18XonINVITE_require_sdp_UE(
+ template(value) StatusLine_18x p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) MessageBody p_mb,
+ template(omit) Require p_require := omit,
+ template(omit) LibSip_SIPTypesAndValues.Allow p_allow := omit
+ ) modifies m_Response_18XonINVITE_sdp_UE := {
+ msgHeader := {
+ require := p_require,
+ allow := p_allow
+ }
+ }
+
+ } // end group responseSend1xx
+
+ group responseSend2xx {
+
+ template(value) Response m_Response_2xx_Base(
+ template(value) StatusLine_2xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_Dummy := {
+ statusLine := p_statusLine,
+ msgHeader := {
+ callId := p_callId,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ maxForwards := omit,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := omit,
+ payload := omit
+ }
+
+ template(value) Response m_Response_2xx_ext(
+ template(value) StatusLine_2xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordroute := omit
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ route := p_route, // f_route(),
+ recordRoute :=
+ p_recordroute // f_recordroute()
+ }
+ }
+
+ template(value) Response m_Response_2xx_mbody(
+ template(value) StatusLine_2xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordroute := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_2xx_ext := {
+ msgHeader := {
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication)
+ },
+ messageBody := p_mb
+ }
+
+ template(value) Response m_Response_2xxonBYE_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ template(value) Response m_Response_2xxonINVITE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ contact := p_contact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ recordRoute := p_recordRoute // for INVITE response
+ },
+ messageBody := p_mb
+ }
+
+ // NOTE STF471: changed order of parameter p_historyInfo and p_mb to be able to modify from m_Response_2xxonINVITE
+ template(value) Response m_Response_2xxonINVITE_HistoryInfo(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) HistoryInfo p_historyInfo
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ historyInfo := p_historyInfo
+ }
+ }
+
+ template(value) Response m_Response_2xxonINVITE_Mime(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ contentType := m_contentType(c_mimeMultipart)
+ }
+ }
+
+ template(value) Response m_Response_2xxonINVITE_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_2xxonINVITE := {
+ }
+
+ template(value) Response m_Response_2xxonINVITE_PchargingVector(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Route p_route := omit,
+ template(omit) RecordRoute p_recordroute := omit,
+ template(value) MessageBody p_mb,
+ template(omit) Contact p_contact := omit,
+ template(value) PChargingVector p_pChargingVector
+ ) modifies m_Response_2xx_mbody := {
+ msgHeader := {
+ contact := p_contact,
+ pChargingFunctionAddresses := m_pChargingFunctionAddresses_fixedValue,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_pPreferredID and p_mb to be able to modify from m_Response_2xxonINVITE
+ template(value) Response m_Response_2XXonINVITE_pPreferred_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) PPreferredID p_pPreferredID
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_pPreferredID and p_mb to be able to modify from m_Response_2xxonINVITE
+ template(value) Response m_Response_2XXonINVITE_pAsserted_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) PAssertedID p_pAssertedID
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_pAssertedID/p_privacy and p_mb to be able to modify from m_Response_2XXonINVITE_pAsserted_UE
+ template(value) Response m_Response_2XXonINVITE_pAsserted_privacy_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) PAssertedID p_pAssertedID,
+ template(value) Privacy p_privacy
+ ) modifies m_Response_2XXonINVITE_pAsserted_UE := {
+ msgHeader := {
+ privacy := p_privacy
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_privacy and p_mb to be able to modify from m_Response_2xxonINVITE
+ template(value) Response m_Response_2XXonINVITE_privacy_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) Privacy p_privacy
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ privacy := p_privacy
+ }
+ }
+
+ // NOTE STF471: changed order of parameter p_supported/p_privacy and p_mb to be able to modify from m_Response_2XXonINVITE_privacy_UE
+ template(value) Response m_Response_2XXonINVITE_supported_privacy_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) Privacy p_privacy,
+ template(value) Supported p_supported
+ ) modifies m_Response_2XXonINVITE_privacy_UE := {
+ msgHeader := {
+ supported := p_supported
+ }
+ }
+
+ template(value) Response m_Response_2xxonINVITE_UserToUser(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb,
+ template(value) UserToUser.uuiData p_U2UData
+ ) modifies m_Response_2xxonINVITE := {
+ msgHeader := {
+ userToUser := m_UserToUserData(p_U2UData)
+ }
+ }
+
+ template(value) Response m_Response_2xxonREGISTER_IMS(
+ template(value) StatusLine_2xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) SipUrl p_serviceroute_sip_url,
+ template(value) SipUrl p_passociated_uri
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ contact := p_contact,
+ serviceRoute := {
+ fieldName := SERVICE_ROUTE_E,
+ routeBody := {
+ {
+ nameAddr := {
+ displayName := omit,
+ addrSpec := p_serviceroute_sip_url
+ },
+ rrParam := omit
+ }
+ }
+ },
+ pAssociatedURI :=
+ m_pAssociatedURI(
+ {
+ displayName := omit,
+ addrSpec := p_passociated_uri
+ }
+ ) // PAssociatedURI RFC3455
+ }
+ }
+
+ template(value) Response m_Response_2xxonSUBSCRIBE_IMS(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ template(value) Response m_Response_2xxonSUBSCRIBE_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_2xxonSUBSCRIBE_IMS := {
+ }
+
+ template(value) Response m_Response_2xxonMESSAGE_PAccessNetwInfo_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := m_pAccessNetworkInfo_IEEE_11a
+ }
+ }
+
+ template(value) Response m_Response_2xxonMESSAGE_PCharging_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) PChargingVector p_pChargingVector
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := m_pChargingFunctionAddresses_fixedValue,
+ pChargingVector := p_pChargingVector
+ }
+ }
+
+ template(value) Response m_Response_2xxonMESSAGE_PCharging_IMS(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) PChargingVector p_pChargingVector
+ ) modifies m_Response_2xxonMESSAGE_PCharging_UE := {
+ }
+
+ template(value) Response m_Response_2xxonMESSAGE_PMediaAuth_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ pMediaAuthorization := m_pMediaAuthorization_fixedValue
+ }
+ }
+
+ template(value) Response m_Response_2xxonMESSAGE_pPreferredID_UE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) PPreferredID p_pPreferredID
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ template(value) Response m_Response_2xxonUPDATE(
+ template(value) StatusLine_2xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(omit) RecordRoute p_recordRoute := omit,
+ template(value) MessageBody p_mb
+ ) modifies m_Response_2xx_Base := {
+ msgHeader := {
+ contact := p_contact,
+ contentLength := m_contentLength(f_MessageBodyLength(p_mb)),
+ contentType := m_contentType(c_sdpApplication),
+ recordRoute := p_recordRoute
+ },
+ messageBody := p_mb
+ }
+
+ } // end group responseSend2xx
+
+ group responseSend3xx {
+
+ template(value) Response m_Response_3xx_Base(
+ template(value) StatusLine_3xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_Dummy := {
+ statusLine := p_statusLine,
+ msgHeader := {
+ callId := p_callId,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ maxForwards := omit,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := omit,
+ payload := omit
+ }
+
+ template(value) Response m_Response_3XXonINVITE(
+ template(value) StatusLine_3xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_3xx_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ } // end group responseSend3xx
+
+ group responseSend4xx {
+
+ template(value) Response m_Response_4xx_Base(
+ template(value) StatusLine_4xx p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(omit) CSeq p_cSeq := omit,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_Dummy := {
+ statusLine := p_statusLine,
+ msgHeader := {
+ callId := p_callId,
+ cSeq := p_cSeq,
+ fromField := p_from,
+ maxForwards := omit,
+ toField := p_to,
+ via := p_via
+ },
+ messageBody := omit,
+ payload := omit
+ }
+
+ template(value) Response m_Response_4XXonINVITE(
+ template(value) StatusLine_4xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_4xx_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ template(value) Response m_Response_4XXonINVITE_UE(
+ template(value) StatusLine_4xx p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_4xx_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ } // end group responseSend4xx
+
+ template(value) Response m_Response_onCANCEL(
+ template(value) StatusLine p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via
+ ) modifies m_Response_Base := {
+ }
+
+ template(value) Response m_Response_onMESSAGE_IMS(
+ template(value) StatusLine p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ template(value) Response m_Response_onINVITE(
+ template(value) StatusLine p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit
+ ) modifies m_Response_Base := {
+ msgHeader := {
+ contact := p_contact
+ }
+ }
+
+ template(value) Response m_Response_onINVITE_Reason(
+ template(value) StatusLine p_statusLine,
+ template(value) CallId p_callId,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(omit) Contact p_contact := omit,
+ template(value) GenValue p_cause
+ ) modifies m_Response_onINVITE := {
+ msgHeader := {
+ reason := mw_Reason(p_cause)
+ }
+ }
+
+ template(value) Response m_Response_WWWauthenticate_IMS(
+ template(value) StatusLine p_statusLine,
+ template(omit) CallId p_callId := omit,
+ template(value) CSeq p_cSeq,
+ template(value) From p_from,
+ template(value) To p_to,
+ template(value) Via p_via,
+ template(value) WwwAuthenticate p_wwwAuthenticate
+ ) modifies m_Response_Base := {
+ msgHeader := {
+ wwwAuthenticate := p_wwwAuthenticate
+ }
+ }
+
+ } // end group responseSend
+
+ group responseReceive {
+
+ group responseReceive2xx {
+
+ // NOTE STF471: removed statusline parameter as it is fixed 200 status code
+ template(present) Response mw_Response_200onINVITE_noPChargingVector_UE(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xx_Base := {
+ statusLine := {
+ sipVersion := c_sipNameVersion,
+ statusCode := 200,
+ reasonPhrase := ?
+ },
+ msgHeader := {
+ pChargingVector := omit
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is fixed 200 status code
+ template(present) Response mw_Response_200onINVITE_SDP_UE(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xx_Base := {
+ statusLine := {
+ sipVersion := c_sipNameVersion,
+ statusCode := 200,
+ reasonPhrase := ?
+ },
+ messageBody := {
+ sdpMessageBody := ?
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a 200.299 status code
+ template(present) Response mw_Response_2xxonMESSAGE_noPCharging_UE(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xx_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := omit,
+ pChargingVector := omit
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a 200..299 status code
+ template(present) Response mw_Response_2xxonMESSAGE_noPCharging_IMS(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xxonMESSAGE_noPCharging_UE := {
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a 200..299 status code
+ template(present) Response mw_Response_2xxonMESSAGE_noPAccessNetworkInfo_IMS(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xx_Base := {
+ msgHeader := {
+ pAccessNetworkInfo := omit
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a 200..299 status code
+ template(present) Response mw_Response_2xxonMESSAGE_noPMediaAuthorization_IMS(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_2xx_Base := {
+ msgHeader := {
+ pMediaAuthorization := omit
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a fixed 200 status code
+ template(present) Response mw_Response_200onREGISTER_IMS(
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template SipUrl p_ue_uri,
+ template Contact p_contact,
+ template SipUrl p_sut_scscf_uri
+ ) modifies mw_Response_2xx_Base := {
+ statusLine := {
+ sipVersion := c_sipNameVersion,
+ statusCode := 200,
+ reasonPhrase := ?
+ },
+ msgHeader := {
+ pAssociatedURI := {
+ fieldName := P_ASSOCIATED_URI_E,
+ nameAddrList := {
+ *,
+ {
+ nameAddr := {
+ displayName := *,
+ addrSpec := p_ue_uri
+ },
+ genericParams := *
+ },
+ *
+ }
+ },
+ path := ?,
+ serviceRoute := {
+ fieldName := SERVICE_ROUTE_E,
+ routeBody := {
+ {
+ nameAddr := {
+ displayName := *,
+ addrSpec := p_sut_scscf_uri
+ },
+ rrParam := *
+ }
+ }
+ },
+ pChargingFunctionAddresses := ?,
+ pChargingVector := ?,
+ contact := p_contact
+ }
+ }
+
+ } // end group responseReceive2xx
+
+ group responseReceive4xx {
+
+ // NOTE STF471: removed statusline parameter as it is a fixed 401 status code
+ template(present) Response mw_Response_401onREGISTER_securityServer_UE(
+ template CallId p_callId,
+ template CSeq p_cSeq
+ ) modifies mw_Response_4xx_Base := {
+ statusLine := {
+ sipVersion := c_sipNameVersion,
+ statusCode := 401,
+ reasonPhrase := ?
+ },
+ msgHeader := {
+ securityServer := ?,
+ wwwAuthenticate := ?
+ }
+ }
+
+ // NOTE STF471: removed statusline parameter as it is a fixed 400 status code
+ template(present) Response mw_Response_401onREGISTER_WWWauthenticate_IMS(
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) WwwAuthenticate p_wwwAuthenticate := ?
+ ) modifies mw_Response_4xx_Base := {
+ statusLine := {
+ sipVersion := c_sipNameVersion,
+ statusCode := 401,
+ reasonPhrase := ?
+ },
+ msgHeader := {
+ wwwAuthenticate := p_wwwAuthenticate
+ }
+ }
+
+ } // end group responseReceive4xx
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_SecServer_WWWAuth_UE(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) SecurityServer p_securityServer := ?,
+ template WwwAuthenticate p_wwwAuthenticate
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ securityServer := p_securityServer,
+ wwwAuthenticate := p_wwwAuthenticate
+ }
+ }
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PpreferredID_PassertedID(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PPreferredID p_pPreferredID := ?,
+ template(present) PAssertedID p_pAssertedID := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ pPreferredID := p_pPreferredID
+ }
+ }
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PAsserted_Privacy_History(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PAssertedID p_pAssertedID := ?,
+ template(present) Privacy p_privacy := ?,
+ template(present) HistoryInfo p_historyInfo := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ privacy := p_privacy,
+ historyInfo := p_historyInfo
+ }
+ }
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PAsserted_ContentType(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PAssertedID p_pAssertedID := ?,
+ template(present) ContentType p_contentType := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pAssertedID := p_pAssertedID,
+ contentType := p_contentType
+ }
+ }
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PchargingVector(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PChargingVector p_chargingVector := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pChargingVector := p_chargingVector
+ }
+ }
+
+ // NOTE STF471: changed name from mw_Response_PchargingVecFctadrId
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PchargingVector_PchargingFunctionAddr_PpreferredID(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PChargingVector p_chargingVector := ?,
+ template(present) PChargingFunctionAddresses p_chargingFunctionAddresses := ?,
+ template(present) PPreferredID p_preferredID := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pChargingVector := p_chargingVector,
+ pChargingFunctionAddresses := p_chargingFunctionAddresses,
+ pPreferredID := p_preferredID
+ }
+ }
+
+ // NOTE STF471: changed statusline parameter to statusCode parameter
+ template(present) Response mw_Response_PchargingFunctionAddr(
+ template(present) StatusLine.statusCode p_statusCode := ?,
+ template CallId p_callId,
+ template CSeq p_cSeq,
+ template(present) PChargingFunctionAddresses p_chargingFunctionAddresses := ?
+ ) modifies mw_Response_StatusCode_Base := {
+ msgHeader := {
+ pChargingFunctionAddresses := p_chargingFunctionAddresses
+ }
+ }
+
+ } // end group responseReceive
+
+ } // end group modifiedTemplates
+
+ } // end group messageTemplates
+
+} // end module LibIms_Templates
\ No newline at end of file
/tags/v3.0.0/ttcn/LibIms_Templates.ttcn
Property changes:
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: tags/v3.0.0/ttcn/LibIms_Library.ttcn
===================================================================
--- tags/v3.0.0/ttcn/LibIms_Library.ttcn (nonexistent)
+++ tags/v3.0.0/ttcn/LibIms_Library.ttcn (revision 208)
@@ -0,0 +1,16 @@
+/**
+ * @author STF471
+ * @version $Id: LibSip_Steps.ttcn 614 2014-07-07 10:01:14Z tepelmann $
+ * @desc This module provides all modules of the LibIms as public imports.
+ * Importing this module will automatically import all here listed modules,
+ * no other LibIms_xxx module import needed in this case.
+ * This module is part of LibImsV3.
+ */
+module LibIms_Library {
+
+ import from LibIms_Interface all;
+ import from LibIms_SIPTypesAndValues all;
+ import from LibIms_Steps all;
+ import from LibIms_Templates all;
+
+}
\ No newline at end of file
Index: tags/v3.0.0/ttcn/LibIms_SIPTypesAndValues.ttcn
===================================================================
--- tags/v3.0.0/ttcn/LibIms_SIPTypesAndValues.ttcn (nonexistent)
+++ tags/v3.0.0/ttcn/LibIms_SIPTypesAndValues.ttcn (revision 208)
@@ -0,0 +1,65 @@
+/**
+ * @author STF 346, STF366, STF368, STF369, STF450, STF471
+ * @version $Id$
+ * @desc This module provides the types and constants used by the test component for SIP tests. This module is part of LibImsV3.
+ */
+module LibIms_SIPTypesAndValues {
+
+ group otherTypes {
+
+ /**
+ * @desc StatusLine with status code restricted to 18x
+ * @remark Used TTCN-3 internally
+ */
+ type record StatusLine_18x {
+ charstring sipVersion,
+ integer statusCode (180 .. 189) ,
+ charstring reasonPhrase
+ }
+
+ /**
+ * @desc StatusLine with status code restricted to 2xx
+ * @remark Used TTCN-3 internally
+ */
+ type record StatusLine_2xx {
+ charstring sipVersion,
+ integer statusCode (200 .. 299) ,
+ charstring reasonPhrase
+ }
+
+ /**
+ * @desc StatusLine with status code restricted to 3xx
+ * @remark Used TTCN-3 internally
+ */
+ type record StatusLine_3xx {
+ charstring sipVersion,
+ integer statusCode (300 .. 399) ,
+ charstring reasonPhrase
+ }
+
+ /**
+ * @desc StatusLine with status code restricted to 4xx
+ * @remark Used TTCN-3 internally
+ */
+ type record StatusLine_4xx {
+ charstring sipVersion,
+ integer statusCode (400 .. 499) ,
+ charstring reasonPhrase
+ }
+
+ type record ImsInterfaceProfile {
+ /**
+ * @desc integer for Port number to exchange SIP messages
+ */
+ integer SUTPort,
+ /**
+ * @desc charstring for IP address to exchange SIP messages
+ */
+ charstring SUTIpaddr,
+ /**
+ * @desc charstring for home domain to exchange SIP messages
+ */
+ charstring SUTHomeDomain
+ }
+ }
+} // end module LibIms_SIPTypesAndValues
/tags/v3.0.0/ttcn/LibIms_SIPTypesAndValues.ttcn
Property changes:
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property