LibSip_Steps.ttcn

            inout Request p_Request
        ) return template(omit) NameAddr  {
            if (isvalue(p_Request.msgHeader.path)) {
                if (lengthof(p_Request.msgHeader.path.pathValues) > 0) {
                    return (p_Request.msgHeader.path.pathValues[0].nameAddr);
                }
            }
            return (omit);
        }

        /**
         * @desc function updates first element of a Via headerfield list
         * @param p_viaBody_List address list of a Via header field
         * @param p_source_address address to be inserted in the top element
         */
        function f_getViaReplyAddr(
            inout ViaBody_List p_viaBody_List,
            inout Address4SIP p_source_address
        ) runs on SipComponent  {
            var ViaBody v_viaBody;
            // The address to send message shall be updated after getting information
            // in the Via header fied and according to 18.2.2
            v_viaBody := p_viaBody_List[0];

            // received parameter has to be addded to the via hader field
            // Be careful it could be an Host name and not an IP Address
            // One of the reasons this error can occur is if no DNS server is available.
            // As a workaround, it is possible to adapt the configuration on the local machine the test 
            // suite is running on (e.g. under Windows the following file could be configured:
            // C:\WINDOWS\system32\drivers\etc\hosts).
            // Check if host address can be rosolved
            if (not f_equivalentHostAddr(valueof(v_viaBody.sentBy.host), valueof(p_source_address.host))) {
                f_addParameterIfNotPresent(c_receivedId, { tokenOrHost := valueof(p_source_address.host) }, v_viaBody);
            }
            if (isvalue(v_viaBody.sentBy.portField)) {
                p_source_address.portField := valueof(v_viaBody.sentBy.portField);
            }
            else {
                p_source_address.portField := c_defaultSipPort;
            }
        }

        /**
         * @desc functions give access to an element of the Route header field (record).
         * @param p_message (request) SIP message to be analysed
         * @param p_index index of Route record element to be retrieved
         * @return HostPort value of the Route element or omit
         */
        function f_getRouteHeaderElementAddressFromRequest(
            in Request p_message,
            in integer p_index
        ) return HostPort  {
            if (isvalue(p_message.msgHeader.route)) {
                if (lengthof(p_message.msgHeader.route.routeBody) > p_index) {
                    return (p_message.msgHeader.route.routeBody[p_index].nameAddr.addrSpec.components.sip.hostPort);
                }
            }
            setverdict(fail);
            return (c_hostport_dummy);
        }

        /**
         * @desc functions give access to an element of the Record-Route header field (record).
         * @param p_message (request) SIP message to be analysed
         * @param p_index index of recordRoute record element to be retrieved
         * @return HostPort value of the Record-Route element or omit
         */
        function f_getRecordRouteHeaderElementAddressFromRequest(
            in Request p_message,
            in integer p_index
        ) return HostPort  {
            if (isvalue(p_message.msgHeader.recordRoute)) {
                if (lengthof(p_message.msgHeader.recordRoute.routeBody) > p_index) {
                    return (p_message.msgHeader.recordRoute.routeBody[p_index].nameAddr.addrSpec.components.sip.hostPort);
                }
            }
            setverdict(fail);
            return (c_hostport_dummy);
        }

        /**
         * @desc functions give access to an element of the Record-Route header field (record).
         * @param p_message (response) SIP message to be analysed
         * @param p_index index of recordRoute record element to be retrieved
         * @return HostPort value of the Record-Route element or omit
         */
        function f_getRecordRouteHeaderElementAddressFromResponse(
            in Response p_message,
            in integer p_index
        ) return HostPort  {
            if (isvalue(p_message.msgHeader.recordRoute)) {
                if (lengthof(p_message.msgHeader.recordRoute.routeBody) > p_index) {
                    return (p_message.msgHeader.recordRoute.routeBody[p_index].nameAddr.addrSpec.components.sip.hostPort);
                }
            }
            setverdict(fail);
            return (c_hostport_dummy);
        }

        /**
         * @desc functions give access to an element of the Via header field (record).
         * @param p_message (request) SIP message to be analysed
         * @param p_index index of via record element to be retrieved
         * @return HostPort value of the Via element or omit
         */
        function f_getViaHeaderElementHostPort(
            in Request p_message,
            in integer p_index
        ) return HostPort  {

            if (lengthof(p_message.msgHeader.via.viaBody) > p_index) {
                return (p_message.msgHeader.via.viaBody[p_index].sentBy);
            }
            setverdict(fail);
            return (c_hostport_dummy);
        }

        /**
         * @desc functions give access to an element of the Via header field (record).
         * @param p_message (response) SIP message to be analysed
         * @param p_index index of via record element to be retrieved
         * @return HostPort value of the Via element or omit
         */
        function f_getViaHeaderElementHostPortResponse(
            in Response p_message,
            in integer p_index
        ) return HostPort  {

            if (lengthof(p_message.msgHeader.via.viaBody) > p_index) {
                return (p_message.msgHeader.via.viaBody[p_index].sentBy);
            }
            setverdict(fail);
            return (c_hostport_dummy);
        }

        /**
         * @desc function checks indicators if topology hiding (TH) has been applied: - second element in via-header record has tokenized-by parameter
         * @param p_Request SIP message to be analysed
         * @return boolean value (true indicate TH, false otherwise)
         */
        function f_topologyHiding(
            inout Request p_request
        ) runs on SipComponent 
        return boolean  {
            var GenericParam v_viaParameter;
            
            if (lengthof(p_request.msgHeader.via.viaBody) <2 ) {
                return (false);
            }
            v_viaParameter := p_request.msgHeader.via.viaBody[1].viaParams[0];
            // second element
            if (not v_viaParameter.id == "tokenized-by") {
                return (false);
            }
            return (true);
        }

        /**
         * @desc function checks indicators if topology hiding (TH) has been applied: - any element in via-header record has tokenized-by parameter
         * @param Response SIP message to be analysed
         * @return boolean value (true indicate TH, false otherwise)
         */
        function f_topologyHidingResponse(
            inout Response p_response
        ) runs on SipComponent 
        return boolean  {
            var GenericParam v_viaParameter;
            var integer i;

            for (i := 0; i < lengthof(p_response.msgHeader.via.viaBody); i := i + 1) {

                v_viaParameter := p_response.msgHeader.via.viaBody[i].viaParams[0]; // first parameter
                if (not v_viaParameter.id == "tokenized-by") {
                    return (false);
                }
            }
            return (true);
        }



        group SetHeaders {


            /**
             * @desc function for setting of component variables related to message header fields (message type independent: CSeq, contact, via), function uses information from userprofile
             * @param p_cSeq_s CSeq parameter
             * @param p_method method name for cSeq header field
             */
            function f_setHeadersGeneral(
                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 := valueof(m_Contact(m_SipUrl_contactIpaddr(vc_userprofile)));
                vc_branch := c_branchCookie & f_getRndTag();
                vc_via := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };
            } // end function f_setHeadersGeneral



            /**
             * @desc function for setting of component variables related to message header fields (message type independent: CSeq, contact, via), function uses information from userprofile
             * @param p_cSeq_s CSeq parameter
             * @param p_method method name for cSeq header field
             */
            function f_setHeadersACK(
            ) runs on SipComponent  {
                // vc_requestUri.hostPort := vc_reqHostPort;
                if (vc_response.statusLine.statusCode >= 200 and vc_response.statusLine.statusCode <= 299)
                // ref. RFC3261 8.1.1.7 Via
                {
                    vc_branch := c_branchCookie & f_getRndTag();
                }
                vc_via := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };
            } // end function f_setHeadersGeneral

            /**
             * @desc setting of general and basic Bye header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersBYE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "BYE"); // cseq, contact, branch, via
                //      vc_callId := { fieldName:=CALL_ID_E, callid:=f_getRndCallId(p_cSeq_s) & c_AT & vc_userprofile.currIpaddr };
                f_addTagInTo(vc_to);

                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersBYE

            /**
             * @desc setting of general and basic CANCEL header fields
             * @param p_cSeq_s
             */
            function f_setHeadersCANCEL(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {

                p_cSeq_s.method := "CANCEL";
                //      vc_branch := c_branchCookie & f_getRndTag(); // STF 406: CANCEL and ACK should have the same branch as the INVITE
                vc_via := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };
            } // end function f_setHeadersCANCEL

            /**
             * @desc function sets header field for the next outgoing REGISTER message
             * @param p_cSeq_s CSeq parameter to be applied
             * @param p_emergency Set to true in case of emergency
             */
            function f_setHeaders_REGISTER(
                inout CSeq p_cSeq_s,
                boolean p_emergency := false
            ) 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; // remember callId for de-registration
                vc_to := valueof(m_To(m_SipUrl_currDomain(vc_userprofile)));
                vc_cancel_To := vc_to;
                v_params := f_addParameter(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) {
                    if (p_emergency) {
                        v_params := {
                            {
                                "sos",
                                omit
                            }
                        };
                        vc_contact.contactBody.contactAddresses[0].addressField.addrSpecUnion.urlParameters := v_params;
                    }
                    else {
                        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)}
                };

                vc_via_REG := vc_via;
            } // end function setHeaders_REGISTER

            /**
             * @desc function sets via, cseq and authorization header for the next outgoing (protected) REGISTER
             * @verdict
             */
            function f_setHeaders_2ndREGISTER(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                var CommaParam_List v_challenge;

                // Increment CSeq sequence number
                p_cSeq_s.seqNumber := p_cSeq_s.seqNumber + 1;
                vc_cSeq := p_cSeq_s;

                vc_requestUri := {
                    scheme := c_sipScheme,
                    components := {
                        sip := {
                            userInfo := omit,
                            hostPort := {
                                host := vc_userprofile.registrarDomain,
                                portField := omit
                            }
                        }
                    },
                    urlParameters := omit,
                    headers := omit
                };

                // new branch tag due to different branch tag in new REGISTER method
                vc_branch := c_branchCookie & f_getRndTag();

                vc_via_REG := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };

                // Extract challenge and calculate credentials for a response.
                v_challenge := vc_response.msgHeader.wwwAuthenticate.challenge.digestCln;


                // Prepair right answer
                vc_authorization := {
                    fieldName := AUTHORIZATION_E,
                    body := {f_calculatecCredentials(vc_userprofile, "REGISTER", v_challenge)}
                };
            } // end function f_setHeaders_2ndREGISTER

            /**
             * @desc function sets via, cseq and authorization header for the next outgoing (protected) REGISTER NO response in Authorization header to cause an error
             * @verdict
             */
            function f_setHeaders_2ndREGISTER_wo_response(
            ) runs on SipComponent  {
                var CommaParam_List v_challenge;

                vc_branch := c_branchCookie & f_getRndTag();

                vc_via_REG := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };

                if (ischosen(vc_response.msgHeader.wwwAuthenticate.challenge.otherChallenge))
                // Extract challenge and calculate credentials for a response.
                {
                    v_challenge := vc_response.msgHeader.wwwAuthenticate.challenge.otherChallenge.authParams;
                }
                else {
                    v_challenge := vc_response.msgHeader.wwwAuthenticate.challenge.digestCln;
                }

                // Increment CSeq sequence number
                vc_cSeq.seqNumber := vc_cSeq.seqNumber + 1;

                // Prepair right answer
                vc_authorization := {
                    fieldName := AUTHORIZATION_E,
                    body := {f_calculatecCredentials_wo_response(vc_userprofile, "REGISTER", v_challenge)}
                };
            } // end function f_setHeaders_2ndREGISTER_wo_response

            /**
             * @desc function sets via, cseq and authorization header with different private name for the next outgoing (protected) REGISTER
             * @verdict
             */
            function f_setHeaders_2ndREGISTER_authorizationWithDifferentUserName(
            ) runs on SipComponent  {
                var CommaParam_List v_challenge;

                vc_branch := c_branchCookie & f_getRndTag();

                vc_requestUri := {
                    scheme := c_sipScheme,
                    components := {
                        sip := {
                            userInfo := omit,
                            hostPort := {
                                host := vc_userprofile.registrarDomain,
                                portField := omit
                            }
                        }
                    },
                    urlParameters := omit,
                    headers := omit
                };

                vc_via_REG := {
                    fieldName := VIA_E,
                    viaBody := {valueof(m_ViaBody_currIpaddr(vc_branch, vc_userprofile))}
                };

                // Extract challenge and calculate credentials for a response.
                v_challenge := vc_response.msgHeader.wwwAuthenticate.challenge.otherChallenge.authParams;

                // Increment CSeq sequence number
                vc_cSeq.seqNumber := vc_cSeq.seqNumber + 1;

                // Prepair right answer
                vc_authorization := {
                    fieldName := AUTHORIZATION_E,
                    body := {f_calculatecCredentialsAndChangeUserName(vc_userprofile, "REGISTER", v_challenge)}
                };
            } // end function f_setHeaders_2ndREGISTER_authorizationWithDifferentUserName


            /**
             * @desc function sets header fields for the next outgoing REGISTER (de-registration)
             * @param p_cSeq_s cSeq to be used
             * @verdict
             */
            function f_setHeaders_deREGISTER(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                var SemicolonParam_List v_params := {};

                f_setHeadersGeneral(p_cSeq_s, "REGISTER"); // cseq, contact, branch, via
                // reset authorization header to not use nonce from registration (otherwise we have to increase nc)
                vc_authorization := {
                    fieldName := AUTHORIZATION_E,
                    body := {f_calculatecCredentials_empty(vc_userprofile)}
                };
                vc_requestUri := {
                    scheme := c_sipScheme,
                    components := {
                        sip := {
                            userInfo := omit,
                            hostPort := {
                                host := vc_userprofile.registrarDomain,
                                portField := omit
                            }
                        }
                    },
                    urlParameters := omit,
                    headers := omit
                };
                vc_to := valueof(m_To(m_SipUrl_currDomain(vc_userprofile)));
                v_params := f_addParameter(v_params,
                    {
                        id := c_tagId,
                        paramValue := { 
                            tokenOrHost := f_getRndTag()
                        }
                    });
                vc_from := {
                    fieldName := FROM_E,
                    addressField := vc_to.addressField,
                    fromParams := v_params
                };

                vc_contact := {
                    fieldName := CONTACT_E,
                    contactBody := {wildcard := "*"}
                };
            } // end function f_setHeaders_deREGISTER


            /**
             * @desc setting of general and basic Invite header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersINVITE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "INVITE"); // cseq, contact, branch, via
                vc_callId := {
                    fieldName := CALL_ID_E,
                    callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
                };

                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                if (ischosen(vc_requestUri.components.sip)) {
                    // sip/sips call
                    vc_reqHostPort := vc_requestUri.components.sip.hostPort;
                }
                else if (ischosen(vc_requestUri.components.urn)) {
                    // Emergency call
                    vc_reqUrnUri := vc_requestUri.components.urn;
                }
                else {
                    log("*** " & __SCOPE__ &": INFO:f_setHeadersINVITE: unsupported field: ", vc_requestUri," ***");
                    setverdict(fail);
                }
            }

            /**
             * @desc setting of general and basic Update header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersUPDATE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "UPDATE"); // cseq, contact, branch, via
                vc_callId := {
                    fieldName := CALL_ID_E,
                    callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
                };

                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersUPDATE

            /**
             * @desc setting of general and basic Message header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersMESSAGE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "MESSAGE"); // cseq, contact, branch, via
                vc_callId := {
                    fieldName := CALL_ID_E,
                    callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
                };

                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersMESSAGE

            /**
             * @desc setting of general and basic Notify header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersNOTIFY(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "NOTIFY"); // cseq, contact, branch, via
                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;
                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersNOTIFY

            /**
             * @desc setting of general and basic Publish header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersPUBLISH(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "PUBLISH"); // cseq, contact, branch, via
                // after SUBSCRIBE message callid shall be same
                //      vc_callId := { fieldName:=CALL_ID_E, callid:=f_getRndCallId(p_cSeq_s) & c_AT & vc_userprofile.currIpaddr };
                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersPUBLISH

            /**
             * @desc function sets header field for the next outgoing SUBSCRIBE message
             * @param p_cSeq_s CSeq parameter to be applied
             */
            function f_setHeaders_SUBSCRIBE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                var SemicolonParam_List v_params := {};

                f_setHeadersGeneral(p_cSeq_s, "SUBSCRIBE"); // cseq, contact, branch, via
                vc_requestUri := valueof(m_SipUrl_currDomain(vc_userprofile));

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;

                vc_callId := {
                    fieldName := CALL_ID_E,
                    callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
                };

                // store callId from Subscribe message
                vc_callIdSub := vc_callId;

                vc_to := valueof(m_To(m_SipUrl_currDomain(vc_userprofile)));
                vc_cancel_To := vc_to;
                v_params := f_addParameter(v_params, 
                    {
                        id := c_tagId,
                        paramValue := {
                            tokenOrHost := f_getRndTag()
                        }
                    });
                vc_from := {
                    fieldName := FROM_E,
                    addressField := vc_to.addressField,
                    fromParams := v_params
                };
            } // end function setHeaders_SUBSCRIBE

            /**
             * @desc setting of general and basic Subscribe header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersSUBSCRIBE(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "SUBSCRIBE"); // cseq, contact, branch, via
                vc_callId := {
                    fieldName := CALL_ID_E,
                    callid := f_getRndCallId() & c_AT & vc_userprofile.currIpaddr
                };

                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersMESSAGE

            /**
             * @desc setting of general and basic REFER header fields in additon to the addresses (To, From, ReqUri)
             * @param p_cSeq_s
             */
            function f_setHeadersREFER(
                inout CSeq p_cSeq_s
            ) runs on SipComponent  {
                f_setHeadersGeneral(p_cSeq_s, "REFER"); // cseq, contact, branch, via
                //      vc_callId := { fieldName:=CALL_ID_E, callid:=f_getRndCallId(p_cSeq_s) & c_AT & vc_userprofile.currIpaddr };
                vc_cancel_To := vc_to;
                vc_caller_To := vc_to;

                vc_caller_From := vc_from;

                vc_reqHostPort := vc_requestUri.components.sip.hostPort;
            } // end function f_setHeadersREFER

            /**
             * @desc This function reads all necessary headers from the received REGISTER message and generate the tag for the answer
             * @param p_Request REGISTER that has been received
             */
            function f_setHeadersOnReceiptOfREGISTER(
                Request p_Request
            ) runs on SipComponent  {

                f_setHeadersOnReceiptOfRequest(p_Request);

                vc_callId := p_Request.msgHeader.callId;
                vc_caller_From := vc_from;
                f_addTagInTo(vc_to);
                vc_caller_To := vc_to;
                vc_requestUri := p_Request.requestLine.requestUri;

                vc_cancel_To := p_Request.msgHeader.toField;

                if (isvalue(p_Request.msgHeader.contact) and (not ischosen(p_Request.msgHeader.contact.contactBody.wildcard))) {
                    vc_reqHostPort := f_getContactAddr(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                }

                // update callee information and pick up tag if the call need to be canceled
                vc_callee_To := {
                    fieldName := TO_E,
                    addressField := vc_caller_From.addressField,
                    toParams := vc_caller_From.fromParams
                };

                vc_callee_From := {
                    fieldName := FROM_E,
                    addressField := vc_caller_To.addressField,
                    fromParams := vc_caller_To.toParams
                };

                if (isvalue(p_Request.msgHeader.authorization)) {
                    vc_authorization := valueof(p_Request.msgHeader.authorization);
                }
            } // end f_setHeadersOnReceiptOfREGISTER

            /**
             * @desc This function reads all necessary headers from the received SUBSCRIBE message and generate the tag for the answer
             * @param p_Request SUBSCRIBE that has been received
             */
            function f_setHeadersOnReceiptOfSUBSCRIBE(
                Request p_Request
            ) runs on SipComponent  {

                f_setHeadersOnReceiptOfRequest(p_Request);

                vc_callId := p_Request.msgHeader.callId;
                vc_caller_From := vc_from;
                f_addTagInTo(vc_to);
                vc_caller_To := vc_to;
                vc_requestUri := p_Request.requestLine.requestUri;

                vc_cancel_To := p_Request.msgHeader.toField;

                if (isvalue(p_Request.msgHeader.contact)) {
                    vc_reqHostPort := f_getContactAddr(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                }

                // update callee information and pick up tag if the call need to be canceled
                vc_callee_To := {
                    fieldName := TO_E,
                    addressField := vc_caller_From.addressField,
                    toParams := vc_caller_From.fromParams
                };

                vc_callee_From := {
                    fieldName := FROM_E,
                    addressField := vc_caller_To.addressField,
                    fromParams := vc_caller_To.toParams
                };
            } // end f_setHeadersOnReceiptOfSUBSCRIBE

            function f_setHeadersOnReceiptOfREFER(
                Request p_Request
            ) runs on SipComponent  {

                f_setHeadersOnReceiptOfRequest(p_Request);

                vc_requestUri := p_Request.requestLine.requestUri;
                vc_cancel_To := p_Request.msgHeader.toField;

                if (isvalue(p_Request.msgHeader.contact)) {
                    vc_reqHostPort := f_getContactAddr(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                    vc_requestUri := f_getContactUri(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                }

                // update callee information and pick up tag if the call need to be canceled
                vc_callee_To := {
                    fieldName := TO_E,
                    addressField := vc_caller_From.addressField,
                    toParams := vc_caller_From.fromParams
                };

                vc_callee_From := {
                    fieldName := FROM_E,
                    addressField := vc_caller_To.addressField,
                    fromParams := vc_caller_To.toParams
                };
            } // end f_setHeadersOnReceiptOfREFER

            /**
             * @desc function reads all necessary headers from the received INVITE message and generate the tag for the answer
             * @param p_Request received INVITE message
             * @verdict
             */
            function f_setHeadersOnReceiptOfINVITE(
                Request p_Request
            ) runs on SipComponent  {
                var integer i, j;
                var integer v_length;
                
                f_setHeadersOnReceiptOfRequest(p_Request);

                vc_callId := p_Request.msgHeader.callId;

                vc_requestUri2 := p_Request.requestLine.requestUri;

                vc_cancel_To := p_Request.msgHeader.toField;
                f_addTagInTo(vc_to);
                vc_caller_From := vc_from;
                vc_caller_To := vc_to;

                if (isvalue(p_Request.msgHeader.contact)) {
                    vc_reqHostPort := f_getContactAddr(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                    vc_requestUri := f_getContactUri(p_Request.msgHeader.contact.contactBody.contactAddresses[0]);
                }

                // update callee information and pick up tag if the call need to be canceled
                vc_callee_To := {
                    fieldName := TO_E,
                    addressField := vc_caller_From.addressField,
                    toParams := vc_caller_From.fromParams
                };

                vc_callee_From := {
                    fieldName := FROM_E,
                    addressField := vc_caller_To.addressField,
                    fromParams := vc_caller_To.toParams
                };

                if (isvalue(p_Request.msgHeader.privacy)) {
                    vc_privacy := p_Request.msgHeader.privacy;
                }

                if (isvalue(p_Request.messageBody)) {
                    // cleaning of attributes before assignment
                    if (isvalue(vc_sdp_remote.media_list)) {
                        v_length := lengthof(vc_sdp_remote.media_list);
                        for (i := 0; i < v_length; i := i + 1) {
                            if (isvalue(vc_sdp_remote.media_list[i].attributes)) {
                                vc_sdp_remote.media_list[i].attributes := omit;
                            }
                        }
                    }

                    // save SDP if present
                    if (ischosen(p_Request.messageBody.sdpMessageBody)) {
                        vc_sdp_remote := p_Request.messageBody.sdpMessageBody;
                        vc_sdp_remote_is_valid := true;
                        f_prepare_SDP_answer();
                    }

                    // save XML if present
                    if (ischosen(p_Request.messageBody.xmlBody)) {
                        vc_xml_remote := p_Request.messageBody.xmlBody;
                    }

                    if (ischosen(p_Request.messageBody.mimeMessageBody)) {

                        for (j := 0; j < lengthof(p_Request.messageBody.mimeMessageBody.mimeEncapsulatedList); j := j + 1) {
                            if (match(p_Request.messageBody.mimeMessageBody.mimeEncapsulatedList[j].content_type, c_sdpApplication)) {
                                vc_sdp_remote := p_Request.messageBody.mimeMessageBody.mimeEncapsulatedList[j].mime_encapsulated_part.sdpMessageBody;
                                vc_sdp_remote_is_valid := true;
                                f_prepare_SDP_answer();
                            }
                            if (match(p_Request.messageBody.mimeMessageBody.mimeEncapsulatedList[j].content_type, c_xmlApplication)) {
                                vc_xml_remote := p_Request.messageBody.mimeMessageBody.mimeEncapsulatedList[j].mime_encapsulated_part.xmlBody;
                            }
                        }
                    }
                }

                if (isvalue(p_Request.msgHeader.supported.optionsTags)) {
                    for (i := lengthof(p_Request.msgHeader.supported.optionsTags); i > 0; i := i - 1) {
                        if (p_Request.msgHeader.supported.optionsTags[i - 1] == "100rel") {
                            vc_supported_100rel := true;
                        }
                        if (p_Request.msgHeader.supported.optionsTags[i - 1] == "precondition") {
                            vc_supported_precondition := true;
                        }
                    }
                }
            } // end f_setHeadersOnReceiptOfINVITE

            /**
             * @desc function reads header field of a received BYE message
             * @param p_Request received BYE
             */
            function f_setHeadersOnReceiptOfBYE(
                Request p_BYE_Request
            ) runs on SipComponent  {

                f_setHeadersOnReceiptOfRequest(p_BYE_Request);
                vc_callId := p_BYE_Request.msgHeader.callId;
            } // end f_setHeadersOnReceiptOfBYE

            /**
             * @desc function reads header field from an incoming Request message
             * @param p_Request received Request message
             */
            function f_setHeadersOnReceiptOfRequest(
                Request p_Request
            ) runs on SipComponent  {
                vc_request := p_Request;
                vc_callId := p_Request.msgHeader.callId;
                vc_cSeq := valueof(p_Request.msgHeader.cSeq); // CSeq is mandatory
                vc_iut_CSeq := p_Request.msgHeader.cSeq;
                vc_from := p_Request.msgHeader.fromField;
                vc_caller_From := p_Request.msgHeader.fromField;
                vc_to := p_Request.msgHeader.toField;
                vc_caller_To := p_Request.msgHeader.toField;
                vc_via := p_Request.msgHeader.via;
                // update sent_label according to received via header field
                f_getViaReplyAddr(vc_via.viaBody, vc_sent_label);

                // Catch route
                vc_boo_recordRoute := false;

                // add tag field into To header if tag is not present
                if (not (isvalue(p_Request.msgHeader.toField.toParams))) {
                    vc_to.toParams := {
                        {
                            id := c_tagId,
                            paramValue := {
                                tokenOrHost := f_getRndTag()
                            }
                        }
                    };
                    vc_caller_To := vc_to;
                }
                if (isvalue(p_Request.msgHeader.recordRoute.fieldName)) {//Due to ES 201 873-1/C.3.3 Better to check if fieldName of Record Route is present
                    vc_boo_recordRoute := true;
                    vc_recordRoute := p_Request.msgHeader.recordRoute;
                }
            } // end f_setHeadersOnReceiptOfRequest

            /**
             * @desc functions reads header fields from an incoming Response message
             * @param p_cSeq
             * @param p_response received response message
             * @verdict
             */
            function f_setHeadersOnReceiptOfResponse(
                Response p_response
            ) runs on SipComponent  {
                var integer i, j, v_nbroute;
                var template(omit) Contact v_contact;
                // only for local purpose
                vc_response := p_response;
                // vc_cSeq := p_cSeq; //must not save global c_seq because it can overwrite temporary cSeq
                vc_to := p_response.msgHeader.toField;
                vc_from := p_response.msgHeader.fromField;
                vc_caller_To := vc_to;
                vc_caller_From := vc_from;

                if (isvalue(p_response.msgHeader.contact)) {
                    v_contact := p_response.msgHeader.contact;
                    if (ischosen(v_contact.contactBody.contactAddresses)) {
                        vc_reqHostPort := f_getContactAddr(valueof(v_contact.contactBody.contactAddresses[0]));
                        vc_requestUri := f_getContactUri(valueof(v_contact.contactBody.contactAddresses[0]));
                    }
                }
                else {
                    if (ischosen(vc_to.addressField.addrSpecUnion.components.sip)) {
                        // sip/sips call
                        vc_reqHostPort := vc_to.addressField.addrSpecUnion.components.sip.hostPort;
                    }
                    else if (ischosen(vc_to.addressField.addrSpecUnion.components.urn)) {
                        // Emergency call
                        vc_reqUrnUri := vc_to.addressField.addrSpecUnion.components.urn;
                    }
                    else {
                        log("*** f_setHeadersOnReceiptOfResponse: INFO: unsupported field: ", vc_to, " ***");
                        setverdict(fail);
                    }
                    vc_requestUri := vc_to.addressField.addrSpecUnion;
                }

                vc_callee_To := {
                    fieldName := TO_E,
                    addressField := vc_caller_From.addressField,
                    toParams := vc_caller_From.fromParams
                };