denReceptionManagement.cpp

Go to the documentation of this file.

#include "denReceptionManagement.h"

denReceptionManagement::denReceptionManagement(FakeGPSProvider *gps, FakeApplicationProvider *appli, ParameterDENM *denm,
                                               GeoNet *gn, ParameterConfiguration *conf, FakeCANProvider *can,
                                               ParameterNetwork *network)
{
    m_paramGPS = gps;
    m_paramAppli = appli;
    m_paramDENM = denm;
    m_geonet = gn;
    m_paramConf = conf;
    m_paramCan = can;
    m_mutexReception = new QMutex;

    m_sequenceNumber = 0;
    denm2app = new QUdpSocket(this);
    denm2app->bind();
    network->addPort("DENMReceptionManagement", denm2app->localPort());
    quint16 port = network->denmDestinationPort(), portInfo = network->denmDestinationPortInfo();
    appPort = network->internalPort("Application");


    m_internalSocket = new QUdpSocket(this);
    m_internalSocket->bind();
    network->addBTPPort(port, portInfo, m_internalSocket->localPort());
    qDebug() << network->internalBTPPort(port, portInfo);
    QObject::connect(m_internalSocket, SIGNAL(readyRead()), this, SLOT(readDatagram()));
}

denReceptionManagement::~denReceptionManagement()
{
    denm2app->close();
    m_internalSocket->close();
}

void denReceptionManagement::utInitialize()
{
    printf("UtInitialize reception %d\n", m_receivedDENM.count());
    QMutexLocker locker(m_mutexReception);
    killReceptionThreads();
    m_receivedDENM.clear();
    m_sequenceNumber = 0;
}

void denReceptionManagement::killReceptionThreads()
{
    for(int i = 0 ; i < m_receivedDENM.size() ; i++)
    {
        m_receivedDENM[i]->m_reception->setTimer(-1);
    }
}
void denReceptionManagement::setSequenceNumberSlot(quint16 sequenceNumber)
{
    m_sequenceNumber = sequenceNumber;
}

//void denReceptionManagement::execute(){}

void denReceptionManagement::readDatagram()
{
    QNetworkDatagram data;

    while(m_internalSocket->hasPendingDatagrams())
    {
        qDebug() << "Receiving DENM";
        data = m_internalSocket->receiveDatagram();

        decodeDenm(data.data());
    }

}

void denReceptionManagement::decodeDenm(QByteArray data)
{
    DENM_t *d = 0;
    asn_dec_rval_t rval;

    rval = uper_decode_complete(NULL, &asn_DEF_DENM, (void**)&d, data.data(), data.length());

    if(rval.code == RC_OK)
    {
        if(d->header.protocolVersion != protocolVersion_currentVersion)
        {
            fprintf(stderr, "DENM received has wrong protocol version: %ld instead of %d\n", d->header.protocolVersion, protocolVersion_currentVersion);
            return;
        }

        if(d->header.messageID != messageID_denm)
        {
            fprintf(stderr, "DENM received has wrong message ID: %ld instead of %d\n", d->header.messageID, messageID_denm);
            return;
        }

        printf("DENM decoded :\n");
        asn_fprint(stdout, &asn_DEF_DENM, d);

        denmReception(d);

        qDebug() << "New received DENM added size" << m_receivedDENM.size();

    }
}

