denTriggeringManagement.cpp

Go to the documentation of this file.

#include "include/denTriggeringManagement.h"

denTriggeringManagement::denTriggeringManagement(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_sequenceNumber = 0;

    m_mutexTriggering = new QMutex;

    m_appPort = network->internalPort("Application");
}

void denTriggeringManagement::utInitialize()
{
    printf("UtInitialize trigger %d\n", m_triggeredDENM.count());
    QMutexLocker locker(m_mutexTriggering);
    killTriggeredThreads();
    m_triggeredDENM.clear();
    m_sequenceNumber = 0;
    qDebug() << "endOfUtInitialize";
}

void denTriggeringManagement::killTriggeredThreads()
{
    for(int i = 0 ; i < m_triggeredDENM.size() ; i++)
    {
        if(m_triggeredDENM[i]->m_validity)
        {
            m_triggeredDENM[i]->m_validity->setTimer(-1);
            delete m_triggeredDENM[i]->m_validity;
            qDebug() << "m_validity deleted";
        }

        if(m_triggeredDENM[i]->T_RepetitionDuration())
        {
            if(m_triggeredDENM[i]->m_repetitionDuration)
            {
                m_triggeredDENM[i]->m_repetitionDuration->setTimer(-1);
                delete m_triggeredDENM[i]->m_repetitionDuration;
            }
        }

        if(m_triggeredDENM[i]->T_Repetition())
        {
            if(m_triggeredDENM[i]->m_repetition)
            {
                m_triggeredDENM[i]->m_repetition->setTimer(-1);
                delete m_triggeredDENM[i]->m_repetition;
            }
        }
        m_triggeredDENM[i]->m_thread->terminate();
        m_triggeredDENM[i]->m_thread->wait();
    }
}

void denTriggeringManagement::setSequenceNumberSlot(quint16 sequenceNumber)
{
    m_sequenceNumber = sequenceNumber;
}

void denTriggeringManagement::appendTriggeredDenm(denMessageTableSource *entry)
{
    QMutexLocker locker(m_mutexTriggering);
    m_triggeredDENM.append(entry);
}

