LibSip_Steps.ttcn

		
		f_copy_SDP(); // copy SDP session bandwidth and media list from remote to local component variable
		
		// increment session version
		vc_sdp_local.origin.session_version := int2str(str2int(vc_sdp_local.origin.session_version)+1);
		
		// if more than one codec, select the first one
		v_mn:= sizeof(vc_sdp_local.media_list);

		if (p_medianum == 0) //specific media requested
    		{
    			p_medianum := 1; // start checking from first media
    		};
		if (p_medianum > 0) //specific media requested
    		{
    			if (not(p_medianum > v_mn)) 
    				{v_mn := p_medianum}
    		};
    		
		// handling of media list elements
		for (i :=0;  i < v_mn; i := i+1)
		{
			v_cn := 0; // initialize the number of attributes of the media list entry
		
			if (ispresent(vc_sdp_local.media_list)) //media_list is optional
			{						
//				log("vc_sdp_local.media_list[i] ",vc_sdp_local.media_list[i]);
				if (ispresent(vc_sdp_local.media_list[i].attributes))
				{
					v_cn := sizeof(vc_sdp_local.media_list[i].attributes);
				};
				
				v_set_direction := false;
				
				//if (sizeof(vc_sdp_local.media_list[i].media_field.fmts)>1) 
				// select the first one
				for (j :=0; j<v_cn; j:=j+1)
				{ 
					if (ischosen(vc_sdp_local.media_list[i].attributes[j].recvonly)
							or ischosen(vc_sdp_local.media_list[i].attributes[j].sendonly)
							or ischosen(vc_sdp_local.media_list[i].attributes[j].inactive)
							or ischosen(vc_sdp_local.media_list[i].attributes[j].sendrecv))
						{
							v_mediaAttributes[k] := valueof(p_direction); 
							v_set_direction := true;
						}
				 		else // non-direction attributes will be copied
						{
							v_mediaAttributes[k] := vc_sdp_local.media_list[i].attributes[j];
							k := k+1;
						}
				}
				
				if (not v_set_direction) 
					{ v_mediaAttributes[k] := valueof(p_direction)};
				vc_sdp_local.media_list[i].attributes := v_mediaAttributes;
    				
				// }
			}
		}	 
		// add handling of prenegotiation, change ports if required etc.
		//if prenegotiation...
	}
	
     /** 
     *  @desc modify session and media attributes direction
     *		 
     */
     function f_SIP_modSessionDirection(template SDP_attribute p_direction) runs on SipComponent
     {
      var boolean v_set_direction;
      var integer v_mn:= 0, i:=0;
      var SDP_attribute_list v_mediaAttributes := {};
      
	  if (ispresent(vc_sdp_local.attributes))
		{ v_mn:= sizeof(vc_sdp_local.attributes);			
       
          for (i :=0;  i < v_mn; i := i+1)
          {//for every single attribute (that is not omit)    
                 if (ischosen(vc_sdp_local.attributes[i].recvonly)
                   or ischosen(vc_sdp_local.attributes[i].sendonly)
                   or ischosen(vc_sdp_local.attributes[i].inactive)
                   or ischosen(vc_sdp_local.attributes[i].sendrecv))
                 {
                  v_mediaAttributes[i] := valueof(p_direction); 
                  v_set_direction := true;
                 }
                 else // simple copy of attribute
                 {v_mediaAttributes[i] := vc_sdp_local.attributes[i]}        				 
           }
           if (not v_set_direction) // if not sent before
               { v_mediaAttributes[v_mn] := valueof(p_direction)};
           vc_sdp_local.attributes := v_mediaAttributes;       
		};    
    }
 
	/** 
	*  @desc c
	*		 
	*/


    /*
     * 
     * @desc check (from remote) and set (local) the session/media attribute lines on directions
     * @param p_direction_in incoming SDP attribute that need to be checked
     * @param p_direction_out SDP attribute that should be included in the SDP answer (to be returned to peer)
     * @return 
     * @verdict 
     */	
	function f_SIP_checksetSDPreqDirection(template SDP_attribute p_direction_in, template SDP_attribute p_direction_out) runs on SipComponent
	{	var template SDP_attribute v_direction_out := p_direction_out;
		// check incoming SDP attribute
		if (not (ispresent(vc_request.messageBody) and f_check_attribute(vc_request.messageBody.sdpMessageBody,p_direction_in))) 
			{setverdict(fail);};
		if (match(omit,p_direction_out))//not isvalue(v_direction_out))//MRO
			{v_direction_out := f_get_attribute_answer(vc_request.messageBody.sdpMessageBody, p_direction_in);}
		f_SIP_modMediaDirection(1, v_direction_out); // handling of attribute in media description
		f_SIP_modSessionDirection(v_direction_out); // handling of attribute in session		
	}

	/*
		* 
		* @desc check (from remote) and set (local)the session/media attribute lines on directions
		* @param p_direction_in attribute to be check
		* @param p_direction_out attrubyte to be 
		* @return 
		* @verdict 
		*/	
    function f_SIP_checkSDPrespDirection(template SDP_attribute p_direction_in) runs on SipComponent
    {		
    	// check incoming SDP attribute
    	if (not (ispresent(vc_response.messageBody) and f_check_attribute(vc_response.messageBody.sdpMessageBody,p_direction_in))) 
    		{setverdict(fail);};
    }

	/** 
	*  @desc check media/attribute lines from remote
	*		 
	*/
	function f_SIP_checkMediaDirection(integer p_medianum, template SDP_attribute p_direction) runs on SipComponent
	return boolean
	{
		var integer v_mn, v_cn := 0, i, j;
		var boolean v_result := false;
		//increase session version
		vc_sdp_remote.origin.session_version := int2str(str2int(vc_sdp_remote.origin.session_version)+1);
		// if more than one codec, select the firs one
		v_mn:= sizeof(vc_sdp_remote.media_list);
		if (p_medianum == 0) //specific media requested
		{
			p_medianum := 1; // start checking from first media
		};
		if (p_medianum > 0) //specific media requested
		{
			if (p_medianum > v_mn) {return false}
			else {v_mn := p_medianum}
		};
		for (i :=p_medianum-1;  i < v_mn; i := i+1)
		{
			//for every single media
			if (ispresent(vc_sdp_remote.media_list[i].attributes))
			{
				v_cn := sizeof(vc_sdp_remote.media_list[i].attributes);
				log (v_cn);
			};
			if (sizeof(vc_sdp_remote.media_list[i].attributes)>0) 
			{
				// select the first one
				log(vc_sdp_remote.media_list[i].attributes);
				for (j :=0; j<sizeof(vc_sdp_remote.media_list[i].attributes); j:=j+1)
				{
					log(vc_sdp_remote.media_list[i].attributes[j]);
					if (ischosen(vc_sdp_remote.media_list[i].attributes[j].recvonly)
							or ischosen(vc_sdp_remote.media_list[i].attributes[j].sendonly)
							or ischosen(vc_sdp_remote.media_list[i].attributes[j].inactive)
							or ischosen(vc_sdp_remote.media_list[i].attributes[j].sendrecv))
					{
						if (match(vc_sdp_remote.media_list[i].attributes[j],p_direction))
						{ v_result :=  true; }
						else { return  false; }
					}

					//v_result :=  true; // TODO This is a shortcut since direction attributes are not decoded
				}
			}
		}
		return v_result
	}

	/** 
	*  @desc copy media/attribute lines from remote to local SDP variable
	*		 
	*/
	function f_copy_SDP() runs on SipComponent
	{
		if (ispresent(vc_sdp_remote.bandwidth))
				{vc_sdp_local.bandwidth := vc_sdp_remote.bandwidth}
			else {vc_sdp_local.bandwidth := {}};
			
		if (ispresent(vc_sdp_remote.media_list))
		{
                //			// cleaning of media before assignment	
                //			if (ispresent(vc_sdp_local.media_list))
                //			{
                //				for (var integer i:=0; i<sizeof(vc_sdp_local.media_list); i:=i+1)
                //				{			
                //					vc_sdp_local.media_list[i] := omit ; 						  
                //				}			
                //			};		
			vc_sdp_local.media_list := vc_sdp_remote.media_list;
		}
	}
}//end group SDPOperations

