denKAFManagement.cpp

Go to the documentation of this file.

#include "include/denKAFManagement.h"

denKAFManagement::denKAFManagement(FakeGPSProvider *gps, FakeApplicationProvider *appli, GeoNet *gn)
{
    m_paramGPS = gps;
    m_paramAppli = appli;
    m_geonet = gn;

    m_mutexForwarding = new QMutex;
}

denKAFManagement::~denKAFManagement(){}

//void denKAFManagement::execute(){while(true);}

void denKAFManagement::utInitialize()
{
    printf("UtInitialize KAF %d\n", m_forwardingDENM.size());
    QMutexLocker locker(m_mutexForwarding);
    killForwardingThreads();
    m_forwardingDENM.clear();
}

void denKAFManagement::killForwardingThreads()
{
    for(int i = 0 ; i < m_forwardingDENM.size() ; i++)
    {
        m_forwardingDENM[i]->m_validity->setTimer(-1);;
        m_forwardingDENM[i]->m_forwarding->setTimer(-1);
    }
}

void denKAFManagement::kaf(DENM_t *denm)
{
    qDebug() << "KAF beginning";
    /* 1) Check if the transmissionInterval exists in received DENM. */
    /*    a. If yes, continue the operation. */
    if(!denm->denm.management.transmissionInterval)
        /* b. Otherwise, omit execution of further steps. */
        return;

    int found = haveDENM(denm->denm.management.actionID, m_forwardingDENM);
    denMessageTableForwarding *entry;
    bool newEntry = false;

    if(found >= 0)
    {
        entry = m_forwardingDENM[found];

        /* 2) Check if the referenceTime of the received DENM is equal or greater than the referenceTime value of the
         *    DENM entry in the forwarding ITS-S message table of the same actionID. */
        DENM_t tableDENM = entry->denm();;
        quint64 tableReferenceTime, receivedReferenceTime;
        asn_INTEGER2ulong((INTEGER_t*)&denm->denm.management.referenceTime, (long unsigned int*)&receivedReferenceTime);
        asn_INTEGER2ulong((INTEGER_t*)&tableDENM.denm.management.referenceTime, (long unsigned int*)&tableReferenceTime);

        /* 2) a. if the received referenceTime is equal to the entry referenceTime, start/restart T_F_Forwarding and omit
         *       execution of furether steps. */
        if(receivedReferenceTime == tableReferenceTime)
        {
            if(entry->m_forwarding)
            {
                qDebug() << "62 start";
                entry->m_forwarding->m_T_Forwarding_timer.start();
                return;
            }
        }
        /* 2) b. if the received referenceTime is less than the entry referenceTime, discard the received DENM and omit
         *       execution of further steps. */
        if(receivedReferenceTime < tableReferenceTime)
        {
            m_forwardingDENM.removeAt(found);
            return;
        }
    }
    else
    {
        newEntry = true;
        entry = new denMessageTableForwarding(m_paramGPS);
        entry->setActionID(denm->denm.management.actionID);
        entry->moveToThread(entry->m_thread);
        entry->setDENM(*denm);
        m_forwardingDENM.append(entry);
        found = haveDENM(denm->denm.management.actionID, m_forwardingDENM);
        QObject::connect(m_forwardingDENM[found], SIGNAL(T_F_ValiditySignal(ActionID_t)), this, SLOT(discardDENMFromForwardingTable(ActionID_t)));
        QObject::connect(m_forwardingDENM[found], SIGNAL(T_ForwardingSignal(ActionID_t)), this, SLOT(repeatDENMFromForwardingTable(ActionID_t)));
    }

    /* 2) c. Otherwise, continue the operation. */

    /* 3) Calculate expiration time of timer T_F_Validity. */
    qint64 validity = -1;
    quint64 detectionTime;
    asn_INTEGER2ulong((INTEGER_t*)&denm->denm.management.detectionTime, (long unsigned int*)&detectionTime);
    if(denm->denm.management.validityDuration)
        validity = m_paramGPS->timestamp() - detectionTime + ((*denm->denm.management.validityDuration) * 1000);
    /* 3) a. if timer T_Forwarding is set to invalid value, omit execution of further steps. */
    if(validity < 0)
        return;
    /* 3) b. Otherwise, continue the operation. */

    /* 4) Calculate timeout value for timer T_Forwarding. */
    qint64 forwarding = -1;
    if(denm->denm.management.transmissionInterval)
    {
        forwarding = 2 * *denm->denm.management.transmissionInterval + (qrand() % 151);
        if(forwarding > validity)
            forwarding = validity;
    }
    /* 4) a. if timer T_Forwarding is set to invalid value, omit exection of further steps. */
    if(forwarding < 0)
        return;
    /* 4) b. Otherwise, continue the operation. */

    /* 5) Start/restart timer T_F_Validity and T_Forwarding */
    if(newEntry)
    {
        m_forwardingDENM[found]->setT_F_Validity(validity);
        m_forwardingDENM[found]->setT_Forwarding(forwarding);
        m_forwardingDENM[found]->moveToThread(m_forwardingDENM[found]->m_thread);
        m_forwardingDENM[found]->m_thread->start();
    }
    else
    {
        m_forwardingDENM[found]->m_validity->setTimer(validity);
        m_forwardingDENM[found]->m_validity->m_T_F_Validity_timer.start();
        m_forwardingDENM[found]->m_forwarding->setTimer(forwarding);
        m_forwardingDENM[found]->m_forwarding->m_T_Forwarding_timer.start();
    }


    /* 6) Reconstruct DENM by replacing the ITS PDU header. */
    denm->header.stationID = m_paramAppli->data().stationID();
    char encode[MSG_LENGTH] = {'\0'};
    asn_enc_rval_t rval = uper_encode_to_buffer(&asn_DEF_DENM, denm, encode, MSG_LENGTH);
    if(rval.encoded < 1)
    {
        qDebug() << "Unable to encode KAFed DENM";
        return;
    }

    /* 7) Update DENM entry in forwarding ITS-S message table. */
    m_forwardingDENM[found]->setEncodedDENM(QByteArray(encode, (rval.encoded + 7) / 8));

    /* 8) End. */
//    m_forwardingDENM[found]->m_thread->start();
}

