CBFPacketEntry.cpp

Go to the documentation of this file.

#include "CBFPacketEntry.h"

CBFPacketEntry::CBFPacketEntry()
{
    m_mutex = new QMutex;
    m_paramNetwork = 0;
    m_paramGPS = 0;
    m_timer = 0;
    m_send = true;
}

CBFPacketEntry::CBFPacketEntry(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray payload, int timerToLive, ParameterNetwork* paramNetwork, GnAddr* gnAddr, FakeGPSProvider* paramGPS, HistoryPacketBuffer* HPB, quint16* SN)
{
    m_mutex = new QMutex;
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_gbc = packet;
    m_paramNetwork = paramNetwork;
    m_paramGPS = paramGPS;
    m_timer = timerToLive;
    m_gnAddr = gnAddr;
    m_HPB = HPB;
    sequenceNumber = SN;
    m_send = true;
}

CBFPacketEntry::CBFPacketEntry(BasicHeader bh, CommonHeader ch, GUCPacket packet, QByteArray payload, int timerToLive, ParameterNetwork* paramNetwork, GnAddr* gnAddr, FakeGPSProvider* paramGPS, HistoryPacketBuffer* HPB, quint16* SN)
{
    m_mutex = new QMutex;
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_guc = packet;
    m_paramNetwork = paramNetwork;
    m_paramGPS = paramGPS;
    m_timer = timerToLive;
    m_gnAddr = gnAddr;
    m_HPB = HPB;
    sequenceNumber = SN;
    m_send = true;
}

CBFPacketEntry::CBFPacketEntry(BasicHeader bh, CommonHeader ch, LSReplyPacket packet, QByteArray payload, int timerToLive, ParameterNetwork* paramNetwork, GnAddr* gnAddr, FakeGPSProvider* paramGPS, HistoryPacketBuffer* HPB, quint16* SN)
{
    m_mutex = new QMutex;
    m_bh = bh;
    m_ch = ch;
    m_payload = payload;
    m_lsReply = packet;
    m_paramNetwork = paramNetwork;
    m_paramGPS = paramGPS;
    m_timer = timerToLive;
    m_gnAddr = gnAddr;
    m_HPB = HPB;
    sequenceNumber = SN;
    m_send = true;
}

CBFPacketEntry::CBFPacketEntry(const CBFPacketEntry& other) : PacketBuffersEntry()
{
    m_mutex = other.m_mutex;
    m_bh = other.m_bh;
    m_ch = other.m_ch;
    m_payload = other.m_payload;
    switch(other.m_ch.headerType())
    {
    case CommonHeader::headerType_beacon:
        m_beac = other.m_beac;
        break;
    case CommonHeader::headerType_geoAnycast:
        m_gac = other.m_gac;
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoBroadcast:
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoUnicast:
        m_guc = other.m_guc;
        break;
    case CommonHeader::headerType_topologicallyScopedBroadcast:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop:
            m_shb = other.m_shb;
            break;
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop:
            m_tsb= other.m_tsb;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_locationService:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeLocationService_Request:
            m_lsRequest = other.m_lsRequest;
            break;
        case CommonHeader::headerSubTypeLocationService_Reply:
            m_lsReply = other.m_lsReply;
            break;
        }
        break;
    case CommonHeader::headerType_any:
    default:
        break;
    }
    this->m_paramNetwork = other.m_paramNetwork;
    m_paramGPS = other.m_paramGPS;
    this->m_timer = other.m_timer;
    this->m_gnAddr= other.m_gnAddr;
    this->m_send = other.m_send;
    this->m_miniTimer = other.m_miniTimer;
}

