LibSip_Steps.ttcn

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

                vc_via := p_response.msgHeader.via;

                // Route Management
                if (isvalue(p_response.msgHeader.recordRoute)) {
                    vc_recordRoute := p_response.msgHeader.recordRoute;
                    v_nbroute := lengthof(vc_recordRoute.routeBody);
                    // copy and reverse the order of the routes in route header
                    for (i := 0; i <= (v_nbroute - 1); i := i + 1) {
                        j := v_nbroute - 1 - i;
                        vc_route.routeBody[j] := vc_recordRoute.routeBody[i];
                    }
                    vc_route.fieldName := ROUTE_E;
                    vc_boo_recordRoute := true;
                    vc_boo_route := true;
                }
                else {
                    vc_boo_recordRoute := false;
                    vc_boo_route := false;
                }


                // extentions due to new fields in PRACK and UPDATE messages
                if (isvalue(p_response.msgHeader.rSeq)) {
                    vc_rAck := {
                        fieldName := RACK_E,
                        responseNum := valueof(p_response.msgHeader.rSeq.responseNum),
                        seqNumber := valueof(p_response.msgHeader.cSeq.seqNumber),
                        method := valueof(p_response.msgHeader.cSeq.method)
                    };
                }

                // extentions due to new HistoryInfo fields 180 or 200OK messages
                if (isvalue(p_response.msgHeader.historyInfo)) {
                    vc_historyInfoList := valueof(p_response.msgHeader.historyInfo.historyInfoList);
                    vc_history_is_valid := true;
                }
                else {
                    vc_history_is_valid := false;
                }

                // sdpMessageBody answer
                if (isvalue(p_response.messageBody)) {
                    if (ischosen(p_response.messageBody.sdpMessageBody)) {
                        vc_sdp_remote := p_response.messageBody.sdpMessageBody;
                        vc_sdp_remote_is_valid := true;
                    }

                    if (ischosen(p_response.messageBody.xmlBody)) {
                        vc_xml_remote := p_response.messageBody.xmlBody;
                    }

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

                        for (j := 0; j < lengthof(p_response.messageBody.mimeMessageBody.mimeEncapsulatedList); j := j + 1) {
                            if (match(p_response.messageBody.mimeMessageBody.mimeEncapsulatedList[j].content_type, c_sdpApplication)) {
                                vc_sdp_remote := p_response.messageBody.mimeMessageBody.mimeEncapsulatedList[j].mime_encapsulated_part.sdpMessageBody;
                            }
                            if (match(p_response.messageBody.mimeMessageBody.mimeEncapsulatedList[j].content_type, c_xmlApplication)) {
                                vc_xml_remote := p_response.messageBody.mimeMessageBody.mimeEncapsulatedList[j].mime_encapsulated_part.xmlBody;
                            }
                        }
                    }
                }
            } // end function f_setHeadersOnReceiptOfResponse

            /**
             * @desc functions reads ServiceRoute header field from an incoming 200 Response message in registration
             * @param p_cSeq
             * @param p_response received response message
             */
            function f_getServiceRouteMapIntoRouteInRegistration(
                Response p_response
            ) runs on SipComponent  {
                var integer i, j, v_nbroute;
                var template(omit) ServiceRoute v_serviceRoute;

                // Route Management
                if (isvalue(p_response.msgHeader.serviceRoute.fieldName)) {////Due to ES 201 873-1/C.3.3 Better to check if fieldName of Record Route is present
                    v_serviceRoute := p_response.msgHeader.serviceRoute;
                    v_nbroute := lengthof(v_serviceRoute.routeBody);
                    // copy and reverse the order of the routes in route header
                    for (i := 0; i <= (v_nbroute - 1); i := i + 1) {
                        j := v_nbroute - 1 - i;
                        vc_route.routeBody[j] := v_serviceRoute.routeBody[i];
                    }
                    vc_route.fieldName := ROUTE_E;
                    vc_route_REG := vc_route;
                    vc_boo_route := true;
                }
            } // end function f_getServiceRouteMapIntoRouteInRegistration

            /**
             * @desc functions reads Route header field from an incoming Request message and generate RecordRoute
             * @param p_cSeq
             * @param p_request received request message
             */
            function f_getRouteMapIntoRecordRoute(
                Request p_request
            ) runs on SipComponent  {
                var integer i, j, v_nbroute;
                var template(omit) Route v_route;

                // Route Management
                if (isvalue(p_request.msgHeader.route)) {
                    v_route := p_request.msgHeader.route;
                    v_nbroute := lengthof(v_route.routeBody);
                    // copy and reverse the order of the routes in route header
                    for (i := 0; i <= (v_nbroute - 1); i := i + 1) {
                        j := v_nbroute - 1 - i;
                        vc_recordRoute.routeBody[j] := v_route.routeBody[i];
                    }
                    vc_recordRoute.fieldName := RECORD_ROUTE_E;

                    vc_boo_recordRoute := true;
                }
            } // end function f_getRouteMapIntoRecordRoute


        } // end group SetHeaders



    } // end group FieldOperations

    group SDPOperations {

        /**
         * @desc check if message body include SDP attribute (2nd parameter) for any media
         */
        function f_check_attribute(
            in SDP_Message p_sdp,
            in template SDP_attribute p_attribute
        ) runs on SipComponent 
        return boolean  {
            var integer i, j;

            if (isvalue(p_sdp.media_list)) {
                for (j := 0; j < lengthof(p_sdp.media_list); j := j + 1) {
                    if (isvalue(p_sdp.media_list[j].attributes)) {
                        for (i := 0; i < lengthof(p_sdp.media_list[j].attributes); i := i + 1) {
                            if (match(p_sdp.media_list[j].attributes[i], p_attribute)) {
                                return (true);
                            }
                        }
                    }
                }
            }
            if (isvalue(p_sdp.attributes)) {
                for (j := 0; j < lengthof(p_sdp.attributes); j := j + 1) {
                    if (match(p_sdp.attributes[j], p_attribute)) {
                        return (true);
                    }
                }
            }

            return (false);
        }

        /**
         * @desc check if message body include SDP (session level) attribute (2nd parameter) for any media
         */
        function f_check_session_attribute(
            in SDP_Message p_sdp,
            in template SDP_attribute p_attribute
        ) runs on SipComponent 
        return boolean  {
            var integer j;

            if (isvalue(p_sdp.attributes)) {
                for (j := 0; j < lengthof(p_sdp.attributes); j := j + 1) {
                    if (match(p_sdp.attributes[j], p_attribute)) {
                        return (true);
                    }
                }
            }

            return (false);
        }

        /**
         * @desc identify an SDP direction attribute (session or first media attribute) in a SDP message and return its answer value
         * @param p_sdp the SDP message that has been received
         * @param p_attribute incoming SDP attribute that need to be used for the SDP direction (answer)
         * @return the new attribute (to be send out) derived from the incoming SDP value
         * @verdict
         */
        function f_get_attribute_answer(
            in SDP_Message p_sdp,
            in template SDP_attribute p_attribute
        ) runs on SipComponent 
        return SDP_attribute  {
            var integer i, j;
            var template SDP_attribute v_attribute := p_attribute;

            // check if the selected attribute is included in the SDP offer (session attributes)
            if (isvalue(p_sdp.attributes)) {
                for (j := 0; j < lengthof(p_sdp.attributes); j := j + 1) {
                    if (match(p_sdp.attributes[j], p_attribute)) {
                        v_attribute := p_sdp.attributes[j];
                    }
                }
            }
            else
            // check if the selected attribute is included in the SDP offer (any of the media attributes)
            {
                if (isvalue(p_sdp.media_list)) {
                    for (j := 0; j < lengthof(p_sdp.media_list); j := j + 1) {
                        if (isvalue(p_sdp.media_list[j].attributes)) {
                            for (i := 0; i < lengthof(p_sdp.media_list[j].attributes); i := i + 1) {
                                if (match(p_sdp.media_list[j].attributes[i], p_attribute)) {
                                    v_attribute := p_sdp.media_list[j].attributes[i];
                                }
                            }
                        }
                    }
                }
            }

            select (valueof(v_attribute)) {
                case (mw_attribute_sendonly) {
                    return (valueof(m_attribute_recvonly));
                }
                case (mw_attribute_sendrecv) {
                    return (valueof(m_attribute_sendrecv));
                } // MRO
                case (mw_attribute_inactive) {
                    return (valueof(m_attribute_inactive));
                } // MRO
                case (mw_attribute_recvonly) {
                    return (valueof(m_attribute_sendonly));
                } // MRO
            }
            return (valueof(m_attribute_sendrecv)); // the default return value in case of missing attribute offer
        }

        /**
         * @desc check if message body include SDP bandwidth (2nd parameter) either for the session or a media description
         */
        function f_check_bandwidth(
            in SDP_Message p_loc_sdp,
            in template SDP_bandwidth p_loc_bandw
        ) runs on SipComponent 
        return boolean  {
            var integer i, j;
            if (isvalue(p_loc_sdp.bandwidth)) {
                for (j := 0; j < lengthof(p_loc_sdp.bandwidth); j := j + 1) {
                    if (match(p_loc_sdp.bandwidth[j], p_loc_bandw)) {
                        return (true);
                    }
                }
            }
            if (isvalue(p_loc_sdp.media_list)) {
                for (j := 0; j < lengthof(p_loc_sdp.media_list); j := j + 1) {
                    if (isvalue(p_loc_sdp.media_list[j].bandwidth)) {
                        for (i := 0; i < lengthof(p_loc_sdp.media_list[j].bandwidth); i := i + 1) {
                            if (match(p_loc_sdp.media_list[j].bandwidth[i], p_loc_bandw)) {
                                return (true);
                            }
                        }
                    }
                }
            }

            return (false);
        }

        /**
         * @desc check if message body include SDP media (2nd parameter)
         */
        function f_check_media(
            in SDP_Message p_loc_sdp,
            in template(present) SDP_media_desc p_loc_media
        ) runs on SipComponent 
        return boolean  {
            var integer j;
            if (isvalue(p_loc_sdp.media_list)) {
                for (j := 0; j < lengthof(p_loc_sdp.media_list); j := j + 1) {
                    if (match(p_loc_sdp.media_list[j].media_field.transport, p_loc_media.media_field.transport) and match(p_loc_sdp.media_list[j].media_field.fmts, p_loc_media.media_field.fmts)) {
                        return (true);
                    }
                }
            }
            return (false);
        }

        /**
         * @desc check if message body include precondition mechanism (a=des and a=curr) retrun true, else false
         * @param loc_sdp SDP message
         */
        function f_check_precondition(
            in SDP_Message p_loc_sdp
        ) runs on SipComponent 
        return boolean  {
            if (f_check_attribute(p_loc_sdp, mw_attribute_des) or f_check_attribute(p_loc_sdp, mw_attribute_curr)) {
                return (true);
            }

            return (false);
        }


        /**
         * @desc check if message body include SDP media direction return true, else false
         */
        function f_check_media_direction(
            in SDP_Message p_loc_sdp
        ) runs on SipComponent 
        return boolean  {

            if (f_check_attribute(p_loc_sdp, mw_attribute_sendonly) or f_check_attribute(p_loc_sdp, mw_attribute_recvonly) or f_check_attribute(p_loc_sdp, mw_attribute_sendrecv) or f_check_attribute(p_loc_sdp, mw_attribute_inactive)) {
                return (true);
            }

            return (false);
        }

        /**
         * @desc copy media/attribute lines from remote to local SDP variable
         */
        function f_check_SDP(
            integer p_loc_sdp,
            integer p_loc_codec
        ) runs on SipComponent 
        return boolean  {
            var SDP_media_desc v_media := f_prepare_media(p_loc_sdp, p_loc_codec);
            if (vc_sdp_remote.media_list[0].media_field.media != v_media.media_field.media) {
                return false;
            }
            if (vc_sdp_remote.media_list[0].media_field.transport != v_media.media_field.transport) {
                return false;
            }
            if (vc_sdp_remote.media_list[0].media_field.fmts != v_media.media_field.fmts) {
                return false;
            }

            return true;
        }

        /**
         * @desc replace the first curr media attribute with the given value.
         * @param p_sdp SDP message to modify
         * @param p_curr new curr attribute
         */
        function f_replace_curr_attribute(
            inout SDP_Message p_sdp,
            in SDP_attribute_curr p_curr
        ) {
            var integer i;
            var integer v_mn;
            if (isvalue(p_sdp.media_list)) {
                v_mn := lengthof(p_sdp.media_list[0].attributes);
                for (i := 0; i < v_mn; i := i + 1) {
                    if (ischosen(p_sdp.media_list[0].attributes[i].curr)) {
                        p_sdp.media_list[0].attributes[i].curr := p_curr;
                        i := v_mn;
                    }
                }
            }
        }

        /**
         * @desc append new media attribute to the first media description.
         * @param p_sdp SDP message to modify
         * @param p_att SDP attribute to appand
         */
        function f_append_media_attribute(
            inout SDP_Message p_sdp,
            in SDP_attribute p_att
        ) {
          var integer v_mn := 0;
            if (isvalue(p_sdp.media_list)) {
              if(ispresent(p_sdp.media_list[0].attributes)) {
                v_mn := lengthof(p_sdp.media_list[0].attributes);
              }
              p_sdp.media_list[0].attributes[v_mn] := p_att;
            }
        }


        /**
         * @desc append new media to the existing media list in SDP
         */
        function f_append_media(
            inout SDP_Message p_loc_SDP,
            template(value) SDP_media_desc p_loc_media
        ) {
            var integer v_mn := lengthof(p_loc_SDP.media_list);
            p_loc_SDP.media_list[v_mn] := valueof(p_loc_media);
        }

        /**
         * @desc append new connection to the existing connection list in SDP
         */
        function f_set_connectiom(
            inout SDP_Message p_loc_SDP,
            template(value) SDP_connection p_connection
        ) {
            p_loc_SDP.connection := valueof(p_connection);
        }

        /**
         * @desc repare media/attribute lines
         */
        function f_prepare_media(
            integer p_loc_sdp,
            integer p_loc_codec
        ) runs on SipComponent 
        return SDP_media_desc  {
            var SDP_attribute_rtpmap_codec v_codecs[32] := {
                {"PCMU", "8000", omit}, {"GSM", "8000", omit}, {"G723", "8000", omit}, {"DVI4", "8000", omit}, 
                {"DVI4", "16000", omit}, {"LPC", "8000", omit}, {"PCMA", "8000", omit}, {"G722", "8000", omit},
                {"L16", "44100", "2"}, {"L16", "44100", omit}, {"QCELP", "8000", omit}, {"CN","8000", omit}, 
                {"MPA", "90000", omit}, {"G728", "8000", omit}, {"DVI4", "11025", omit}, {"DVI4", "22050", omit},
                {"G729", "8000", omit}, {"G726-40", "8000", omit}, {"G726-32", "8000", omit}, {"G726-24", "8000", omit},
                {"G726-16", "8000", omit}, {"G726D", "8000", omit}, {"G726E", "8000", omit}, {"GSM-EFR", "8000", omit},
                {"CelB", "90000", omit}, {"JPEG", "90000", omit}, {"Nv", "90000", omit}, {"H261", "90000", omit}, 
                {"MPV", "90000", omit}, {"MP2T" ,"90000", omit}, {"H263", "90000", omit}, {"H263-1998", "90000", omit}};
            var SDP_media_desc v_media := {
                    media_field := {
                        media := "audio",
                        ports := {
                            port_number := 10000,
                            num_of_ports := omit
                        },
                        transport := "RTP/AVP",
                        fmts := {"0"}
                    },  // m=audio
                        // 8500
                        // RTP/AVP
                        // 0
                    information := omit,
                    connections := omit,
                    bandwidth := omit,
                    key := omit,
                    attributes := omit
                };

            if (32 < p_loc_codec or p_loc_codec < 1) {
                log("*** " & __SCOPE__ & ": INFO: Unexpected SDP variant ***");
                setverdict(inconc);
                return (v_media);
            }

            if (p_loc_sdp == 1) {
            }
            else if (p_loc_sdp == 2) {
                v_media.media_field.fmts := {PX_SIP_SDP_DYN}; // { "98", "0" };
                v_media.attributes := {
                    {
                        rtpmap := {
                            payload_type := PX_SIP_SDP_DYN,
                            codec := v_codecs[p_loc_codec - 1]
                        }
                    }
                };
            }
            else if (p_loc_sdp == 3) {
                v_media.media_field.fmts := {"8"};
            }
            else if (p_loc_sdp == 4) {
                v_media.media_field.fmts := {"99", "8"};
                v_media.attributes := {
                        {
                        rtpmap := {
                            payload_type := "99",
                            codec := v_codecs[p_loc_codec - 1]
                        }
                    }
                };
            }
            else if (p_loc_sdp == 5) {
                v_media.media_field.media := "image";
                v_media.media_field.transport := "udptl";
                v_media.media_field.fmts := {"t38"};
            }
            else if (p_loc_sdp == 6) {
                v_media.media_field.media := "image";
                v_media.media_field.transport := "tcptl";
                v_media.media_field.fmts := {"t38"};
            }
            else {
                log("*** " & __SCOPE__ & ": INFO: Unexpected SDP variant ***");
                setverdict(inconc);
            }

            return (v_media);
        }

        /**
         * @desc repare media/attribute lines
         */
        function f_prepare_SDP(
            integer p_loc_sdp,
            integer p_loc_codec
        ) runs on SipComponent  {

            vc_sdp_local.media_list := {f_prepare_media(p_loc_sdp, p_loc_codec)};
        }

        /**
         * @desc function that copy media/attribute lines from remote to local SDP variable
         */
        function f_prepare_SDP_answer(
        ) runs on SipComponent  {
            var integer v_mn, v_cn := 0, i, j, k := 0;
            var charstring v_PT;
            var SDP_attribute_rtpmap_codec v_rtpmap := { "", "", omit};
            var SDP_attribute_list v_mediaAttributes := {};
            // increase session version
            vc_sdp_local.origin.session_version := int2str(str2int(vc_sdp_remote.origin.session_version) + 1);
            // if more than one codec, select the firs one
            v_mn := lengthof(vc_sdp_remote.media_list);
            for (i := 0; i < v_mn; i := i + 1) {
                // for every single media
                if (isvalue(vc_sdp_remote.media_list[i].attributes)) {
                    v_cn := lengthof(vc_sdp_remote.media_list[i].attributes);
                }
                if (lengthof(vc_sdp_remote.media_list[i].media_field.fmts) > 0) {
                    // select the first one
                    v_PT := vc_sdp_remote.media_list[i].media_field.fmts[0];
                    vc_sdp_local.media_list[i].media_field.fmts := {v_PT};
                    for (j := 0; j < v_cn; j := j + 1) {
                        if (ischosen(vc_sdp_remote.media_list[i].attributes[j].rtpmap)) {
                            if (v_PT == vc_sdp_remote.media_list[i].attributes[j].rtpmap.payload_type) {
                                v_rtpmap := vc_sdp_remote.media_list[i].attributes[j].rtpmap.codec;
                                v_mediaAttributes[k] := {rtpmap := {v_PT, v_rtpmap}};
                                k := k + 1;
                            } // else line is not copied
                        }
                        else {
                            // simple copy of attribute
                            v_mediaAttributes[k] := vc_sdp_remote.media_list[i].attributes[j];
                            k := k + 1;
                        }
                    }
                    vc_sdp_local.media_list[i].attributes := v_mediaAttributes;

                    if (isvalue(vc_sdp_local.media_list[i].attributes)) {
                        v_cn := lengthof(vc_sdp_local.media_list[i].attributes);
                        for (j := 0; j < v_cn; j := j + 1) {
                            // simplified handling of status attributes (copy/keep status from peer):
                            // a) copy/keep SDP_attribute_curr (invert tags if applicable)
                            if (ischosen(vc_sdp_local.media_list[i].attributes[j].curr)) {
                                // invert local/remote status tags
                                if (vc_sdp_local.media_list[i].attributes[j].curr.statusType == "local") {
                                    vc_sdp_local.media_list[i].attributes[j].curr.statusType := "remote";
                                }
                                if (vc_sdp_local.media_list[i].attributes[j].curr.statusType == "remote") {
                                    vc_sdp_local.media_list[i].attributes[j].curr.statusType := "local";
                                }
                                // invert send/recv direction tags
                                if (vc_sdp_local.media_list[i].attributes[j].curr.direction == "send") {
                                    vc_sdp_local.media_list[i].attributes[j].curr.direction := "recv";
                                }
                                if (vc_sdp_local.media_list[i].attributes[j].curr.direction == "recv") {
                                    vc_sdp_local.media_list[i].attributes[j].curr.direction := "send";
                                }
                            }
                            else
                            if (
                                // b) copy/keep SDP_attribute_des (keep strength, invert tags if applicable)
                                ischosen(vc_sdp_local.media_list[i].attributes[j].des)
                            ) {
                                // invert local/remote status tags
                                if (vc_sdp_local.media_list[i].attributes[j].des.statusType == "local") {
                                    vc_sdp_local.media_list[i].attributes[j].des.statusType := "remote";
                                }
                                if (vc_sdp_local.media_list[i].attributes[j].des.statusType == "remote") {
                                    vc_sdp_local.media_list[i].attributes[j].des.statusType := "local";
                                }
                                // invert send/recv direction tags
                                if (vc_sdp_local.media_list[i].attributes[j].des.direction == "send") {
                                    vc_sdp_local.media_list[i].attributes[j].des.direction := "recv";
                                }
                                if (vc_sdp_local.media_list[i].attributes[j].des.direction == "recv") {
                                    vc_sdp_local.media_list[i].attributes[j].des.direction := "send";
                                }
                            }
                            else
                            if (
                                // c) simplification: assume no SDP_attribute_conf
                                ischosen(vc_sdp_local.media_list[i].attributes[j].conf)
                            ) {
                                // handle SDP_attribute_conf
                            }
                        }
                    }
                }
            }
        // add handling of prenegotiation, change ports if required etc.
        // if prenegotiation...
        }

        /**
         * @desc reject SDP offer by setting media ports to 0
         */
        function f_reject_SDP_offer(
        ) runs on SipComponent  {
            var integer mn, i;
            f_copy_SDP(); // TO BE DONE with more details!
            // increase session version
            vc_sdp_local.origin.session_version := int2str(str2int(vc_sdp_local.origin.session_version) + 1);
            // if more than one codec, select the firs one
            mn := lengthof(vc_sdp_local.media_list);
            for (i := 0; i < mn; i := i + 1) {
                vc_sdp_local.media_list[i].media_field.ports := {0, omit};
                vc_sdp_local.media_list[i].attributes := omit; // {};
            }
        }

        /**
         * @desc copies SDP message elements from remote to local component variable: - bandwidth - session version (will be incremented) - media list modify the direction attribute of an SDP media list entry within an SDP message (vc_sdp_local)
         * @param p_medianum list position number of the media (if value 0 identifies first media list element)
         * @param p_direction the new direction attribute to be included in the media entry
         * @verdict
         */
        function f_SIP_modMediaDirection(
            integer p_medianum,
            template(value) SDP_attribute p_direction
        ) runs on SipComponent  {
            var boolean v_set_direction;

            // flag indicates if direction attribute has been modified
            var integer v_mn := 0;

            // length of media list (number of entries)
            var integer v_cn := 0;

            // number of attributes of a media entry
            var integer i, j, k := 0;
            var SDP_attribute_list v_mediaAttributes := {};
            // collect the media attributes (to be assigned at end of function)
            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 := lengthof(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 (isvalue(vc_sdp_local.media_list))
                // media_list is optional
                {
                    // log("vc_sdp_local.media_list[i ] ",vc_sdp_local.media_list[i ] );
                    if (isvalue(vc_sdp_local.media_list[i].attributes)) {
                        v_cn := lengthof(vc_sdp_local.media_list[i].attributes);
                    }

                    v_set_direction := false;

                    // if (lengthof(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(value) SDP_attribute p_direction
        ) runs on SipComponent  {
            var boolean v_set_direction := false;
            var integer v_mn := 0, i := 0;

            if (isvalue(vc_sdp_local.attributes)) {
                v_mn := lengthof(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)) {
                        vc_sdp_local.attributes[i] := valueof(p_direction);
                        v_set_direction := true;
                    }
                }
                if (not v_set_direction)
                // if not sent before
                {
                    vc_sdp_local.attributes[v_mn] := valueof(p_direction);
                }
            }
            else {
                vc_sdp_local.attributes[0] := valueof(p_direction);
            }
        }

        /**
         * @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(value) SDP_attribute p_direction_in,
            template(value) SDP_attribute p_direction_out
        ) runs on SipComponent  {
            var template(value) SDP_attribute v_direction_out := p_direction_out;
            // check incoming SDP attribute
            if (not (isvalue(vc_request.messageBody) and (f_check_attribute(vc_request.messageBody.sdpMessageBody, p_direction_in)))) {
                if (match(valueof(p_direction_in), mw_attribute_sendrecv) and not (f_check_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_sendrecv) or f_check_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_sendonly) or f_check_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_recvonly) or f_check_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_inactive))) {
                    log("*** " &__SCOPE__& ": INFO: no direction attributes with expectation: ", p_direction_in, " ***");
                }
                else {
                    setverdict(fail);
                }
            }
            else {
                setverdict(pass);
                log("*** " &__SCOPE__& ": INFO: attribute found in message body ***");
            }
            if (not(isbound(p_direction_out)))
            // STF549 if (match(omit, p_direction_out))
            {
                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 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_checkResponsesetSDPreqDirection(
            template(value) SDP_attribute p_direction_in,
            template(value) SDP_attribute p_direction_out
        ) runs on SipComponent  {
            var template(value) SDP_attribute v_direction_out := p_direction_out;
            // check incoming SDP attribute
            if (not (isvalue(vc_response.messageBody) and (f_check_attribute(vc_response.messageBody.sdpMessageBody, p_direction_in)))) {
                if (match(valueof(p_direction_in), mw_attribute_sendrecv) and not (f_check_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_sendrecv) or f_check_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_sendonly) or f_check_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_recvonly) or f_check_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_inactive))) {
                    log("*** " &__SCOPE__& ": INFO: no direction attributes with expectation: ", p_direction_in, " ***");
                }
                else {
                    setverdict(fail);
                }
            }
            else {
                setverdict(pass);
                log("*** " &__SCOPE__& ": INFO: attribute found in message body ***");
            }
            if (not(isbound(p_direction_out)))
            // STF549 if (match(omit, p_direction_out))
            {
                v_direction_out := f_get_attribute_answer(vc_response.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 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_checksetSDPreqDirectionSession(
            template(value) SDP_attribute p_direction_in,
            template(value) SDP_attribute p_direction_out
        ) runs on SipComponent  {
            var template(value) SDP_attribute v_direction_out := p_direction_out;
            // check incoming SDP attribute
            if (not (isvalue(vc_request.messageBody) and (f_check_session_attribute(vc_request.messageBody.sdpMessageBody, p_direction_in)))) {
                if (match(valueof(p_direction_in), mw_attribute_sendrecv) and not (f_check_session_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_sendrecv) or f_check_session_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_sendonly) or f_check_session_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_recvonly) or f_check_session_attribute(vc_request.messageBody.sdpMessageBody, mw_attribute_inactive))) {
                    log("*** " &__SCOPE__& ": INFO: no direction attributes with expectation: ", p_direction_in, " ***");
                }
                else {
                    setverdict(fail);
                }
            }
            if (not(isbound(p_direction_out)))
            // STF549 if (match(omit, p_direction_out))
            {
                v_direction_out := f_get_attribute_answer(vc_request.messageBody.sdpMessageBody, p_direction_in);
            }
            f_SIP_modSessionDirection(v_direction_out); // handling of attribute in session
        }

        /*
     *
     * @desc check (from remote) and set (local) the session 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_checkResponsesetSDPreqDirectionSession(
            template(value) SDP_attribute p_direction_in,
            template(value) SDP_attribute p_direction_out
        ) runs on SipComponent  {
            var template(value) SDP_attribute v_direction_out := p_direction_out;
            // check incoming SDP attribute
            if (not (isvalue(vc_response.messageBody) and (f_check_session_attribute(vc_response.messageBody.sdpMessageBody, p_direction_in)))) {
                if (match(valueof(p_direction_in), mw_attribute_sendrecv) and not (f_check_session_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_sendrecv) or f_check_session_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_sendonly) or f_check_session_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_recvonly) or f_check_session_attribute(vc_response.messageBody.sdpMessageBody, mw_attribute_inactive))) {
                    log("*** " &__SCOPE__& ": INFO: no direction attributes with expectation: ", p_direction_in, " ***");
                }
                else {
                    setverdict(fail);
                }
            }
            if (not(isbound(p_direction_out)))
            // STF549 if (match(omit, p_direction_out))
            {
                v_direction_out := f_get_attribute_answer(vc_response.messageBody.sdpMessageBody, p_direction_in);
            }
            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 (isvalue(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 := lengthof(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 (isvalue(vc_sdp_remote.media_list[i].attributes)) {
                    v_cn := lengthof(vc_sdp_remote.media_list[i].attributes);
                }
                if (lengthof(vc_sdp_remote.media_list[i].attributes) > 0) {
                    // select the first one
                    for (j := 0; j < lengthof(vc_sdp_remote.media_list[i].attributes); j := j + 1) {
                        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;
                            }
                        }
                    }
                }
            }
            return v_result;
        }

        /**
         * @desc copy media/attribute lines from remote to local SDP variable
         */
        function f_copy_SDP(
        ) runs on SipComponent  {
            if (isvalue(vc_sdp_remote.connection)) {
                vc_sdp_local.connection := vc_sdp_remote.connection;
            }
            else {
                vc_sdp_local.connection := omit;
            }

            vc_sdp_local.origin := vc_sdp_remote.origin;
            vc_sdp_local.session_name := vc_sdp_remote.session_name;

            if (isvalue(vc_sdp_remote.bandwidth)) {
                vc_sdp_local.bandwidth := vc_sdp_remote.bandwidth;
            }
            else {
                vc_sdp_local.bandwidth := {};
            }

            if (isvalue(vc_sdp_remote.media_list)) {
                // // cleaning of media before assignment
                // if (isvalue(vc_sdp_local.media_list))
                // {
                //                      for (var integer i:=0; i<lengthof(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 for time delay
         */
        function f_awaitingDelayTimer(
            float p_delay
        ) runs on SipComponent  {
            tc_tDelay.start(p_delay);
            alt {
                [] tc_tDelay.timeout {
                    setverdict(pass);
                }
            }
        } // end f_awaitingDelayTimer

        /**
         * @desc Function waiting for any MSG -request/response
         */
        function f_awaitingAnyPassOnTimeout(
        ) runs on SipComponent  {
            tc_wait.start(PX_SIP_TWAIT);
            alt {
                [] SIPP.receive
                {
                    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