void denKAFManagement::repeatDENMFromForwardingTable(ActionID_t actionID)
{
    qDebug() << "Forward DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber;
    QMutexLocker locker(m_mutexForwarding);
    int found = haveDENM(actionID, m_forwardingDENM);

    if(found < 0)
    {
        qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber <<
                    "not found in the received message table";
        return;
    }

    DENM_t denm = m_forwardingDENM[found]->denm();
    AppDenmTriggerData data(denm, DestinationAreaData(denm.denm.management.eventPosition));
    if(!PassDenmToNetworkAndTransportLayerTrigger(data, m_forwardingDENM[found]->encodedDENM()))
    {
        qDebug() << "Unable to pass DENM to N&T";
        return;
    }
}

void denKAFManagement::discardDENMFromForwardingTable(ActionID_t actionID)
{
    QMutexLocker locker(m_mutexForwarding);
    int found = haveDENM(actionID, m_forwardingDENM);

    if(found < 0)
    {
        qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber <<
                    "not found in the received message table";
        return;
    }
    if(m_forwardingDENM[found]->m_forwarding)
    {
        m_forwardingDENM[found]->m_forwarding->setTimer(-1);
    }
    if(m_forwardingDENM[found]->m_validity)
    {
        m_forwardingDENM[found]->m_validity->setTimer(-1);
    }
    m_forwardingDENM.removeAt(found);
}

bool denKAFManagement::PassDenmToNetworkAndTransportLayerTrigger(AppDenmTriggerData data, QByteArray payload)
{
    gnDataRequest_t dr = gnDataRequestFromAppDenmTriggerData(data, m_paramGPS->data());

    dr.payload = payload;

    int foo;
    if((foo = m_geonet->send(dr)) != GeoNet::geonetError_success)
    {
        qDebug() << "error " << foo;
        return false;
    }
    return true;
}