LibItsGeoNetworking_Functions.ttcn

         */
        function f_getAppMaxRetrans() return integer {
            var integer v_itsGnApplicationMaxRetrans := PX_GN_APPLICATION_MAX_RETRANS;
            
            return v_itsGnApplicationMaxRetrans;
        }
        
        /**
         * @desc    Gets the Location Service packet buffer size.
         * @return  Location Service packet buffer size in Kbytes
         * @see     PICS_GN_LOCATION_SERVICE_PACKET_BUFFER_SIZE
         */
        function f_getLsPacketBufferSize() return integer {
            var integer v_itsGnLocationServicePacketBufferSize := PICS_GN_LOCATION_SERVICE_PACKET_BUFFER_SIZE;
            
            return v_itsGnLocationServicePacketBufferSize;
        } // end f_getLsPacketBufferSize
        
        /**
         * @desc    Gets the UC forwarding packet buffer size.
         * @return  UC forwarding packet buffer size in Kbytes
         * @see     PICS_GN_UC_FORWARDING_PACKET_BUFFER_SIZE
         */
        function f_getUcForwardingPacketBufferSize() return integer {
            var integer v_itsGnUcForwardingPacketBufferSize := PICS_GN_UC_FORWARDING_PACKET_BUFFER_SIZE;
            
            return v_itsGnUcForwardingPacketBufferSize;
        } // end f_getUcForwardingPacketBufferSize
        
        /**
         * @desc    Gets the BC forwarding packet buffer size.
         * @return  BC forwarding packet buffer size in Kbytes
         * @see     PICS_GN_BC_FORWARDING_PACKET_BUFFER_SIZE
         */
        function f_getBcForwardingPacketBufferSize() return integer {
            var integer v_itsGnBcForwardingPacketBufferSize := PICS_GN_BC_FORWARDING_PACKET_BUFFER_SIZE;
            
            return v_itsGnBcForwardingPacketBufferSize;
        } // end f_getBcForwardingPacketBufferSize
        
        /**
         * @desc    Gets the maximum lifetime of a packet.
         * @return  Maximum lifetime of a packet in seconds
         * @see     PICS_GN_MAX_PACKET_LIFETIME
         */
        function f_getMaxPacketLifeTime() return float {
            var float v_itsGnMaxPacketLifetime := int2float(PICS_GN_MAX_PACKET_LIFETIME);
            
            return v_itsGnMaxPacketLifetime;
        }
        
        /**
         * @desc    Gets delta for timers.
         * @return  Delta for timers in seconds
         * @see     PX_T_DELTA
         */
        function f_getDeltaTimer() return float {
            var float v_deltaTimer := PX_T_DELTA;
            
            return v_deltaTimer;
        }
        
        /**
         * @desc Gets the beacon service retransmit timer.
         * @return  Beacon service retransmit timer
         */
        function f_getBsRetransmitTimer() return float {
            var float v_itsGnBeaconServiceRetransmitTimer;
            
            v_itsGnBeaconServiceRetransmitTimer := int2float(
                (PICS_GN_BEACON_SERVICE_RETRANSMIT_TIMER/1000));
            
            return v_itsGnBeaconServiceRetransmitTimer;
        }
        
        /**
         * @desc    Gets the beacon service retransmit timer for NetBeaconInterval = medium (cong. ctrl).
         * @return  Beacon service retransmit timer (medium)
         */
        function f_getBsRetransmitTimerMedium() return float {
            var float v_itsGnBeaconServiceRetransmitTimerMedium; // timer value increased (medium)
            
            v_itsGnBeaconServiceRetransmitTimerMedium := int2float(
                (PX_GN_BEACON_SERVICE_TIMER_MEDIUM+float2int((f_getBsMaxJitter() - 0.0 +1.0)*rnd()) + 0)/1000);
            
            return v_itsGnBeaconServiceRetransmitTimerMedium;
        }
        
        /**
         * @desc    Gets the beacon service retransmit timer for NetBeaconInterval = maximum (cong. ctrl).
         * @return  Beacon service retransmit timer (maximum)
         */
        function f_getBsRetransmitTimerMaximum() return float {
            var float v_itsGnBeaconServiceRetransmitTimerMaximum; // timer value increased (maximum)
            
            v_itsGnBeaconServiceRetransmitTimerMaximum := int2float(
                (PX_GN_BEACON_SERVICE_TIMER_MAXIMUM+float2int((f_getBsMaxJitter() - 0.0 +1.0)*rnd()) + 0)/1000);
            
            return v_itsGnBeaconServiceRetransmitTimerMaximum;
        }
        
        /**
         * @desc    Gets the maximum beacon service jitter.
         * @return  Maximum beacon service jitter
         */
        function f_getBsMaxJitter() return float {
            var float v_itsGnBeaconServiceMaxJitter := int2float(PICS_GN_BEACON_SERVICE_MAX_JITTER)/1000.0;
            
            return v_itsGnBeaconServiceMaxJitter;
        }
        
        /**
         * @desc    Gets the Lifetime of a Location Table Entry.
         * @return  Lifetime of a Location Table Entry in seconds
         * @see     PICS_GN_LIFETIME_LOC_TE
         */
        function f_getLifetimeLocTableEntry() return float {
            var float v_itsGnLifetimeLocTableEntry := int2float(PICS_GN_LIFETIME_LOC_TE);
            
            return v_itsGnLifetimeLocTableEntry;
        } // end f_getLifetimeLocTableEntry
        
        /**
         * @desc    Gets the maximum communication range for CBF algorithm
         * @return  Maximum communication range for CBF algorithm in meters
         * @see     PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE
         */
        function f_getCbfMaxCommunicationRange() return integer {
            var integer v_maxCommunicationRange := PICS_GN_DEFAULT_MAX_COMMUNICATION_RANGE;
            
            return v_maxCommunicationRange;
        } // end f_getCbfMaxCommunicationRange
        
        function f_getGeoUnicastCbfMaxTime() return integer {
            var integer v_cbfMaxTime := PICS_GN_GEOUNICAST_CBF_MAX_TIME;
            
            return v_cbfMaxTime;
        } // end f_getGeoUnicastCbfMaxTime
        
        function f_getGeoUnicastCbfMinTime() return integer {
            var integer v_cbfMinTime := PICS_GN_GEOUNICAST_CBF_MIN_TIME;
            
            return v_cbfMinTime;
        } // end f_getGeoUnicastCbfMinTime
        
        function f_getGeoBroadcastCbfMaxTime() return integer {
            var integer v_cbfMaxTime := PICS_GN_GEOBROADCAST_CBF_MAX_TIME;
            
            return v_cbfMaxTime;
        } // end f_getGeoBroadcastCbfMaxTime
        
        function f_getGeoBroadcastCbfMinTime() return integer {
            var integer v_cbfMinTime := PICS_GN_GEOBROADCAST_CBF_MIN_TIME;
            
            return v_cbfMinTime;
        } // end f_getGeoBroadcastCbfMinTime
        
        function f_getGnMaxAreaSize() return float {
            var float v_maxAreaSize := PICS_GN_MAX_GEO_AREA_SIZE;
            
            return v_maxAreaSize;
        } // end f_getGnMaxAreaSize
        
        function f_getAdvancedGbcForwardingMaxCounter() return integer {        
            var integer v_maxCounter := PICS_GN_ADVANCED_BC_FORWARDING_MAX_COUNTER;
            
            return v_maxCounter;  
        }
        
        /**
         * @desc    Set the number of neighbour in the Location Table.
         * @see     PX_MIN_NR_NEIGHBOUR
         */
        function f_setNrNeighbourLocTableDefault() runs on ItsGeoNetworking {
            var integer v_nrNeighbour := f_random (0, PX_MIN_NR_NEIGHBOUR);
            
            f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
            
        } // end f_setNrNeighbourLocTableDefault
        
        /**
         * @desc    Set the number of neighbour in the Location Table (medium).
         * @see     PX_MIN_NR_NEIGHBOUR
         * @see     PX_MAX_NR_NEIGHBOUR
         */
        function f_setNrNeighbourLocTableMedium() runs on ItsGeoNetworking {
            var integer v_nrNeighbour := f_random (PX_MIN_NR_NEIGHBOUR, PX_MAX_NR_NEIGHBOUR);
            
            f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
            
        } // end f_setNrNeighbourLocTableMedium
        
        /**
         * @desc    Set the number of neighbour in the Location Table (maximum).
         * @see     PX_MAX_NR_NEIGHBOUR
         * @see     PX_MIN_NR_NEIGHBOUR
         */
        function f_setNrNeighbourLocTableMaximum() runs on ItsGeoNetworking {
            var integer v_nrNeighbour := f_random (PX_MAX_NR_NEIGHBOUR, (2*PX_MIN_NR_NEIGHBOUR));
            
            f_acStartBeaconingMultipleNeighbour(v_nrNeighbour);
            
        } // end f_setNrNeighbourLocTableMaximum
                
    } // end iutFunctions
    
    group posVectorFunctions {
        
        /**
         * @desc    Convert long position vector to short position vector
         * @param   p_longPosVector Long position vector to be converted
         * @return  Short position vector
         */
        function f_longPosVector2ShortPosVector(in LongPosVector p_longPosVector) return ShortPosVector {
            var ShortPosVector v_shortPosVector;
            
            v_shortPosVector := {
                gnAddr := p_longPosVector.gnAddr,
                timestamp := p_longPosVector.timestamp,
                latitude := p_longPosVector.latitude,
                longitude := p_longPosVector.longitude
            };
            
            return v_shortPosVector;
        }
        
        /**
         * @desc    Get IUT's long position vector
         * @return  IUT's long position vector
         */
        function f_getIutLongPosVector() runs on ItsBaseGeoNetworking return LongPosVector {
            return f_acGetLongPosVector(f_getIutGnLocalAddress());
        }
        
        /**
         * @desc    Get IUT's short position vector
         * @return  IUT's short position vector
         */
        function f_getIutShortPosVector() runs on ItsGeoNetworking return ShortPosVector {
            var LongPosVector v_longPosVectorIut := f_getPosition(c_compIut);
            
            if (not isbound(v_longPosVectorIut)) {
                v_longPosVectorIut := f_getIutLongPosVector();
            }
            return f_longPosVector2ShortPosVector(v_longPosVectorIut);
        }
        
        /**
         * @desc    Compute a position using a reference position, a distance and an orientation
         * @param   p_iutLongPosVector Reference position
         * @param   p_distance Distance to the reference position (in meter)
         * @param   p_orientation direction of the computed position (0 to 359; 0 means North)
         * @return  LongPosVector
         */
        function f_computePositionUsingDistance(in LongPosVector p_iutLongPosVector, in integer p_distance, in integer p_orientation)
        return LongPosVector {
            var LongPosVector v_result := p_iutLongPosVector;
            
            log("*** f_computePositionUsingDistance: INFO: calling fx_computePositionUsingDistance() ***");
            fx_computePositionUsingDistance(p_iutLongPosVector.latitude, p_iutLongPosVector.longitude, p_distance, p_orientation, v_result.latitude, v_result.longitude);
            
            return v_result;
        }
        
    } // end posVectorFunctions
    
    group externalFunctions {
        
        /**
         * @desc    External function to compute timestamp based on current time
         * @return  Unix-Epoch-Time mod 2^32
         */
        external function fx_computeGnTimestamp() return UInt32;
    }

    group security {
        /**
         * @desc    Waiting for the GN message with Security
         * @param   p_InSecMsg  SecurityMessage template 
         * @param   p_received  returns received SecurityMessage 
         */
        altstep a_securedMessage (
            in template (present) SecuredMessage p_InSecMsg,
            out SecuredMessage p_received
        ) runs on ItsGeoNetworking {
            var GeoNetworkingInd v_geoNw;
            [] geoNetworkingPort.receive(mw_geoNwInd(
                                            mw_geoNwSecPdu(
                                                p_InSecMsg,
                                                mw_geoNwAnyPacket_withPayload(?)
                                        ))) -> value (v_geoNw) {
                    p_received := f_getSecuredMessage(v_geoNw.msgIn);
            }
        }
        
        /**
         * @desc         Receive GN message with security containing certificate as a signer info
         * @param p_cert returns the certificate used for sign received message
         */
        altstep a_securedMessageWithCertificate (
            out SecuredMessage p_received
        ) runs on ItsGeoNetworking {
            var SecuredMessage v_secMsg;
            []a_securedMessage (
                mw_securedMessage (superset(mw_header_field_signer_info_certificate)),
                p_received
            ) {}
        }

        /**
         * @desc         Receive GN message with security containing certificate chain as a signer info
         * @param p_cert returns the certificate used for sign received message
         */
        altstep a_securedMessageWithCertificateChain (
            out SecuredMessage p_received
        ) runs on ItsGeoNetworking {
            var SecuredMessage v_secMsg;
            []a_securedMessage (
                mw_securedMessage (superset(mw_header_field_signer_info_certificate_chain)),
                p_received
            ) {}
        }

        /**
         * @desc         Receive GN message with security containing digest as a signer info
         * @param p_cert returns the certificate used for sign received message
         */
        altstep a_securedMessageWithDigest (
            out SecuredMessage p_received
        ) runs on ItsGeoNetworking {
            []a_securedMessage (
                mw_securedMessage (superset(mw_header_field_signer_info_certificate)), 
                p_received
            ) {}
        }

    }// End of group altSteps
    
    group waitingHelpers {
        
        /**
         * @desc  Wait for GN message with security containing certificate as a signer info
         * @return the certificate used for sign received message
         */
        function f_waitForCertificate (out Certificate p_cert)
        runs on ItsGeoNetworking
        return boolean {
            var SecuredMessage v_recv;
            var boolean v_ret := false;
            alt {
                [] a_securedMessageWithCertificate(v_recv){
                    var SignerInfo v_si;
                    if(f_getMsgSignerInfo(v_recv, v_si)){ 
                        p_cert :=  v_si.signerInfo.certificate;
                        v_ret := true;
                    }
                }
            }
            return v_ret;
        }
        
        /**
         * @desc  Wait for GN message with security containing certificate chain as a signer info
         * @return the certificate used for sign received message
         */
        function f_waitForCertificateChain (out CertificateChain p_chain)
        runs on ItsGeoNetworking
        return boolean {
            var SecuredMessage v_recv;
            var boolean v_ret := false;
            alt {
                [] a_securedMessageWithCertificateChain(v_recv){
                    var SignerInfo v_si;
                    if(f_getMsgSignerInfo(v_recv, v_si)){
                        p_chain :=  v_si.signerInfo.certificates;
                        v_ret := true;
                    }
                }
            }
            return v_ret;
        }

        /**
         * @desc  Ask for the certificate chain and wait for GN message with security containing certificate chain as a signer info
         * @return the certificate chain used for sign received message
         */
        function f_askForCertificateChain (in template(value) octetstring p_CamPayload)
        runs on ItsGeoNetworking
        return boolean {
            var SecuredMessage v_recv;
            var SignerInfo     v_si;
            var boolean v_ret := false;
            alt {
                [] a_securedMessageWithCertificate(v_recv) {
                    if(f_getMsgSignerInfo(v_recv, v_si)) {
                        if(f_getCertificateSignerInfo(v_si.signerInfo.certificate, v_si)) {
                            if(match (v_si.type_, e_certificate_digest_with_ecdsap256)) {
                                f_sendCertificateRequest(v_si.signerInfo.digest, p_CamPayload);
                                if(tc_ac.running){
                                    tc_ac.stop;tc_ac.start;
                                }
                                v_ret := true;
                            }
                        }
                    }
                }
            }
            return v_ret;
        }
        /**
         * @desc  Ask for the certificate chain and wait for GN message with security containing certificate chain as a signer info
         * @return the certificate chain used for sign received message
         */
        function f_askAndWaitForCertificateChain (out CertificateChain p_chain, in template(value) octetstring p_CamPayload)
        runs on ItsGeoNetworking
        return boolean {
            var SecuredMessage v_recv;
            var SignerInfo     v_si;
            var boolean v_ret := false;
            alt {
                [] a_securedMessageWithCertificate(v_recv) {
                    if(f_getMsgSignerInfo(v_recv, v_si)) {
                        if(f_getCertificateSignerInfo(v_si.signerInfo.certificate, v_si)) {
                            if(match (v_si.type_, e_certificate_digest_with_ecdsap256)) {
                                f_sendCertificateRequest(v_si.signerInfo.digest, p_CamPayload);
                                if(tc_ac.running){
                                    tc_ac.stop;tc_ac.start;
                                }
                                repeat;
                            }
                        }
                    }
                }
                [] a_securedMessageWithCertificateChain(v_recv){
                    if(f_getMsgSignerInfo(v_recv, v_si)){
                        p_chain := v_si.signerInfo.certificates;
                        v_ret := true;
                    } 
                }
            }
            return v_ret;
        }
        
        
        /**
         * @desc  Wait for GN message with security containing digest as a signer info
         * @return the digest of the certificate been used to sign received message
         */
        function f_waitForDigest ( out HashedId8 p_digest)
        runs on ItsGeoNetworking
        return boolean {
            var SecuredMessage v_recv;
            var boolean v_ret := false;
            alt {
                [] a_securedMessageWithDigest(v_recv){
                    var SignerInfo v_si;
                    if(f_getMsgSignerInfo(v_recv, v_si)) { 
                        p_digest :=  v_si.signerInfo.digest;
                        v_ret := true;
                    }
                }
            }
            return v_ret;
        }
        
    } // End of group waitingHelpers
        
    group CertRequests{
        
        function f_sendCertificateRequest (
                                      in template (value) HashedId8 p_digest,
                                      in template (value) octetstring p_payload
        )
        runs on ItsGeoNetworking
        {
            var GeoNetworkingReq v_gnReq;
            var GnNonSecuredPacket v_gnNonSecuredPacket;
            var template (value) ToBeSignedSecuredMessage v_toBeSignedSecuredMessage;
            var template (value) SecuredMessage v_securedMessage;
                
            // Build signed SecuredMessage
            v_gnNonSecuredPacket := m_geoNwShbPacket(
                f_getPosition(c_compMTC)
            );
            // Add CAM payload
            v_gnNonSecuredPacket.payload := f_adaptPayload_m(p_payload);

            f_buildGnSecuredCam(
                v_securedMessage,
                bit2oct(encvalue(v_gnNonSecuredPacket)),
                true,
                { m_header_field_digest(f_HashedId3FromHashedId8(p_digest)) } 
            );
                
            // Build secured Gn packet
            v_gnReq := m_geoNwReq_linkLayerBroadcast(
                m_geoNwSecPdu(
                    v_gnNonSecuredPacket,
                    v_securedMessage
                ) // End of template m_geoNwSecPdu
            ); // End of template m_geoNwReq_linkLayerBroadcast
            
            // Send Message
            f_sendGeoNetMessage(v_gnReq);
            
        } // End of function f_sendCertificateRequest
        
    } // End of group CertRequests 
    
    group messageGetters {
        
        /**
         * @desc    return SecuredMessage field of GeoNetworking packet 
         * @param   p_msg GeoNetworking packet
         * @return  the SecuredMessage if any
         */
        function f_getSecuredMessage(in GeoNetworkingPdu p_msg)
        return SecuredMessage {
            return p_msg.gnPacket.securedMsg;
        }
        
    }
    
} // end LibItsGeoNetworking_Functions