CBFPacketEntry& CBFPacketEntry::operator=(const CBFPacketEntry& other)
{
    m_mutex = other.m_mutex;
    m_bh = other.m_bh;
    m_ch = other.m_ch;
    m_payload = other.m_payload;
    switch(other.m_ch.headerType())
    {
    case CommonHeader::headerType_beacon:
        m_beac = other.m_beac;
        break;
    case CommonHeader::headerType_geoAnycast:
        m_gac = other.m_gac;
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoBroadcast:
        m_gbc = other.m_gbc;
        break;
    case CommonHeader::headerType_geoUnicast:
        m_guc = other.m_guc;
        break;
    case CommonHeader::headerType_topologicallyScopedBroadcast:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_singleHop:
            m_shb = other.m_shb;
            break;
        case CommonHeader::headerSubTypeTopologicallyScopedBroadcast_multiHop:
            m_tsb= other.m_tsb;
            break;
        default:
            break;
        }
        break;
    case CommonHeader::headerType_locationService:
        switch(other.m_ch.headerSubType())
        {
        case CommonHeader::headerSubTypeLocationService_Request:
            m_lsRequest = other.m_lsRequest;
            break;
        case CommonHeader::headerSubTypeLocationService_Reply:
            m_lsReply = other.m_lsReply;
            break;
        }
        break;
    case CommonHeader::headerType_any:
    default:
        break;
    }
    this->m_paramNetwork = other.m_paramNetwork;
    this->m_paramGPS = other.m_paramGPS;
    this->m_timer = other.m_timer;
    this->m_gnAddr = other.m_gnAddr;
    this->m_send = other.m_send;
    this->m_miniTimer = other.m_miniTimer;
    return *this;
}

//bool CBFPacketEntry::operator==(const CBFPacketEntry& other)
//{
//    if(other.m_ch.headerType() == CommonHeader::headerType_geoBroadcast)
//        return isDuplicatePacketDetectionTimestampSN(m_gbc.soPv().timestamp(), other.m_gbc.soPv().timestamp(), m_gbc.sequenceNumber(), other.m_gbc.sequenceNumber());
//    else if(other.m_ch.headerType() == CommonHeader::headerType_geoUnicast)
//        return isDuplicatePacketDetectionTimestampSN(m_guc.soPv().timestamp(), other.m_guc.soPv().timestamp(), m_guc.sequenceNumber(), other.m_guc.sequenceNumber());
//    else
//        return false;
//}

void CBFPacketEntry::kill()
{
    m_send = false;
    this->deleteLater();
}

void CBFPacketEntry::execute()
{
    m_elapsed.start();
    m_miniTimer.start();
    printf("Timer : %d\n", m_timer);
    //m_timeCompt.start(m_timer);

    //QThread::msleep(m_timer);

    //while(m_timeCompt.remainingTime() > 0)
    while(m_miniTimer.elapsed() < m_timer)
        ;
    printf("End Elapsed : %lld\n", m_elapsed.elapsed());
    if(basicHeader().lifeTime().lifeTime() - m_elapsed.elapsed() < 50 || basicHeader().rhl() < 1)
    {
        if(commonHeader().headerType() == CommonHeader::headerType_geoAnycast || commonHeader().headerType() == CommonHeader::headerType_geoBroadcast)
            emit killMe(m_gbc);
        else if(commonHeader().headerType() == CommonHeader::headerType_geoUnicast)
            emit killMe(m_guc);
        else if(commonHeader().headerType() == CommonHeader::headerType_locationService && commonHeader().headerSubType() == CommonHeader::headerSubTypeLocationService_Reply)
            emit killMe(m_lsReply);
        kill();
    }

    if(m_send)
        sendPacket();
}