void denReceptionManagement::denmReception(DENM_t * denm)
{
    /* 1) Calculate expiration time for timer T_R_Validity */
    quint64 receivedDetectionTime;
    quint64 expiration;
    quint32 validity = denm->denm.management.validityDuration ? *denm->denm.management.validityDuration : DefaultValidity;
    asn_INTEGER2ulong((INTEGER_t*)&denm->denm.management.detectionTime, (long unsigned int*)&receivedDetectionTime);
    expiration = receivedDetectionTime + validity * 1000;
    QMutexLocker locker(m_mutexReception);

    /* 1) a. If the expiration time is in the past, discard the received DENM and omit execution of further steps. */
    if(expiration < m_paramGPS->timestamp())
    {
        qDebug() << "Received DENM is expired expiration =" << expiration << "now = " << m_paramGPS->timestamp()
                 << "diff =" << (qint64)(expiration - m_paramGPS->timestamp()) << "received =" << receivedDetectionTime
                 << "validity =" << validity;
        int found = haveDENM(denm->denm.management.actionID, m_receivedDENM);
        if(found >= 0)
            discardDENM(found);
        return;
    }

    /* 1) b. Otherwise, continue the operation. */

    /* 2) Lookup entries in the receiving ITS-S message table with the received actionID. */
    ActionID_t actionID = denm->denm.management.actionID;
    int found = haveDENM(actionID, m_receivedDENM);

    if(found < 0)
    {
        /* 2) a. If entry does not exist in the receiving ITS-S message table, check if termination data exists in the
         *       received DENM: */
        if(denm->denm.management.termination)
        {
            /* 2) a. i. If yes, discard the received DENM and omit execution of further steps. */
            qDebug() << "Received DENM is a terminated DENM of an unknown DENM";
            return;
        }
        /* 2) a. ii. Otherwise, check SSP and CauseCode if available: */
        /* TODO: Check SSP consistancy. */
        /* 2) a. ii. 2. Otherwise create an entry in the receiving ITS-S message table with the received DENM and
         *              set the state to ACTIVE. */
        denMessageTableReception* entry = new denMessageTableReception();

        entry->setActionID(actionID);
        entry->setDENM(*denm);
        entry->m_reception = new denMessageTableReceptionThread(expiration);

        entry->setT_R_Validity(-1);
        entry->moveToThread(entry->m_thread);
        entry->m_thread->start();
        qDebug() << "145 thread start";
        m_receivedDENM.append(entry);

        found = haveDENM(actionID, m_receivedDENM);
        qDebug() << "New received DENM added size" << m_receivedDENM.size();
    }
    else
    {
        /* 2) b. If entry does exist, in the receiving ITS-S message table, check if the received referenceTime is less than
         *       the entry referenceTime, or the received detectionTime is less than the entry detectionTime. */
        quint64 receivedReferenceTime, tableDetectionTime, tableReferenceTime;
        DENM_t tableDenm = m_receivedDENM.at(found)->denm();
        asn_INTEGER2ulong((INTEGER_t*)&denm->denm.management.referenceTime, (long unsigned int*)&receivedReferenceTime);
        asn_INTEGER2ulong((INTEGER_t*)&tableDenm.denm.management.detectionTime, (long unsigned int*)&tableDetectionTime);
        asn_INTEGER2ulong((INTEGER_t*)&tableDenm.denm.management.referenceTime, (long unsigned int*)&tableReferenceTime);
        if(receivedReferenceTime < tableReferenceTime || receivedDetectionTime < tableDetectionTime)
        {
            /* 2) b. i. If yes, discard the received DENM and omit execution of further steps. */
            qDebug() << "Received DENM has wrong detectionTime or referenceTime:\n"
                     << "Received DT =" << receivedDetectionTime << "Table DT =" << tableDetectionTime << "diff =" <<
                        (qint64)(receivedDetectionTime - tableDetectionTime) << "\n"
                     << "Received RT =" << receivedReferenceTime << "Table RT =" << tableReferenceTime << "diff =" <<
                        (qint64)(receivedReferenceTime - tableReferenceTime);
            return;
        }
        /* 2) b. ii. Otherwise, check if the received DENM is a repeated DENM of the entry, i.e. the received
         *           referenceTime equals to the entry referenceTime, the received detectionTime equals to the entry
         *           detectionTime, and the received termination value equals to the entry state. */
        if(receivedReferenceTime == tableReferenceTime &&
           receivedDetectionTime == tableDetectionTime)
        {
            if((!denm->denm.management.termination && !tableDenm.denm.management.termination) ||
               (denm->denm.management.termination && tableDenm.denm.management.termination))
            {
                if(denm->denm.management.termination && (*denm->denm.management.termination == *tableDenm.denm.management.termination))
                {
                    /* 2) b. ii. 1. If yes, discard the received DENM and omit exection of further steps. */
                    qDebug() << "Received DENM is a repeated DENM";
                    return;
                }
            }
        }
        /* 2) b. ii. 2. Otherwise, check SSP and CauseCode if available. */
        /* TODO: Check SSP consistency. */
        /* 2) b. ii. 2. b. Otherwise, update the entry in receiving ITS-S message table, set entry state according
         *                 to the termination value of the received DENM. */
        m_receivedDENM[found]->setDENM(*denm);
    }

    /* 3) Start/restart T_R_Validity timer. */
    qDebug() << "Start/Restart T_R_Validity";
    m_receivedDENM[found]->setT_R_Validity(expiration - m_paramGPS->timestamp());
    m_receivedDENM[found]->m_reception->m_T_R_Validity_timer.start();

    /* 4) Inform ITS-S applications of the DENM entry and state if applicable. */
    QByteArray resUt;
    QDataStream ds(&resUt, QIODevice::WriteOnly);
    char msg[MSG_LENGTH];
    asn_enc_rval_t erval = uper_encode_to_buffer(&asn_DEF_DENM, denm, msg, MSG_LENGTH);
    ds << (quint8)0x17 << (quint16)((erval.encoded + 7) >> 3);
    ds.writeRawData(QByteArray(msg, (erval.encoded + 7) >> 3), (erval.encoded + 7) >> 3);

    denm2app->writeDatagram(resUt, QHostAddress::LocalHost, appPort);
    qDebug() << resUt.toHex() << "sent to" << QHostAddress::LocalHost << appPort;

    if(denm->denm.situation)
    {
        if(denm->denm.alacarte)
        {
            if(denm->denm.alacarte->impactReduction)
            {
                if(denm->denm.alacarte->impactReduction->requestResponseIndication == RequestResponseIndication_request)
                {
                    sendRequestResponseIndication_Response(denm->denm.situation, denm->denm.management.actionID);
                }
            }
        }
    }
    /* 5) End. */

    emit kaf(denm);
}