void denTriggeringManagement::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 denTriggeringManagement::AppDENM_trigger(QByteArray datagram)
{
    quint64 expirationTime;
    quint32 validityDuration = 600;
    asn_enc_rval_t rval;
    char msg[MSG_LENGTH] = {'\0'};
    denMessageTableSource *entry = new denMessageTableSource();
    ActionID_t actionID;
    AppDenmTriggerData data(datagram);
    quint16 repetitionDuration, repetitionInterval;
    DENM_t d;

    actionID = defaultActionID(&m_paramAppli->data(), m_sequenceNumber);
    memset(&d, 0, sizeof d);

    /* 1) Calculate expiration time of timer T_O_Validity */
    expirationTime = calculate_T_O_Validity(data);

    /* 1) a. If expiration time of T_O_Validity is in the past, send a failure notification and omit
     *       the execution of firther steps. */
    if(expirationTime < m_paramGPS->timestamp())
    {
        qDebug() << "DENM expired:" << expirationTime << "for" << m_paramGPS->timestamp();
        return AppDENM_result(actionID, false, AppDenmResultData::eventIsInThePast, NULL);
    }

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

    /* 2) Assign unused ActionID value. */
    actionID = assignUnusedActionID(&m_paramAppli->data(), actionID);
    d.denm.management.actionID = actionID;
    qDebug() << "New ActionID" << actionID.originatingStationID << ":" << actionID.sequenceNumber;

    /* 3) If transmisionInterval is provided by the application request: */
    if(data.transmissionInterval())
    {
        /* 3) a. Set transmissionInterval. */
        d.denm.management.transmissionInterval = (TransmissionInterval_t*)calloc(1, sizeof *d.denm.management.transmissionInterval);
        *d.denm.management.transmissionInterval = *data.transmissionInterval();
        qDebug() << "Transmission interval set to" << *d.denm.management.transmissionInterval;
    }

    /* 3) b. Otherwise continue the operation. */

    /* 4) Set other fields of DENM management container… */
    d.header = fill_ItsPduHeader(m_paramAppli->data().stationID());
    if(!fill_ManagementContainer(data, &d.denm.management, &m_paramAppli->data(), m_paramGPS->data()))
    {
        qDebug() << "Unable to collect required data to fill management container";
        return AppDENM_result(actionID, false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
    }

    /* 4) … situation container … */
    if(data.situation())
    {
        d.denm.situation = (SituationContainer_t*)calloc(1, sizeof *d.denm.situation);
        if(!fill_SituationContainer(data, d.denm.situation))
        {
            qDebug() << "Unable to collect data to fill situation container";
            return AppDENM_result(actionID, false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }

    /* 4) … location container … */
    if(data.location())
    {
        d.denm.location = (LocationContainer_t*)calloc(1, sizeof *d.denm.location);
        if(!fill_LocationContainer(data, d.denm.location))
        {
            qDebug() << "Unable to collect data to fill location container";
            return AppDENM_result(actionID, false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }
    /* 6.1.3.2. A DENM shall include at least one trace. */
    else
    {
        d.denm.location = (LocationContainer_t*)calloc(1, sizeof *d.denm.location);
        d.denm.location->traces.list.array = (PathHistory_t**)calloc(1, sizeof *d.denm.location->traces.list.array);
        PathHistory_t *p = (PathHistory_t*)calloc(1, sizeof *p);
        d.denm.location->traces.list.array[0] = (PathHistory_t*)calloc(1, sizeof *d.denm.location->traces.list.array[0]);
        ASN_SEQUENCE_ADD(&d.denm.location->traces, p);
    }

    /* 4) … à la carte container. */
    if(data.alacarte())
    {
        d.denm.alacarte = (AlacarteContainer_t*)calloc(1, sizeof *d.denm.alacarte);
        if(!fill_AlacarteContainer(data, d.denm.alacarte))
        {
            qDebug() << "Unable to collect data to fill alacarte container";
            return AppDENM_result(actionID, false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }

    /* 5) Set referenceTime to the current time. */
    memset(&d.denm.management.referenceTime, 0, sizeof d.denm.management.referenceTime);
    asn_long2INTEGER((INTEGER_t*)&d.denm.management.referenceTime, m_paramGPS->timestamp());

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

    /* 7) Pass the DENM to the ITS networking & transport layer. */
    print_hexa((unsigned char*)msg, (rval.encoded + 7) / 8);
    if(!PassDenmToNetworkAndTransportLayerTrigger(data, msg, (rval.encoded + 7) / 8))
    {
        qDebug() << "Unable to pass DENM to N&T";
        return AppDENM_result(actionID, false, AppDenmResultData::cannotSendDENM, NULL);
    }

    /* 8) Create an entry in the originating ITS-S message table and set the state to ACTIVE. */
    entry->setDENM(d);
    entry->setStatus(denMessageTableSource::state_ACTIVE);
    entry->setTrafficClass(data.trafficClass().toInt());
    entry->setActionID(d.denm.management.actionID);
    entry->setDestinationArea(data.destinationArea());

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

    /* 10) If repetitionDuration and repetitionInterval > 0: */
    if(data.repetitionDuration() && data.repetitionInterval())
        if(*data.repetitionDuration() > 0 && *data.repetitionInterval() > 0)
        {
            repetitionDuration = *data.repetitionDuration();
            repetitionInterval = *data.repetitionInterval();
            if(repetitionDuration < validityDuration * 1000 && repetitionInterval < validityDuration * 1000)
            {
                /* 10) a. Calculate and start timer T_Repetitionduration and T_Repetition. */
                entry->setT_RepetitionDuration(repetitionDuration * 1000);
                entry->setT_Repetition(repetitionInterval);
            }
            qDebug() << "repetitionDuration =" << *data.repetitionDuration() << "repetitionInterval =" << *data.repetitionInterval();
        }
        else
            qDebug() << "repetitionDuration =" << *data.repetitionDuration() << "repetitionInterval =" << *data.repetitionInterval();
    else
        qDebug() << "No repetitionDuration or repetitionInterval";

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

    /* 11) Send actionID to the requesting ITS-S application. */
    AppDENM_result(actionID, true, AppDenmResultData::success, &d);

    /* 12) End. */
    QObject::connect(entry, SIGNAL(T_O_ValiditySignal(ActionID_t)), this, SLOT(discardDENMFromTriggeredTable(ActionID_t)));
    QObject::connect(entry, SIGNAL(T_RepetitionSignal(ActionID_t)), this, SLOT(repeatDENMFromTriggeredTable(ActionID_t)));
    entry->moveToThread(entry->m_thread);
    entry->m_thread->start();
    qDebug() << "entry->m_thread->start()";
    m_triggeredDENM.append(entry);
    emit setSequenceNumberSignal(++m_sequenceNumber);
}

void denTriggeringManagement::AppDENM_update(QByteArray datagram)
{
    DENM_t d;
    quint64 expirationTime;
    quint32 validityDuration = DefaultValidity * 1000;
    asn_enc_rval_t rval;
    char msg[MSG_LENGTH] = {'\0'};
    AppDenmUpdateData data(datagram);

    ActionIDData actionID = data.actionID();

    memset(&d, 0, sizeof d);

    /* 1) Calculate expiration time for timer T_O_Validity */
    if(data.validityDuration())
        validityDuration = *data.validityDuration();
    expirationTime = data.eventUpdateDetectionTime() + validityDuration;

    /* 1) a. If expiration time of timer T_O_Validity is in the past, send a failure notification to the ITS-S application
     *       and omit the execution of further steps. */
    if(expirationTime < m_paramGPS->timestamp())
    {
        qDebug() << "DENM expired:" << expirationTime << "for" << m_paramGPS->timestamp();
        return AppDENM_result(actionID.toASN(), false, AppDenmResultData::eventIsInThePast, NULL);
    }

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

    /* 2) Compare actionID in the application requiest with entries in the originating ITS-S message table */
    QMutexLocker locker(m_mutexTriggering);
    int found = haveDENM(actionID.toASN(), m_triggeredDENM);

    /* 2) a. If actionID provided by the ITS-S application request does not exist in the originating ITS-S message
     *       table, send a failure notification to the ITS-S application and omit the execution of furether steps. */
    if(found == -1)
    {
        qDebug() << "DENM" << actionID.originatingStationID() << ":" << actionID.sequenceNumber() <<
                    "not found in the triggered message table";
        return AppDENM_result(actionID.toASN(), false, AppDenmResultData::eventDoesNotExist, NULL);
    }

    /* 2) b. Otherwise, continue the operation. */
    DENM_t triggeredDENM = m_triggeredDENM.at(found)->denm();
    qint64 repetitionDuration = 0, repetitionInterval = 0;

    /* 3) Stop T_O_Validity, T_RepetitionDuration and T_Repetition if applicable. */
    repetitionDuration = m_triggeredDENM.at(found)->T_RepetitionDuration();
    repetitionInterval = m_triggeredDENM.at(found)->T_Repetition();
    m_triggeredDENM[found]->setT_O_Validity(-1);
    m_triggeredDENM.at(found)->setT_RepetitionDuration(-1);
    m_triggeredDENM.at(found)->setT_Repetition(-1);

    /* 4) If transmissionInterval is provided by the application */
    if(data.transmissionInterval())
    {
        /* 4) a. Set transmissionInterval. */
        d.denm.management.transmissionInterval = (TransmissionInterval_t*)calloc(1, sizeof *d.denm.management.transmissionInterval);
        *d.denm.management.transmissionInterval = *data.transmissionInterval();
    }
    else if(triggeredDENM.denm.management.transmissionInterval)
    {
        d.denm.management.transmissionInterval = (TransmissionInterval_t*)calloc(1, sizeof *d.denm.management.transmissionInterval);
        *d.denm.management.transmissionInterval = *triggeredDENM.denm.management.transmissionInterval;
    }

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

    /* 5) Set other fields of DENM management container… */
    d.header = fill_ItsPduHeader(m_paramAppli->data().stationID());
    if(!fill_ManagementContainer(data, &d.denm.management, triggeredDENM.denm.management, actionID.toASN(), &m_paramAppli->data()))
    {
        qDebug() << "Unable to collect required data to fill management container";
        return AppDENM_result(actionID.toASN(), false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
    }

    /* 5) … situation container … */
    if(data.situation())
    {
        d.denm.situation = (SituationContainer_t*)calloc(1, sizeof *d.denm.situation);
        if(!fill_SituationContainer(data, d.denm.situation))
        {
            qDebug() << "Unable to collect data to fill situation container";
            return AppDENM_result(actionID.toASN(), false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }
    else if(triggeredDENM.denm.situation)
    {
        d.denm.situation = (SituationContainer_t*)calloc(1, sizeof *d.denm.situation);
        *d.denm.situation = setSituationContainer(*triggeredDENM.denm.situation);
    }

    /* 5) … location container … */
    if(data.location())
    {
        if(!fill_LocationContainer(data, d.denm.location))
        {
            qDebug() << "Unable to collect data to fill location container";
            return AppDENM_result(actionID.toASN(), false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }
    /* 6.1.3.2. A DENM shall include at least one trace. */
    else
    {
        d.denm.location = (LocationContainer_t*)calloc(1, sizeof *d.denm.location);
        d.denm.location->traces.list.array = (PathHistory_t**)calloc(1, sizeof *d.denm.location->traces.list.array);
        PathHistory_t *p = (PathHistory_t*)calloc(1, sizeof *p);
        d.denm.location->traces.list.array[0] = (PathHistory_t*)calloc(1, sizeof *d.denm.location->traces.list.array[0]);
        ASN_SEQUENCE_ADD(&d.denm.location->traces, p);
    }

    /* 5) … à la carte container. */
    if(data.alacarte())
    {
        d.denm.alacarte = (AlacarteContainer_t*)calloc(1, sizeof *d.denm.alacarte);
        if(!fill_AlacarteContainer(data, d.denm.alacarte))
        {
            qDebug() << "Unable to collect data to fill alacarte container";
            return AppDENM_result(actionID.toASN(), false, AppDenmResultData::cannotCreateDENM_unableToCollectRequiredData, NULL);
        }
    }

    /* 6) Set referenceTime to the current time. */
    asn_long2INTEGER((INTEGER_t*)&d.denm.management.referenceTime, m_paramGPS->timestamp());

    /* 7) Construct the DENM. */
    rval = uper_encode_to_buffer(&asn_DEF_DENM, &d, msg, MSG_LENGTH);
    if(rval.encoded < 1)
    {
        qDebug() << "Unable to encode" << rval.failed_type->name;
        return AppDENM_result(actionID.toASN(), false, AppDenmResultData::cannotCreateDENM_unableToEncodeDENM, NULL);
    }

    /* 8) Pass the DENM to the ITS networking & transport layer. */
    AppDenmTriggerData trigger(d, data.destinationArea());

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

    /* 9) Update the entry in the originating ITS-S message table. */
    m_triggeredDENM[found]->setDENM(d);
    m_triggeredDENM[found]->setStatus(denMessageTableSource::state_ACTIVE);
    if(data.trafficClass())
        m_triggeredDENM[found]->setTrafficClass(data.trafficClass()->toInt());
    else
        m_triggeredDENM[found]->setTrafficClass(itsGnDefaultTrafficClass);
    m_triggeredDENM[found]->setActionID(d.denm.management.actionID);

    /* 10) Start/restart timer T_O_Validity. */
    m_triggeredDENM[found]->setT_O_Validity(expirationTime - m_paramGPS->timestamp());
    m_triggeredDENM[found]->m_validity->m_T_O_Validity_timer.start();

    /* 11) If repetitionDuration > 0 and repetitionInterval > 0 */
    qDebug() << "repetitionDuration" << repetitionDuration << "repetitionInterval" << repetitionInterval;
    if(data.repetitionDuration() && data.transmissionInterval())
    {
        if(*data.repetitionDuration() > 0 && *data.transmissionInterval() > 0)
        {
            qDebug() << "data.repetitionDuration" << *data.repetitionDuration() << "data.transmissionInterval" << *data.transmissionInterval();
            /* 11) a. Calculating and restart timer T_RepetitionDuration and T_Repetition. */
            m_triggeredDENM[found]->setT_RepetitionDuration(*data.repetitionDuration() * 1000);
            m_triggeredDENM[found]->setT_Repetition(*data.transmissionInterval());
            m_triggeredDENM[found]->m_repetitionDuration = new denMessageTableSourceThread(m_triggeredDENM[found]->T_RepetitionDuration());
            m_triggeredDENM[found]->m_repetition = new denMessageTableSourceThread(m_triggeredDENM[found]->T_Repetition());
            m_triggeredDENM[found]->m_repetitionDuration->m_T_RepetitionDuration_timer.start();
            m_triggeredDENM[found]->m_repetition->m_T_Repetition_timer.start();
            QTimer::singleShot(m_triggeredDENM[found]->T_RepetitionDuration(), m_triggeredDENM[found]->m_repetitionDuration, SLOT(endOfT_RepetitionDuration()));
            QTimer::singleShot(m_triggeredDENM[found]->T_Repetition(), m_triggeredDENM[found]->m_repetition, SLOT(endOfT_Repetition()));
        }
    }
    else if(repetitionDuration > 0 && repetitionInterval > 0)
    {
        m_triggeredDENM[found]->setT_RepetitionDuration(repetitionDuration * 1000);
        m_triggeredDENM[found]->setT_Repetition(repetitionInterval);
        m_triggeredDENM[found]->m_repetitionDuration->m_T_RepetitionDuration_timer.start();
        m_triggeredDENM[found]->m_repetition->m_T_Repetition_timer.start();
    }

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

    /* 12) Send actionID to the requesting ITS-S applpication. */

    qDebug() << "END of Update";
    QObject::connect(m_triggeredDENM[found], SIGNAL(T_O_ValiditySignal(ActionID_t)), this, SLOT(discardDENMFromTriggeredTable(ActionID_t)));
    QObject::connect(m_triggeredDENM[found], SIGNAL(T_RepetitionSignal(ActionID_t)), this, SLOT(repeatDENMFromTriggeredTable(ActionID_t)));

    return AppDENM_result(d.denm.management.actionID, true, AppDenmResultData::success, &d);

    /* 13) End. */
}

void denTriggeringManagement::AppDENM_cancellation(AppDenmTerminationData termination, ActionID_t actionID)
{
    qDebug() << "\n\n\n\n\nCancel\n\n\n\n\n";
    QMutexLocker locker(m_mutexTriggering);
    int found = haveDENM(actionID, m_triggeredDENM);

    qInfo() << "There are" << m_triggeredDENM.size() << "DENM in the triggeredDENM:";
    qInfo() << m_triggeredDENM;
    if(found < 0)
    {
        qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber <<
                    "not found in the triggered message table";
        return AppDENM_result(actionID, false, AppDenmResultData::eventDoesNotExist, NULL);
    }
    qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber <<
                "found in the triggered message table";
    if(m_triggeredDENM[found]->status() != denMessageTableSource::state_ACTIVE)
    {
        qDebug() << "DENM not active";
        return AppDENM_result(actionID, false, AppDenmResultData::eventNotActive, NULL);
    }

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

    m_triggeredDENM[found]->setT_O_Validity(-1);
    m_triggeredDENM[found]->setT_RepetitionDuration(-1);
    m_triggeredDENM[found]->setT_Repetition(-1);
    if(m_triggeredDENM[found]->m_validity)
    {
        m_triggeredDENM[found]->m_validity->setTimer(-1);
        m_triggeredDENM[found]->m_validity->stopTimer();
    }
    if(m_triggeredDENM[found]->m_repetitionDuration)
    {
        m_triggeredDENM[found]->m_repetitionDuration->setTimer(-1);
        m_triggeredDENM[found]->m_repetitionDuration->stopTimer();
    }
    if(m_triggeredDENM[found]->m_repetition)
    {
        m_triggeredDENM[found]->m_repetition->setTimer(-1);
        m_triggeredDENM[found]->m_repetition->stopTimer();
    }

    qInfo() << "Creating Canceled DENM";
    memset(&denmToSend, 0, sizeof denmToSend);
    denmToSend.header = denm.header;
    denmToSend.denm.management = denm.denm.management;

    fill_ManagementContainer(denm.denm.management.detectionTime, &denmToSend.denm.management, Termination_isCancellation,
                             m_paramGPS, &m_paramAppli->data());
    asn_long2INTEGER((INTEGER_t*)&denmToSend.denm.management.referenceTime, m_paramGPS->timestamp());

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

    asn_fprint(NULL, &asn_DEF_DENM, &denmToSend);
    qInfo() << "Encoding Canceled DENM";
    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());

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

    AppDENM_result(actionID, true, AppDenmResultData::success, &denm);
}

bool denTriggeringManagement::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 denTriggeringManagement::discardDENMFromTriggeredTable(ActionID_t actionID)
{
    int found = haveDENM(actionID, m_triggeredDENM);
    qDebug() << "Discarding DENM" << found;

    if(found < 0)
    {
        qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber <<
                    "not found in the triggered message table";
        return;
    }
    qInfo() << "Setting state CANCELED";
    m_triggeredDENM[found]->setStatus(denMessageTableSource::state_CANCELED);
    qInfo() << "Removing DENM";
    m_triggeredDENM.removeAt(found);
    qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber << "discarded from triggered table";

    AppDENM_terminationIndication(actionID);
}

void denTriggeringManagement::AppDENM_terminationIndication(ActionID actionID)
{
    AppDenmTerminationIndication termination(actionID);
    QUdpSocket socket;
    QNetworkDatagram datagram;

    datagram.setDestination(QHostAddress::LocalHost, m_appPort);
    datagram.setData(termination.toBin());
    qInfo() << "Sending termination indication to" << m_appPort;
    socket.writeDatagram(datagram);
    qInfo() << "Termination indication sent";
}

void denTriggeringManagement::repeatDENMFromTriggeredTable(ActionID_t actionID)
{
    qDebug() << "locking repeatDENMFromTriggeredTable";
    QMutexLocker locker(m_mutexTriggering);
    int found = haveDENM(actionID, m_triggeredDENM);
    qDebug() << "Repeating DENM" << found;

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

    DENM_t denm = m_triggeredDENM[found]->denm();
    qDebug() << "Pseudo =" << m_paramAppli->data().stationID();
    if(actionID.originatingStationID != m_paramAppli->data().stationID())
    {
        ActionID_t current;
        denm.header.stationID = m_paramAppli->data().stationID();
        denm.denm.management.actionID.originatingStationID = m_paramAppli->data().stationID();
        m_triggeredDENM[found]->setDENM(denm);
        current.originatingStationID = m_paramAppli->data().stationID();
        current.sequenceNumber = actionID.sequenceNumber;
        m_triggeredDENM[found]->setActionID(current);
        found = haveDENM(current, m_triggeredDENM);
    }
    AppDenmTriggerData data(m_triggeredDENM[found]->denm(), m_triggeredDENM[found]->destinationArea());
    char msg[MSG_LENGTH] = {'\0'};
    asn_enc_rval_t 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;
    }
    qDebug() << "DENM" << actionID.originatingStationID << ":" << actionID.sequenceNumber << "repeated";
}