LibIms_Steps.ttcn 79.5 KB
Newer Older
 *	@author 	STF 346, STF366, STF368, STF369, STF450
 *  @version    $Id$
 *	@desc		This module provides the types used by the test component 
 *              for SIP-IMS tests.
 *              This module is part of LibImsV2.
 */

module LibIms_Steps
{	
	//LibSip
	import from LibSip_SIPTypesAndValues all;
	import from LibSip_SDPTypes all;
	import from LibSip_Templates all;
	import from LibSip_Steps all;
	import from LibSip_PIXITS all;
	import from LibSip_Interface all;
	import from LibSip_XMLTypes all;
    import from LibSip_MessageBodyTypes all;
	//LibIms
	import from LibIms_Templates all;
	import from LibIms_Interface all;
	import from LibIms_PIXITS all;	
	import from LibIms_SIPTypesAndValues all;
		
	group externalfunctions {
	}//end group externalfunctions
	group parameterOperations {

        /**
         * 
         * @desc functions add new via parameter
         * @param p_message (request) SIP message to be used to prepair via header
         * @param p_userprofile user profile
         */
        function f_addNewViaParameter(in Request p_message, in integer p_userprofile) runs on ImsComponent
        {
          var integer v_intVia;
          var integer i := 0;
          if (ispresent(p_message.msgHeader.via)) {          

            v_intVia := sizeof(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 functions remove own via parameter
        * @param p_message (request) SIP message to be used to prepair via header
        * @param p_userprofile user profile
        */
       function f_removeOwnViaParameter(in Response p_message) runs on ImsComponent
       {
         var integer v_intVia;
         var Via v_via := c_empty_Via;
         
         if (ispresent(p_message.msgHeader.via)) {          

           v_intVia := sizeof(p_message.msgHeader.via.viaBody)-1;
           
           for (var integer i := 0; i < v_intVia; i := i + 1)
           {
               v_via.viaBody[i] := p_message.msgHeader.via.viaBody[i+1]; 
           }
           vc_via := v_via;
         }
       }
        
        /**
        * 
        * @desc functions add new via parameter
        * @param p_message (request) SIP message to be used to prepair via header
        * @param p_userprofile user profile
        */
       function f_addNewRecordRouteAndRemoveRoutParameter(in Request p_message) runs on ImsComponent
       {
         var integer v_intRoute,v_intRecordRoute;
         var integer i := 1;
         var integer j := 0;
         var RouteBody v_route1; 
         var Route v_newRoute;
         v_newRoute.fieldName := ROUTE_E;
         if (ispresent(p_message.msgHeader.route)) {          

           v_intRoute := sizeof(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 (ispresent(p_message.msgHeader.recordRoute)) {          

           v_intRecordRoute := sizeof(p_message.msgHeader.recordRoute.routeBody);
           while (j < 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 := p_message.msgHeader.recordRoute;
         }
       }

       /**
       * 
       * @desc functions add new recordRoute parameter
       * @param p_message (request) SIP message to be used to prepair via header
       * @param p_userprofile user profile
       */
      function f_addNewRecordRouteIMS(in RecordRoute p_rr) runs on ImsComponent return template RecordRoute
      {
        template RecordRoute v_recordRoute := omit;
        var integer v_intRecordRoute;
        var integer i := 1;
        var integer j := 0;

        v_intRecordRoute := sizeof(p_rr.routeBody);
         if (v_intRecordRoute>0){
          while (j < 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
	
	 * @desc sets BYE header fields (IMS addresses)
	 *			extension of general settings from LibSip basic function
	 * @param p_cSeq_s current cSeq 
	 * @param p_to_user user_profile id of the user to send Bye
	 * @verdict 
	 */
		function f_setHeadersBYE(inout CSeq p_cSeq_s, in integer p_to_user) runs on ImsComponent
		{      
//		  vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
//		  
//		  vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
        
		  vc_requestUri := f_initSipUrl(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 current cSeq 
	 * @param p_to_user user_profile id of the user to send Cancel
	 * @verdict 
	 */
		function f_setHeadersCANCEL(inout CSeq p_cSeq_s, in integer p_to_user) 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_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, c_userProfile_AS1);
                f_addNewRecordRouteAndRemoveRoutParameter(v_request);
    		}
    		else
			{	//B2Bmode
    			vc_contact := valueof(m_Contact(m_SipUrl_contactIpaddr(vc_userprofile)));
                vc_callId := { fieldName:=CALL_ID_E, callid:=f_getRndCallId(p_cSeq_s) & 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 (inout CSeq p_cSeq_s) 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 current cSeq 
		 * @param p_to_user user_profile id of the user to be invited
		 * @verdict 
		 */
		function f_setHeadersINVITE(inout CSeq p_cSeq_s, in integer p_to_user) runs on ImsComponent
		{      
rennoch's avatar
rennoch committed
		  vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
rennoch's avatar
rennoch committed
		  vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
            
		  vc_requestUri := f_initSipUrl(p_to_user); // Request URI of Invite is identical with To header
		  if (vc_boo_route)
		  { vc_route := valueof(m_route_interface(vc_interfaceprofile))};
		  if (vc_boo_recordRoute)
		  { vc_recordRoute := valueof(m_recordRoute_currIpAddr(vc_userprofile))};
		  LibSip_Steps.f_setHeadersINVITE(p_cSeq_s);
		}// end f_setHeadersINVITE
poglitsch's avatar
poglitsch committed

		/*
		* 
		* @desc sets Invite header fields (IMS addresses)
		*			extension of general settings from LibSip basic function
		* @param p_cSeq_s current cSeq 
		* @param p_to_user user_profile id of the user to be invited
		* @verdict 
		*/
		function f_setHeadersUPDATE(inout CSeq p_cSeq_s, in integer p_to_user) runs on ImsComponent
		{      
			vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier

			vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
        
			vc_requestUri := f_initSipUrl(p_to_user); // Request URI of Invite is identical with To header
  
			if (vc_boo_route)
			{ vc_route := valueof(m_route_interface(vc_interfaceprofile))};
			if (vc_boo_recordRoute)
			{ vc_recordRoute := valueof(m_recordRoute_currIpAddr(vc_userprofile))};
	  
			LibSip_Steps.f_setHeadersUPDATE(p_cSeq_s);
		  
		}// end f_setHeadersUPDATE
rennoch's avatar
rennoch committed
    	
		 * @desc sets Message header fields (IMS addresses)
		 *			extension of general settings from LibSip basic function
		 * @param p_cSeq_s current cSeq 
		 * @param p_to_user user_profile id of the user to be invited
		 * @verdict 
		 */
		function f_setHeadersMESSAGE(inout CSeq p_cSeq_s, in integer p_to_user) runs on ImsComponent
		{      
rennoch's avatar
rennoch committed
		  vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
rennoch's avatar
rennoch committed
		  vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
        
		  vc_requestUri := f_initSipUrl(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)
rennoch's avatar
rennoch committed
		*			extension of general settings from LibSip basic function
		* @param p_cSeq_s current cSeq 
		* @param p_to_user user_profile id of the user to be invited
		* @verdict 
		*/
		function f_setHeadersNOTIFY(inout CSeq p_cSeq_s, in integer 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))}
				};
				
rennoch's avatar
rennoch committed
				vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier

				vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
        
				vc_requestUri := f_initSipUrl(p_to_user); // Request URI of Invite is identical with To header
				
				//contact header initialization for sending of NOTIFY from CSCF component
				vc_contact := valueof(m_Contact(m_SipUrl_currIpaddr_CSCF(vc_userprofile)));
rennoch's avatar
rennoch committed
	  
		}// end f_setHeadersNOTIFY

		/*
		* 
		* @desc sets Publish header fields (IMS addresses)
		*			extension of general settings from LibSip basic function
		* @param p_cSeq_s current cSeq 
		* @param p_to_user user_profile id of the user to be invited
		* @verdict 
		*/
		function f_setHeadersPUBLISH(inout CSeq p_cSeq_s, in integer 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(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier

				vc_requestUri := f_initSipUrl(p_to_user); // Request URI of Invite is identical with To header
		
				if (vc_boo_route)
				{ vc_route := valueof(m_route_interface(vc_interfaceprofile))};
				if (vc_boo_recordRoute)
				{ vc_recordRoute := valueof(m_recordRoute_currIpAddr(vc_userprofile))};
				
				//contact header initialization for sending of PUBLISH from CSCF component
				vc_contact := valueof(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 current cSeq 
		* @param p_to_user user_profile id of the user to be invited
		* @verdict 
		*/
		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(vc_userprofile.id, 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
		
poglitsch's avatar
poglitsch committed
		 * @desc  sets headers for ReINVITE method 
		 * @param p_cSeq_s current cSeq 
poglitsch's avatar
poglitsch committed
		 * @param p_orginatingSide true in case of Re-INVITE is send from the orgination endpoint otherwise false. 
		function f_setHeadersReINVITE (inout CSeq p_cSeq_s, in boolean p_orginatingSide, in integer p_to_user) runs on ImsComponent
		  var integer v_tmp, v_i, v_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 := f_initSipUrl(p_to_user);
          
poglitsch's avatar
poglitsch committed
		  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 (ispresent(v_request.msgHeader.recordRoute))
              {
                vc_recordRoute := v_request.msgHeader.recordRoute;
                v_nbroute := sizeof(vc_recordRoute.routeBody);
                // copy and reverse the order of the routes in route header
                for (v_i:=0; v_i<=(v_nbroute - 1); v_i:=v_i+1)
                {
                  v_j:= v_nbroute - 1 - v_i;
                  vc_route.routeBody[v_j]:=vc_recordRoute.routeBody[v_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 CSeq parameter
	 * @param p_method method name for cSeq header field
	 */	
 	function f_setHeadersGeneral_ICSCF(inout CSeq p_cSeq_s, in charstring p_method) runs on SipComponent
	{
	  var SemicolonParam_List v_params;

	  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 := valueof(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 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(p_cSeq_s) & 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:=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:=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 current cSeq 
		 * @param p_to_user user_profile id of the user to be invited
		 * @verdict 
		 */
		function f_setHeadersREFER(inout CSeq p_cSeq_s, in integer p_to_user) runs on ImsComponent
		{      
juvancic's avatar
juvancic committed
		  //vc_to := f_initToHeader(p_to_user); // init of vc_to using userProfile identifier
juvancic's avatar
juvancic committed
		  //vc_from := f_initFromHeader(vc_userprofile.id, f_getRndTag()); // init of vc_from using userProfile identifier
            
		  vc_requestUri := f_initSipUrl(p_to_user); // Request URI of Invite is identical with To header
      
		  if (vc_boo_route)
		  { vc_route := valueof(m_route_interface(vc_interfaceprofile))};
		  if (vc_boo_recordRoute)
		  { vc_recordRoute := valueof(m_recordRoute_currIpAddr(vc_userprofile))};
		  
		  LibSip_Steps.f_setHeadersREFER(p_cSeq_s);
		  
		}// end f_setHeadersREFER
	     * @desc sets REFER header fields (IMS addresses)
poglitsch's avatar
poglitsch committed
		 *			extension of general settings from LibSip basic function
		 * @param p_cSeq_s current cSeq 
		 * @param p_uri 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(vc_userprofile.id, 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 := valueof(m_route_interface(vc_interfaceprofile))
		  };
		  if (vc_boo_recordRoute) { 
		  	vc_recordRoute := valueof(m_recordRoute_currIpAddr(vc_userprofile))
		  };
		  
		  LibSip_Steps.f_setHeadersREFER(p_cSeq_s);
		}// end f_setHeadersREFER_conf

	} // end group fieldOperations
	
	group awaitingMessage {
	}
	group sendMessage {
	/**
	* 
	* @desc  send PRACK message
	* @param p_request template of the message to be sent
	*/
	function f_SendPRACK_sdp(template MessageBody p_mb) runs on SipComponent
	{
		f_setHeadersGeneral(vc_cSeq, "PRACK"); // cseq, contact, branch, via	
		vc_rAck := valueof(m_RAck(vc_response.msgHeader.rSeq.responseNum, vc_cSeq.seqNumber, vc_cSeq.method));
		
		SIPP.send(m_PRACK_Request_sdp(
            vc_requestUri, 
            vc_callId, 
            vc_cSeq, 
            vc_from, 
            vc_to, 
            vc_via,
            vc_rAck,
            p_mb
    	)) to vc_sent_label;	  
	}

		 * 
		 * @desc sets user parameters with PIXIT values
		 * @param p_user identifies the selected user configuration and location
		 * @verdict 
		 */
		function f_init_userprofile(in integer p_user) runs on ImsComponent
		{
		LibSip_Steps.f_init_userprofile(p_user);
		
		select(p_user){
			case (c_userProfile_UE1atSUThome) { //variant c_userProfile_UE1atSUThome
			vc_userprofile.currPort := PX_IMS_TS_UE1_PORT;
			vc_userprofile.currIpaddr := PX_IMS_TS_UE1_IPADDR;	
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	
			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;	
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR;
			}
			case (c_userProfile_UE2atSUThome) { //variant c_userProfile_UE2atSUThome
			vc_userprofile.currPort := PX_IMS_TS_UE2_PORT;
			vc_userprofile.currIpaddr := PX_IMS_TS_UE2_IPADDR;	
			vc_userprofile.contactPort := PX_IMS_TS_UE2_PORT;
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE2_IPADDR;
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE2_BEARER_IPADDR;
			vc_userprofile.homeDomain := PX_IMS_SUT_UE2_HOME_DOMAIN;	
			vc_userprofile.publUsername := PX_IMS_SUT_UE2_PUBLIC_USER;
			vc_userprofile.qop := PX_IMS_SUT_UE2_QOP;
			vc_userprofile.privUsername := PX_IMS_SUT_UE2_PRIVAT_USERNAME;	
			vc_userprofile.passwd := PX_IMS_SUT_UE2_PRIVAT_PASSWD;	
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE2_REGISTRAR;
			}

			case (c_userProfile_UE3atSUThome) { //variant c_userProfile_UE3atSUThome
			vc_userprofile.currPort := PX_IMS_TS_UE3_PORT;
			vc_userprofile.currIpaddr := PX_IMS_TS_UE3_IPADDR;	
			vc_userprofile.contactPort := PX_IMS_TS_UE3_PORT;
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE3_IPADDR;
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE3_BEARER_IPADDR;
			vc_userprofile.homeDomain := PX_IMS_SUT_UE3_HOME_DOMAIN;	
			vc_userprofile.publUsername := PX_IMS_SUT_UE3_PUBLIC_USER;
			vc_userprofile.qop := PX_IMS_SUT_UE3_QOP;
			vc_userprofile.privUsername := PX_IMS_SUT_UE3_PRIVAT_USERNAME;	
			vc_userprofile.passwd := PX_IMS_SUT_UE3_PRIVAT_PASSWD;	
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE3_REGISTRAR;
			}

			case (c_userProfile_UE4atSUThome) { //variant c_userProfile_UE4atSUThome
			vc_userprofile.currPort := PX_IMS_TS_UE4_PORT;
			vc_userprofile.currIpaddr := PX_IMS_TS_UE4_IPADDR;	
			vc_userprofile.contactPort := PX_IMS_TS_UE4_PORT;
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE4_IPADDR;
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE4_BEARER_IPADDR;
			vc_userprofile.homeDomain := PX_IMS_SUT_UE4_HOME_DOMAIN;	
			vc_userprofile.publUsername := PX_IMS_SUT_UE4_PUBLIC_USER;
			vc_userprofile.qop := PX_IMS_SUT_UE4_QOP;
			vc_userprofile.privUsername := PX_IMS_SUT_UE4_PRIVAT_USERNAME;	
			vc_userprofile.passwd := PX_IMS_SUT_UE4_PRIVAT_PASSWD;	
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE4_REGISTRAR;
			}
			
			case (c_userProfile_UE1atSUTvisiting) { //variant c_userProfile_UE1atSUTvisiting - UE3 parameters
			vc_userprofile.currPort := PX_IMS_TS_UE1_PORT;
			vc_userprofile.currIpaddr := PX_IMS_TS_UE1_IPADDR;
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE3_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE3_HOME_DOMAIN;	
			vc_userprofile.publUsername := PX_IMS_SUT_UE3_PUBLIC_USER;
			vc_userprofile.qop := PX_IMS_SUT_UE3_QOP;
			vc_userprofile.privUsername := PX_IMS_SUT_UE3_PRIVAT_USERNAME;	
			vc_userprofile.passwd := PX_IMS_SUT_UE3_PRIVAT_PASSWD;	
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE3_REGISTRAR;
//			//temporary not used and it can be deleted during validation
//			case (c_userProfile_UE1atSUTvisiting) { //variant c_userProfile_UE1atSUTvisiting
//			vc_userprofile.currPort := PX_IMS_TS_UE2_PORT;
//			vc_userprofile.currIpaddr := PX_IMS_TS_UE2_IPADDR;
//			vc_userprofile.contactPort := PX_IMS_TS_UE2_PORT;
//			vc_userprofile.contactIpaddr := PX_IMS_TS_UE2_IPADDR;
//			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE2_BEARER_IPADDR;	
//			vc_userprofile.homeDomain := PX_IMS_SUT_UE2_HOME_DOMAIN;	
//			vc_userprofile.publUsername := PX_IMS_SUT_UE2_PUBLIC_USER;
//			vc_userprofile.qop := PX_IMS_SUT_UE2_QOP;
//			vc_userprofile.privUsername := PX_IMS_SUT_UE2_PRIVAT_USERNAME;	
//			vc_userprofile.passwd := PX_IMS_SUT_UE2_PRIVAT_PASSWD;	
//			vc_userprofile.registrarDomain := PX_IMS_TS_UE2_REGISTRAR;
//			}

			case (c_userProfile_IBCFwithHomeUE)			 { 				//variant c_userProfile_IBCFwithHomeUE
			vc_userprofile.currPort := PX_IMS_TS_IBCF_PORT;				// via (Ic interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_IBCF_IPADDR;			// via
			vc_userprofile.contactPort := PX_IMS_TS_IBCF_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_IBCF_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;		// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;				// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}	

			case (c_userProfile_IBCFwithVisitingUE) { 					//variant c_userProfile_IBCFwithVisitingUE
			vc_userprofile.currPort := PX_IMS_TS_IBCF_PORT;				// via (Ic interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_IBCF_IPADDR;			// via
			vc_userprofile.contactPort := PX_IMS_TS_IBCF_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_IBCF_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;		// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;				// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}
			
			case (c_userProfile_ICSCFwithHomeUE) { 						//variant c_userProfile_ICSCFwithHomeUE - UE4 parameters
			vc_userprofile.currPort := PX_IMS_TS_ICSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_ICSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE4_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE4_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE4_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE4_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE4_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE4_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE4_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE4_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE4_REGISTRAR; 	// Authorization
			}
	
			case (c_userProfile_IBCFwithUnknownUE) { 					//variant 
			vc_userprofile.currPort := PX_IMS_TS_ICSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_ICSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_unknownUE_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}

			case (c_userProfile_PCSCFwithHomeUE) { 						//variant c_userProfile_PCSCFwithHomeUE
			vc_userprofile.currPort := PX_IMS_TS_PCSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_PCSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}
	
			case (c_userProfile_PCSCFwithVisitingUE) { 					//variant c_userProfile_PCSCFwithVisitingUE
			vc_userprofile.currPort := PX_IMS_TS_PCSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_PCSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_REGISTRAR;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}

			// another visting user in IMS (cp. TP_IMST2_MW_REG_15: different public id, same private id)
			case (c_userProfile_PCSCFwithVisitingUE2) { 				//variant
			vc_userprofile.currPort := PX_IMS_TS_PCSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_PCSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE2_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE2_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE2_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE2_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}

			// unknown visting user in IMS (cp. TP_IMST2_MW_REG_16)
			case (c_userProfile_PCSCFwithUnknownVisitingUE) { 			//variant
			vc_userprofile.currPort := PX_IMS_TS_PCSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_PCSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE2_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_unknownUE_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}

			case (c_userProfile_SCSCFwithHomeUE) { 						//variant c_userProfile_SCSCFwithHomeUE  - UE4 parameters
			vc_userprofile.currPort := PX_IMS_TS_SCSCF_PORT;			// via (Mw interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_SCSCF_IPADDR;		// via
			vc_userprofile.contactPort := PX_IMS_TS_UE4_PORT;			// contact (simulated UE)
			vc_userprofile.contactIpaddr := PX_IMS_TS_UE4_IPADDR;		// contact
			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE4_BEARER_IPADDR;	
			vc_userprofile.homeDomain := PX_IMS_SUT_UE4_HOME_DOMAIN;	// From, To (register)
			vc_userprofile.publUsername := PX_IMS_SUT_UE4_PUBLIC_USER;	// From, To (register)
			vc_userprofile.qop := PX_IMS_SUT_UE4_QOP;					// Authorization
			vc_userprofile.privUsername := PX_IMS_SUT_UE4_PRIVAT_USERNAME;	// Authorization
			vc_userprofile.passwd := PX_IMS_SUT_UE4_PRIVAT_PASSWD;			// Authorization
			vc_userprofile.registrarDomain := PX_IMS_SUT_UE4_REGISTRAR; 	// Authorization

            case (c_userProfile_SCSCFwithHomeUE_domain) { 						//variant c_userProfile_SCSCFwithHomeUE  - UE4 parameters
            vc_userprofile.currPort := PX_IMS_TS_SCSCF_PORT;			// via (Mw interface of TS)
            vc_userprofile.currIpaddr := PX_IMS_TS_SCSCF_IPADDR;		// via
            vc_userprofile.contactPort := PX_IMS_TS_UE4_PORT;			// contact (simulated UE)
            vc_userprofile.contactIpaddr := PX_IMS_TS_UE4_IPADDR;		// contact
            vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE4_BEARER_IPADDR;	
            vc_userprofile.homeDomain := PX_IMS_SUT_UE4_HOME_DOMAIN;	// From, To (register)
            vc_userprofile.publUsername := PX_IMS_SUT_UE4_PUBLIC_USER;	// From, To (register)
            vc_userprofile.qop := PX_IMS_SUT_UE4_QOP;					// Authorization
            vc_userprofile.privUsername := PX_IMS_SUT_UE4_PRIVAT_USERNAME;	// Authorization
            vc_userprofile.passwd := PX_IMS_SUT_UE4_PRIVAT_PASSWD;			// Authorization
            vc_userprofile.registrarDomain := PX_IMS_SUT_UE4_REGISTRAR; 	// Authorization
            }
            case (c_userProfile_AS1)  { 								//variant c_userProfile_AS1
            vc_userprofile.currPort := PX_IMS_TS_AS1_PORT;				// via, route(Isc interface of TS)
            vc_userprofile.currIpaddr := PX_IMS_TS_AS1_IPADDR;			// via, route
            vc_userprofile.contactPort := PX_IMS_TS_AS1_PORT;			// contact (simulated UE)
            vc_userprofile.contactIpaddr := PX_IMS_TS_AS1_IPADDR;		// contact
            vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;
            vc_userprofile.homeDomain := PX_IMS_TS_AS1_HOME_DOMAIN;		// via, routevc_userprofile.publUsername := PX_IMS_SUT_UE4_PUBLIC_USER;	// From, To (register)
            vc_userprofile.publUsername := "as1";
            vc_userprofile.qop := "";					// Authorization
            vc_userprofile.privUsername := "";	// Authorization
            vc_userprofile.passwd := "";			// Authorization
            vc_userprofile.registrarDomain := ""; 	// Authorization
			
            }
			
			case (c_userProfile_AS2)  { 								//variant c_userProfile_AS2
			vc_userprofile.currPort := PX_IMS_TS_AS2_PORT;				// via, route(Isc interface of TS)
			vc_userprofile.currIpaddr := PX_IMS_TS_AS2_IPADDR;			// via, route
			vc_userprofile.homeDomain := PX_IMS_TS_AS2_HOME_DOMAIN;		// via, route
			}
			case (c_userProfile_ECSCFwithHomeUE) { 						//variant c_userProfile_PCSCFwithHomeUE
    			vc_userprofile.currPort := PX_IMS_TS_ECSCF_PORT;			// via (Mw interface of TS)
    			vc_userprofile.currIpaddr := PX_IMS_TS_ECSCF_IPADDR;		// via
    			vc_userprofile.contactPort := PX_IMS_TS_UE1_PORT;			// contact (simulated UE)
    			vc_userprofile.contactIpaddr := PX_IMS_TS_UE1_IPADDR;		// contact
    			vc_userprofile.bearerIpaddr := PX_IMS_SUT_UE1_BEARER_IPADDR;	
    			vc_userprofile.homeDomain := PX_IMS_SUT_UE1_HOME_DOMAIN;	// From, To (register)
    			vc_userprofile.publUsername := PX_IMS_SUT_UE1_PUBLIC_USER;	// From, To (register)
    			vc_userprofile.qop := PX_IMS_SUT_UE1_QOP;					// Authorization
    			vc_userprofile.privUsername := PX_IMS_SUT_UE1_PRIVAT_USERNAME;	// Authorization
    			vc_userprofile.passwd := PX_IMS_SUT_UE1_PRIVAT_PASSWD;			// Authorization
    			vc_userprofile.registrarDomain := PX_IMS_SUT_UE1_REGISTRAR; 	// Authorization
			}
			
			}
		}

		function f_initToHeader(in integer p_user) runs on ImsComponent return To
		{
			var To p_to := c_empty_To;
			p_to := {	fieldName := TO_E,
						addressField :=
						{nameAddr := {
							displayName := omit, 	 			// optional charstring
							addrSpec :=	f_initSipUrl(p_user)	// SipUrl
						  }},//end addressField
						toParams := omit
					  };
rennoch's avatar
rennoch committed
			return(p_to);
		}


		function f_initFromHeader(in integer p_user, charstring p_tag_str) runs on ImsComponent return From
		{
			var From p_from := c_empty_From;
			p_from := {	fieldName := FROM_E,
						addressField :=
						{nameAddr := {
							displayName := omit, 	 			// optional charstring
							addrSpec :=	f_initSipUrl(p_user)	// SipUrl
						  }},//end addressField
						fromParams := {{id := c_tagId, paramValue := p_tag_str}}
					  };
			return(p_from)
		}

		function f_initSipUrl(in integer p_user) runs on ImsComponent return SipUrl
		{
			var SipUrl v_sipUrl := {	  
				scheme := c_sipScheme,  			// contains "sip"
                components := { sip:= {
                        				userInfo := omit,
                        				hostPort := {omit,omit}}},
				urlParameters := omit,
				headers := omit};
				
			var SipUrl v_urnUrl := {	  
				scheme := c_urnScheme,  			// contains "urn"
                components := { urn:= {
                        				namespaceId := "service",
                    					namespaceSpecificString := "sos"}},
				urlParameters := omit,
				headers := omit};
				
			select(p_user){
				case (c_userProfile_UE1atSUThome) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE1_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_SUT_UE1_HOME_DOMAIN, portField :=omit}
						}
				case (c_userProfile_UE2atSUThome) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE2_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_SUT_UE2_HOME_DOMAIN, portField :=omit}
				case (c_userProfile_UE3atSUThome) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE3_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_SUT_UE3_HOME_DOMAIN, portField :=omit}
				case (c_userProfile_UE4atSUThome) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE4_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_SUT_UE4_HOME_DOMAIN, portField :=omit}
				case (c_userProfile_IBCFwithHomeUE) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_IMS1UE_HOME_DOMAIN, portField :=omit}
						}
				case (c_userProfile_ICSCFwithHomeUE) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_IMS1UE_HOME_DOMAIN, portField :=omit}
				}
				case (c_userProfile_PCSCFwithHomeUE) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_PCSCF_IPADDR, portField :=omit}
                case (c_userProfile_PCSCFwithVisitingUE) {
                        v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
                        v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_PCSCF_IPADDR, portField :=omit}
                }
				case (c_userProfile_SCSCFwithHomeUE) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE4_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_SCSCF_HOME_DOMAIN, portField :=PX_IMS_TS_SCSCF_PORT}
				}
				case (c_userProfile_SCSCFwithHomeUE_domain) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_SUT_UE4_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_SCSCF_HOME_DOMAIN, portField :=omit}
pintar's avatar
pintar committed
                case (c_userProfile_AS1) {
                        v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
                        v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_AS1_IPADDR, portField :=omit}
pintar's avatar
pintar committed
                }                
				case (c_userProfile_ECSCFwithHomeUE) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_IMS1UE_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_ECSCF_IPADDR, portField :=omit}
				case (c_userProfile_ISUP) {
						v_sipUrl.components.sip.userInfo := {userOrTelephoneSubscriber:=PX_IMS_TS_ISUP_PUBLIC_USER, password:=omit};
						v_sipUrl.components.sip.hostPort := {host := PX_IMS_TS_ISUP_HOME_DOMAIN, portField :=omit}
				}
				case (c_serviceProfile_EMERGENCY) {
                   		v_urnUrl.components.urn.namespaceId := PX_IMS_SUT_EMERGENCY_SERVICE_namespaceId;
                    	v_urnUrl.components.urn.namespaceSpecificString := PX_IMS_SUT_EMERGENCY_SERVICE_namespaceSpecificString;
						}
				case (c_serviceProfile_EMERGENCY_INVALID) {
                        v_urnUrl.components.urn.namespaceId := PX_IMS_SUT_EMERGENCY_SERVICE_INVALID_namespaceId;
                        v_urnUrl.components.urn.namespaceSpecificString := PX_IMS_SUT_EMERGENCY_SERVICE_INVALID_namespaceSpecificString;
						}
						
				// following setting is used for the assignment of the Path header field
				case (c_interfaceProfile_IMS_SUT_PCSCF1) {