void denReceptionManagement::sendRequestResponseIndication_Response(SituationContainer_t *s, ActionID_t originatingActionID)
{
    DENM_t denm;
    asn_enc_rval_t rval;
    char msg[MSG_LENGTH] = {'\0'};
    denMessageTableSource *entry = new denMessageTableSource;
    AppDenmTriggerData data(m_paramDENM);
    quint64 expirationTime;

    memset(&denm, 0, sizeof denm);

    denm.header = fill_ItsPduHeader(m_paramAppli->data().stationID());
    denm.denm.management = fill_ManagementContainer(originatingActionID, &m_paramGPS->data(), &m_paramAppli->data());
    denm.denm.situation = (SituationContainer_t*)calloc(1, sizeof *denm.denm.situation);
    denm.denm.situation = s;
    denm.denm.location = (LocationContainer_t*)calloc(1, sizeof *denm.denm.location);
    denm.denm.location->traces.list.array = (PathHistory_t**)calloc(1, sizeof *denm.denm.location->traces.list.array);
    PathHistory_t *p = (PathHistory_t*)calloc(1, sizeof *p);
    denm.denm.location->traces.list.array[0] = (PathHistory_t*)calloc(1, sizeof *denm.denm.location->traces.list.array[0]);
    ASN_SEQUENCE_ADD(&denm.denm.location->traces, p);
    denm.denm.alacarte = (AlacarteContainer_t*)calloc(1, sizeof *denm.denm.alacarte);
    *denm.denm.alacarte = fill_AlacarteContainer(m_paramConf, &m_paramCan->data());
    asn_long2INTEGER((INTEGER_t*)&denm.denm.management.referenceTime, m_paramGPS->timestamp());
    asn_fprint(NULL, &asn_DEF_DENM, &denm);

    rval = uper_encode_to_buffer(&asn_DEF_DENM, &denm, msg, MSG_LENGTH);
    if(rval.encoded < 1)
    {
        qDebug() << "Unable to encode" << rval.failed_type->name;
        return;
    }

    if(!PassDenmToNetworkAndTransportLayerTrigger(data, msg, (rval.encoded + 7) / 8))
    {
        qDebug() << "Unable to pass DENM to N&T";
        return;
    }

    /* 8) Create an entry in the originating ITS-S message table and set the state to ACTIVE. */
    asn_INTEGER2ulong((INTEGER_t*)&denm.denm.management.detectionTime, (long unsigned int*)&expirationTime);
    expirationTime += DefaultValidity * 1000;
    entry->setDENM(denm);
    entry->setTrafficClass(data.trafficClass().toInt());
    entry->setActionID(denm.denm.management.actionID);

    /* 9) Start/restart timer T_O_Validity. */
    entry->setT_O_Validity(expirationTime - m_paramGPS->timestamp());

    emit setSequenceNumberSignal(++m_sequenceNumber);
}