void CBFPacketEntry::sendPacket()
{
    quint32 tmpstmp = m_paramGPS->timestamp() % 0x100000000;
    quint8 pai = m_paramGPS->data().referencePosition().positionConfidenceEllipse.semiMajorConfidence<itsGnPaiInterval/2?true << 15:false << 15;
    LongPositionVector lpv(*m_gnAddr, tmpstmp , m_paramGPS->data().referencePosition().latitude, m_paramGPS->data().referencePosition().longitude, pai, m_paramGPS->data().speed().speedValue,m_paramGPS->data().heading().headingValue);

    if(commonHeader().headerType() == CommonHeader::headerType_geoAnycast || commonHeader().headerType() == CommonHeader::headerType_geoBroadcast)
    {
        if(m_gbc.soPv().gnAddr() == *m_gnAddr)
            m_gbc.setSoPv(lpv);
    }
    else if(commonHeader().headerType() == CommonHeader::headerType_geoUnicast)
    {
        if(m_guc.soPv().gnAddr() == *m_gnAddr)
            m_guc.setSoPv(lpv);
    }
    else if(commonHeader().headerType() == CommonHeader::headerType_locationService && commonHeader().headerSubType() == CommonHeader::headerSubTypeLocationService_Reply)
    {
        if(m_lsReply.soPv().gnAddr() == *m_gnAddr)
            m_lsReply.setSoPv(lpv);
    }

    quint64 lt = basicHeader().lifeTime().lifeTime() - m_elapsed.elapsed();
    if(lt % 50 != 0)
        lt = (lt/50)*50;
    basicHeader().setLifeTime(LifeTime(lt));


    if(m_paramNetwork == NULL)
        return;

    size_t tx_len = sizeof(struct ether_header);

    for(int i = 0 ; i < 6 ; i++)
        m_paramNetwork->eh.ether_dhost[i] = 0xFF;

    /* Construct the Ethernet header : my mac addr */
    for(int i = 0 ; i < 6 ; i++)
        m_paramNetwork->eh.ether_shost[i] = m_gnAddr->mid(i);

    int extendedHeaderSize = 0;
    /* Construct the packet */
    QByteArray packetToSend;
    QDataStream ds(&packetToSend, QIODevice::WriteOnly);

    ds.writeRawData(basicHeader().toHex().data(), basicHeader().toHex().length());
    ds.writeRawData(commonHeader().toHex().data(), commonHeader().toHex().length());
    if(commonHeader().headerType() == CommonHeader::headerType_geoAnycast || commonHeader().headerType() == CommonHeader::headerType_geoBroadcast)
    {
        extendedHeaderSize = m_gbc.toHex().length();
        ds.writeRawData(m_gbc.toHex().data(), extendedHeaderSize);
        qDebug() << "GBCDATA:" << m_gbc.toHex().toHex();
    }
    if(commonHeader().headerType() == CommonHeader::headerType_geoUnicast)
    {
        extendedHeaderSize = m_guc.toHex().length();
        ds.writeRawData(m_guc.toHex().data(), extendedHeaderSize);
    }
    if(commonHeader().headerType() == CommonHeader::headerType_locationService && commonHeader().headerSubType() == CommonHeader::headerSubTypeLocationService_Reply)
    {
        extendedHeaderSize = m_lsReply.toHex().length();
        ds.writeRawData(m_lsReply.toHex().data(), extendedHeaderSize);
    }
    ds.writeRawData(payload().data(), payload().length());

    memcpy(m_paramNetwork->sendbuf, &m_paramNetwork->eh, sizeof(struct ether_header));
    for(int i = 0 ; i < BasicHeader::helper_size + CommonHeader::helper_size + extendedHeaderSize + payload().length(); i++)
        m_paramNetwork->sendbuf[tx_len++] = packetToSend.data()[i];

    /* Send packet */
    if(sendto(m_paramNetwork->rawSocket, m_paramNetwork->sendbuf, tx_len, 0, (struct sockaddr*)(&(m_paramNetwork->socket_address)), sizeof(struct sockaddr_ll)) < 0)
    {
        qDebug() << "sendto" << strerror(errno);
    }
    else
    {
        m_HPB->addPacket(m_gbc);
        (*sequenceNumber)++;
        if(commonHeader().headerType() == CommonHeader::headerType_geoAnycast || commonHeader().headerType() == CommonHeader::headerType_geoBroadcast)
        {
            printf("GAC/GBC PACKET sent from CBF\n");
            m_HPB->addPacket(m_gbc);
            emit packetSent(m_gbc);
        }
        else if(commonHeader().headerType() == CommonHeader::headerType_geoUnicast)
        {
            printf("GUC PACKET sent from CBF\n");
            m_HPB->addPacket(m_guc);
            emit packetSent(m_guc);
        }
        if(commonHeader().headerType() == CommonHeader::headerType_locationService && commonHeader().headerSubType() == CommonHeader::headerSubTypeLocationService_Reply)
        {
            printf("LSREPLY PACKET sent from CBF\n");
            m_HPB->addPacket(m_lsReply);
            emit packetSent(m_lsReply);
        }
    }
}