group AwaitingMessage {

	/**
	 * 
	 * @desc Function waiting for any MSG -request/response 
	 */
	function f_awaitingAnyPassOnTimeout() runs on SipComponent
	{
	  tc_wait.start(PX_SIP_TWAIT);
	  alt
	  {
		[] SIPP.receive	//TAU error if expect (*)
		  {
			tc_wait.stop;
			vc_boo_response:=true;
			vc_boo_request:=true;
			//setverdict(pass)
		  }
		[] tc_wait.timeout
		  {
			vc_boo_response:=false;
			vc_boo_request:=false;
			//setverdict (pass)
		  }
	  }
	} //end f_awaitingResponsePassOnTimeout

	/**
	 * 
	 * @desc Function waiting for no MSG -request/response 
	 */
	function f_awaitingNonePassOnTimeout() runs on SipComponent
	{
	  tc_wait.start(PX_SIP_TWAIT);
	  alt
	  {
		[] SIPP.receive	
		  {
			tc_wait.stop;
			setverdict(fail);
		  }
		[] tc_wait.timeout
		  {
			setverdict (pass);
		  }
	  }
	} //end f_awaitingResponsePassOnTimeout
		
	/**
	 * 
	 * @desc function awaits REGISTER
	 * @param p_register expected REGISTER request
	 */	
 	function f_awaitingREGISTER(in template REGISTER_Request p_register) runs on SipComponent
	{
		var Request v_request;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_register)-> value v_request sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfREGISTER(v_request);
			}
		}		
	}
	
	/**
	 * 
	 * @desc function awaits SUBSCRIBE
	 * @param p_register expected SUBSCRIBE request
	 */	
	function f_awaitingSUBSCRIBE(in template SUBSCRIBE_Request p_register) runs on SipComponent
	{
		var Request	v_request;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_register)-> value v_request sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
			}
		}		
	}
	
	/**
	 * 
	 * @desc function awaits REGISTER and sends a 200 OK response
	 * @param p_reply flag used to avoid the 200OK response sending
	 */	
 	function f_awaitingREGISTER_sendReply(in template REGISTER_Request p_register, in boolean p_reply) runs on SipComponent
	{
		var Request	v_request;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_register)-> value v_request sender vc_sent_label
			{
			  tc_resp.stop;
			  vc_request := v_request;
			  f_setHeadersOnReceiptOfREGISTER(v_request);
			  //Answer to the Request
			  if (p_reply) {f_send200OK();};
			}
		}		
	}
	

	/**
	 * 
	 * @desc Function waiting for a 200 OK response
	 * @param p_cSeq_s current cSeq expectation
	 */
	function f_awaitingOkResponse(inout CSeq p_cSeq_s) runs on SipComponent
	{ 

  	tc_ack.start(PX_SIP_TACK);
  	alt
  	{
		[] SIPP.receive	(mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) -> value vc_response
	  	{
			tc_ack.stop;
			f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
			setverdict(pass)
		}
  	}
	} //end awaitingOkResponse

	/**
	 * 
	 * @desc Function waiting for a response
	 * @param p_Response expected response message
	 */
	function f_awaitingResponse(in template Response p_Response) runs on SipComponent
	{
	  tc_ack.start(PX_SIP_TACK);
	  alt
	  {
		[] SIPP.receive	(p_Response) -> value vc_response
		  {
			tc_ack.stop;
			f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
			setverdict(pass)
		  }
	  }
	} //end f_awaitingResponse
	
	/**
		 * 
		 * @desc Function waiting for a response
		 * @param p_Response expected response message
		 */
		function f_awaitingResponsePassOnTimeout(in template Response p_Response) runs on SipComponent
		{
		  tc_ack.start(PX_SIP_TACK);
		  alt
		  {
			[] SIPP.receive	(p_Response) -> value vc_response
			  {
				tc_ack.stop;
				f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
				vc_boo_response:=true;
				//setverdict(pass)
			  }
			[] tc_ack.timeout
			  {
			  	vc_boo_response:=false;
			  	//setverdict (pass)
			  }
		  }
		} //end f_awaitingResponsePassOnTimeout
	
	/** 
	*  @desc await INFO request
	*		 reply with 200 OK
	*/
	function f_awaitingINFO_sendReply(in template INFO_Request p_MSG) runs on SipComponent
	{
		var INFO_Request	v_MSG;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the INFO
			  f_send200OK();
			}
		}
	} // end of f_awaitingINFO_sendReply
	
	/**
	 * 
	 * @desc function awaiting for an incoming INVITE
	 * @param p_request expected message
	 */
	function f_awaitingINVITE(template INVITE_Request p_request) runs on SipComponent
	{
	  var INVITE_Request v_INVITE_Request;
      
	  tc_wait.start(PX_SIP_TWAIT);
	  alt
	  {
		[]SIPP.receive	(p_request) -> value v_INVITE_Request sender vc_sent_label
		  { 
			tc_wait.stop;
			vc_ignore_invite := true;
			vc_first_recv:= true; // communication has started
			f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
			SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
		  }
	  }
	} //end f_awaitingINVITE

	/**
		* 
		* @desc function awaiting for an incoming INVITE
		* @param p_request expected message
		*/
	function f_awaitingINVITE_No100Response(template INVITE_Request p_request) runs on SipComponent
	{
	  var INVITE_Request v_INVITE_Request;
      
      tc_wait.start(PX_SIP_TWAIT);
      alt
      {
    	[]SIPP.receive	(p_request) -> value v_INVITE_Request sender vc_sent_label
    	  { 
    		tc_wait.stop;
    		vc_ignore_invite := true;
    		vc_first_recv:= true; // communication has started
    		f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
    	    //SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
    	  }
      }
	} //end f_awaitingInviteRequest

	/**
	 * 
	 * @desc function awaiting for an incoming INVITE
	 * @param p_request expected message
	 */
	function f_awaitingINVITE_PassOnTimeout(template INVITE_Request p_request) runs on SipComponent
	{
	  var INVITE_Request v_INVITE_Request;
      
	  tc_wait.start(PX_SIP_TWAIT);
	  alt
	  {
		[]SIPP.receive	(p_request) -> value v_INVITE_Request sender vc_sent_label
		  { 
			tc_wait.stop;
			vc_ignore_invite := true;
			vc_first_recv:= true; // communication has started
			vc_boo_request := true;
			f_setHeadersOnReceiptOfINVITE(v_INVITE_Request);
			SIPP.send(m_Response_Base(c_statusLine100, vc_callId, vc_cSeq, vc_from, vc_to, vc_via)) to vc_sent_label;
		  }
		[]tc_wait.timeout
		  {
			vc_boo_request := false;
		  }
	  }
	} //end f_awaitingInviteRequest

	/**
	 * 
	 * @desc function awaiting ACK request
	 */
	function f_awaitingACK(in template ACK_Request p_ACK) runs on SipComponent
	{
	  var Request v_ACK_Request;
	  tc_ack.start(PX_SIP_TACK);
      
	  alt
	  {
		[] SIPP.receive(p_ACK) -> value v_ACK_Request
		  {
			tc_ack.stop;
		  }
		// INVITE may be repeated and shall be ignored
		[]SIPP.receive(mw_INVITE_Request_Base)
		  {
			repeat;
		  }
		// Ignore othe message
		[] SIPP.receive
		  {
			repeat;
		  }
	  }
	} //end f_awaitingAckRequest

	/**
	 * 
	 * @desc function awaiting BYE and sending 200OK response
	 * @param p_BYE expected BYE
	 */
	function f_awaitingBYE(in template BYE_Request p_BYE) runs on SipComponent
	{
	  var BYE_Request v_BYE_Request;
      
	  tc_resp.start(PX_SIP_TRESP);
	  alt
	  {
		[]SIPP.receive	(p_BYE) -> value v_BYE_Request sender vc_sent_label
		  {
			tc_resp.stop;
			vc_ignore_bye:= true;
			f_setHeadersOnReceiptOfBYE(v_BYE_Request);
			//f_send200OK();
		  }
	  }		
	} // end f_awaitingBYE

	/**
	 * 
	 * @desc function awaiting BYE and sending 200OK response
	 * @param p_BYE expected BYE
	 */
	function f_awaitingBYE_sendReply
	(in template BYE_Request p_BYE) runs on SipComponent
	{
	  var BYE_Request v_BYE_Request;
      
	  tc_resp.start(PX_SIP_TRESP);
	  alt
	  {
		[]SIPP.receive	(p_BYE) -> value v_BYE_Request sender vc_sent_label
		  {
			tc_resp.stop;
			vc_ignore_bye:= true;
			f_setHeadersOnReceiptOfBYE(v_BYE_Request);
			f_send200OK();
		  }
	  }		
	} // end f_awaitingBYE_sendReply
	
	/**
	 * 
	 * @desc function awaiting BYE and sending 200OK response
	 * @param p_BYE expected BYE
	 */
	function f_awaitingBYE_sendReply_PassOnTimeout(in template BYE_Request p_BYE) runs on SipComponent
	{
	  var BYE_Request v_BYE_Request;
      
	  tc_resp.start(PX_SIP_TRESP);
	  alt
	  {
		[]SIPP.receive	(p_BYE) -> value v_BYE_Request sender vc_sent_label
		  {
			tc_resp.stop;
			vc_ignore_bye:= true;
			vc_boo_request := true;
			f_setHeadersOnReceiptOfBYE(v_BYE_Request);
			f_send200OK();
		  }
		[]tc_resp.timeout
		  {
		  	vc_boo_request := false;
		  }
		
	  }		
	} // end f_awaitingBYE_sendReply_PassOnTimeout

	/**
	* 
	* @desc function awaiting CANCEL
	* @param p_CANCEL expected CANCEL
	*/
	function f_awaitingCANCEL(in template CANCEL_Request p_CANCEL) runs on SipComponent
	{
		var CANCEL_Request v_MSG;
     
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		[]SIPP.receive	(p_CANCEL) -> value v_MSG sender vc_sent_label
		  {
			tc_resp.stop;
			f_setHeadersOnReceiptOfRequest(v_MSG);
		  }
		}		
	} // end f_awaitingCANCEL
	/** 
	*  @desc await MESSAGE request
	*/
	function f_awaitingMESSAGE(in template MESSAGE_Request p_MSG) runs on SipComponent
	{
		var MESSAGE_Request	v_MSG;
  
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the MESSAGE
			  //f_send200OK();
			}
		}
	} // end of f_awaitingMESSAGE
	
	/** 
	*  @desc await MESSAGE request
	*		 reply with 200 OK
	*/
	function f_awaitingMESSAGE_sendReply() runs on SipComponent
	{
		var MESSAGE_Request	v_MSG;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(mw_MESSAGE_Request_Base(vc_callId))-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the MESSAGE
			  f_send200OK();
			}
		}		
			
	} // end of f_awaitingMESSAGE_sendReply

	/** 
	*  @desc await MESSAGE request
	*/
	function f_awaitingMESSAGE_sendReply_PassOnTimeout(in template MESSAGE_Request p_MSG) runs on SipComponent
	{
		var MESSAGE_Request	v_MSG;
  
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the MESSAGE
			  //f_send200OK();
			  vc_boo_request := true;
			  f_send200OK();
			  //setverdict (pass);
			}
		  [] tc_resp.timeout
		  	{
			  vc_boo_request := false;
			  //setverdict (pass);
		  	}
		}
	} // end of f_awaitingMESSAGE_PassOnTimeout
	
	/** 
	*  @desc await NOTIFY request
	*		 reply with 200 OK
	*/
	function f_awaitingNOTIFY_sendReply(in template NOTIFY_Request p_MSG) runs on SipComponent
	{
		var NOTIFY_Request	v_MSG;
      
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the NOTIFY
			  f_send200OK();
			}
		}
	} // end of f_awaitingNOTIFY_sendReply	

    /** 
    *  @desc await PRACK request
    *		 reply with 200 OK
    */
    function f_awaitingPRACK_sendReply(in template PRACK_Request p_MSG) runs on SipComponent
    {
    	var PRACK_Request	v_MSG;
      
    	tc_resp.start(PX_SIP_TRESP);
    	alt
    	{
    			[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
    		{
    				tc_resp.stop;
    				f_setHeadersOnReceiptOfRequest(v_MSG);
    				//Answer to the PRACK
    				f_send200OK();
    		}
    	}		
    		
    } // end of f_awaitingPRACK_sendReply
	
		/** 
	*  @desc await PUBLISH request
	*		 reply with 200 OK
	*/
	function f_awaitingPUBLISH_sendReply(in template PUBLISH_Request p_MSG) runs on SipComponent
	{
		var PUBLISH_Request	v_MSG;
  
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
		  [] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
			  tc_resp.stop;
			  f_setHeadersOnReceiptOfRequest(v_MSG);
			  //Answer to the PUBLISH
			  f_send200OK();
			}
		}		
		
	} // end of f_awaitingPUBLISH_sendReply
	
	/** 
	*  @desc await UPDATE request
	*/
	function f_awaitingUPDATE(in template UPDATE_Request p_MSG) runs on SipComponent
	{
		var UPDATE_Request	v_MSG;
  
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
				[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
					tc_resp.stop;
					f_setHeadersOnReceiptOfRequest(v_MSG);
			}
		}
	} // end of f_awaitingUPDATE	
	
	/** 
	*  @desc await UPDATE request
	*		 reply with 200 OK
	*/
	function f_awaitingUPDATE_sendReply(in template UPDATE_Request p_MSG) runs on SipComponent
	{
		var UPDATE_Request	v_MSG;
  
  		tc_resp.start(PX_SIP_TRESP);
		alt
		{
			[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
				{
					tc_resp.stop;
					f_setHeadersOnReceiptOfRequest(v_MSG);
					//Answer to the UPDATE
					f_send200OK();
				}
		}		

	} // end of f_awaitingUPDATE_sendReply
	
		
	/** 
	*  @desc await REFER request
	*/
	function f_awaitingREFER(in template REFER_Request p_MSG) runs on SipComponent
	{
		var REFER_Request v_MSG;
  
		tc_resp.start(PX_SIP_TRESP);
		alt
		{
			[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
			{
					tc_resp.stop;
					f_setHeadersOnReceiptOfRequest(v_MSG);
			}
		}
	} // end of f_awaitingUPDATE
	
} // end AwaitingMessage

group SendMessage {

	/**
 	* 
 	* @desc  send ACK message, update the route and recordRoute header fields depending on boolean flags
 	* @param p_request template of the message to be sent
 	*/	
	function f_SendACK(template ACK_Request p_request) runs on SipComponent
	{
		p_request.msgHeader.route 		:= f_route(); 		// update the route header field depending on vc_boo_route
		// n/a p_request.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
		SIPP.send(p_request) to vc_sent_label;	  
	}
	
	/**
	* 
	* @desc  send BYE message, update the route and recordRoute header fields depending on boolean flags
	* @param p_request template of the message to be sent
	*/	
	function f_SendBYE(template BYE_Request p_request) runs on SipComponent
	{
		f_setHeadersGeneral(vc_cSeq, "BYE"); // cseq, contact, branch, via
		p_request.msgHeader.route 		:= f_route(); 		// update the route header field depending on vc_boo_route
		p_request.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
		SIPP.send(p_request) to vc_sent_label;	  
	}
	
	/**
	* 
	* @desc  send CANCEL message
	* @param p_request template of the message to be sent
	*/	
	function f_SendCANCEL(template CANCEL_Request p_request) runs on SipComponent
	{
		f_setHeadersGeneral(vc_cSeq, "CANCEL"); // cseq, contact, branch, via
		SIPP.send(p_request) to vc_sent_label;	  
	}
		
	/**
	* 
	* @desc  send INFO message
	* @param p_request template of the message to be sent
	*/	
	function f_SendINFO(template INFO_Request p_request) runs on SipComponent
	{
		f_setHeadersGeneral(vc_cSeq, "INFO"); // cseq, contact, branch, via
		SIPP.send(p_request) to vc_sent_label;
	}
	
	/**
	* 
	* @desc  send INVITE message
	* @param p_request template of the message to be sent
	*/	
	function f_SendINVITE(template INVITE_Request p_request) runs on SipComponent
	{
		vc_requestFor407 := valueof(p_request);
		SIPP.send(p_request) to vc_sent_label;
		if(PX_SIP_INVITE_AUTHENTICATION_ENABLED) {a_altstep_401or407();};	  
	}

	/**
	* 
	* @desc  send PRACK message
	* @param p_request template of the message to be sent
	*/
	function f_SendPRACK(template PRACK_Request p_request) 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(p_request) to vc_sent_label;	  
	}

	/**
	* 
	* @desc  send PUBLISH message
	* @param p_request template of the message to be sent
	*/
	function f_SendPUBLISH(template PUBLISH_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;	  
	}
	
	/**
	* 
	* @desc  send REGISTER message
	* @param p_request template of the message to be sent
	*/
	function f_SendREGISTER(template REGISTER_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;	  
	}
		
	/**
	* 
	* @desc  send SUBSCRIBE message
	* @param p_request template of the message to be sent
	*/
	function f_SendSUBSCRIBE(template SUBSCRIBE_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;	  
	}
		
	/**
	* 
	* @desc  send UPDATE message
	* @param p_request template of the message to be sent
	*/
	function f_SendUPDATE(template UPDATE_Request p_request) runs on SipComponent
	{
		f_setHeadersGeneral(vc_cSeq, "UPDATE"); // cseq, contact, branch, via	
		vc_requestFor407 := valueof(p_request);
		SIPP.send(p_request) to vc_sent_label;	  
		if(PX_SIP_INVITE_AUTHENTICATION_ENABLED) {a_altstep_401or407();};	  
	}	
	
	/**
	 * 
	 * @desc function send MESSAGE message
	 * @param p_request template of the message to be sent
	 */
	function f_SendMESSAGE(template MESSAGE_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;	  
	}
	
	/**
	 * 
	 * @desc function send NOTIFY message
	 * @param p_request template of the notify to be sent
	 */
	function f_SendNOTIFY(template NOTIFY_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;	  
	}
			
	/**
	* 
	* @desc  send REFER message
	* @param p_request template of the message to be sent
	*/	
	function f_SendREFER(template REFER_Request p_request) runs on SipComponent
	{
		SIPP.send(p_request) to vc_sent_label;
	}
		
	/**
	* 
	* @desc  send 200 OK
	*/
	function f_send200OK() runs on SipComponent
	{
		f_sendResponse(m_Response_Base(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via));
	}
	
	/**
	* 
	* @desc  send response
	* @param p_request template of the message to be sent
	*/
	function f_sendResponse(template Response p_response) runs on SipComponent
	{
		p_response.msgHeader.route 		 := f_route(); 		// update the route header field depending on vc_boo_route
		p_response.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
		SIPP.send(p_response) to vc_sent_label;
	}

} // end SendMessage

group GlobalSteps {
	/**
	 * 
	 * @desc component initialization
	 * @param p_cSeq_s cSeq value to be assigned to the component variable
	 */
	function f_init_component(inout CSeq p_cSeq_s)  runs on SipComponent
	{
		//Variables
		vc_cSeq := p_cSeq_s;
	
		//Defaults
		vc_def_catchSyncStop := activate(a_Sip_catchSyncStop());
		vc_default := activate (a_clearRegistration());
	}
	
	/**
	 * 
	 * @desc component termination
	 */
	function f_terminate_component() runs on SipComponent
	{
		deactivate;
		stop;
	}

	/**
	 * 
	 * @desc setting of user parameters with PIXIT values