void denReceptionManagement::AppDENM_negation(AppDenmTerminationData termination, ActionID_t actionID)
{
    QMutexLocker locker(m_mutexReception);
    int found = haveDENM(actionID, m_receivedDENM);

    if(found < 0)
    {
        qDebug() << actionID.originatingStationID << ":" << actionID.sequenceNumber << "not found in the received table size"
                 << m_receivedDENM.size();
        AppDENM_result(actionID, false, AppDenmResultData::eventDoesNotExist, NULL);
        return;
    }

    DENM_t denm = m_receivedDENM.at(found)->denm();
    DENM_t denmToSend;

    m_receivedDENM.removeAt(found);

    memset(&denmToSend, 0, sizeof denmToSend);
    denmToSend.header = fill_ItsPduHeader(m_paramAppli->data().stationID());
    denmToSend.denm.management = denm.denm.management;

    fill_ManagementContainer(denm.denm.management.detectionTime, denm.denm.management.referenceTime, &denmToSend.denm.management,
                             Termination_isNegation, m_paramGPS, &m_paramAppli->data());

    char msg[MSG_LENGTH] = {'\0'};
    asn_enc_rval_t rval;

    asn_fprint(NULL, &asn_DEF_DENM, &denmToSend);
    rval = uper_encode_to_buffer(&asn_DEF_DENM, &denmToSend, msg, MSG_LENGTH);
    if(rval.encoded < 1)
    {
        qDebug() << "Unable to encode" << rval.failed_type->name;
        return AppDENM_result(actionID, false, AppDenmResultData::cannotCreateDENM_unableToEncodeDENM, &denm);
    }

    print_hexa((unsigned char*)msg, (rval.encoded + 7) / 8);
    AppDenmTriggerData data(denm, termination.destinationArea());

    if(!PassDenmToNetworkAndTransportLayerTrigger(data, msg, (rval.encoded + 7) / 8))
    {
        qDebug() << "Unable to pass DENM to N&T";
        return AppDENM_result(actionID, false, AppDenmResultData::cannotSendDENM, &denm);
    }

    AppDenmTerminationIndication terminationIndication(actionID);

    denm2app->writeDatagram(terminationIndication.toBin(), QHostAddress::LocalHost, appPort);
    return AppDENM_result(actionID, true, AppDenmResultData::success, &denm);
}

bool denReceptionManagement::PassDenmToNetworkAndTransportLayerTrigger(AppDenmTriggerData data, char *msg, int denmLength)
{
    gnDataRequest_t dr = gnDataRequestFromAppDenmTriggerData(data, m_paramGPS->data());

    dr.payload = QByteArray(msg, denmLength);

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

void denReceptionManagement::AppDENM_result(ActionID_t actionID, bool success, AppDenmResultData::e_failureNotification failureNotification, DENM_t *denm)
{
    QByteArray msg;
    AppDenmResultData result(actionID, success, failureNotification, denm, m_paramDENM);
    msg = result.toBin();

    emit appDenmResult(msg);
}

void denReceptionManagement::discardDENM(int index)
{
    AppDenmTerminationIndication termination(m_receivedDENM.at(index)->actionID());

    if(m_receivedDENM[index]->m_reception)
    {
        m_receivedDENM[index]->m_reception->setTimer(-1);
    }
    m_receivedDENM.removeAt(index);

    denm2app->writeDatagram(termination.toBin(), QHostAddress::LocalHost, appPort);
}

void denReceptionManagement::discardDENMFromReceivedTable(ActionID_t actionID)
{
    QMutexLocker locker(m_mutexReception);
    int found = haveDENM(actionID, m_receivedDENM);

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