Geonet.h

Go to the documentation of this file.

#ifndef _Geonet_H_
#define _Geonet_H_

#include <iostream>
#include <QObject>
#include <QUdpSocket>
#include <stdlib.h>
#include <api.h>
#include <apiNetwork.h>
#include <DestinationArea.h>
#include <BeaconPacket.h>
#include <SHBPacket.h>
#include <GBCPacket.h>
#include <LSRequestPacket.h>
#include <LSReplyPacket.h>
#include <Manager.h>
#include <LocationTableEntry.h>
#include <GNDataRequest.h>
#include <BasicHeader.h>
#include <CommonHeader.h>
#include <ParameterNetwork.h>
#include <ParameterHybrid.h>
#include <caReceptionManagement.h>
#include <HistoryPacketBuffer.h>
#include <BroadcastForwardingPacketBuffer.h>
#include <UnicastForwardingPacketBuffer.h>
#include <CBFPacketBuffer.h>
#include <LocationServicePacketBuffer.h>
#include <RepetitionPacketBuffer.h>
#include <UpperTesterPrimitives.h>
#include <ReceivePackets.h>
#include <ForwardingAlgorithmResponse.h>
#include <QSslSocket>
#include <SecurityManager.h>

class GeoNet : public QObject
{
    Q_OBJECT
public:

    union destinationAddress_u
    {
        uchar mid[6];
    };

    enum e_networkError
    {
        networkError_success,
        networkError_rawsocket_open,
        networkError_rawsocket_siocgifindex,
        networkError_rawsocket_send
    };

    enum e_hybridError
    {
        hybridError_success,
        hybridError_send
    };

    enum e_geonetError
    {
        geonetError_success,
        // Send Errors
        // Common Header Errors
        geonetError_send_ch_headerType,
        // Anycast
        geonetError_send_ch_headerSubType_geoAnycast_unknown,
        // Broadcast
        geonetError_send_ch_headerSubType_geoBroadcast_unknown,
        // Topological
        geonetError_send_ch_headerSubType_TSB_unknown,
        // LSRequest Send Errors
        tmp_geonetError_send_LSRequest_securedPacket,
        geonetError_send_LSRequest_buffered,
        geonetError_send_LSRequest_successfullyRespond,
        geonetError_send_LSRequest_noResponse,
        // LSReply send Errors
        tmp_geonetError_send_LSReply_securedPacket,
        geonetError_send_LSReply_destinationUnknown,
        geonetError_send_LSReply_bufferedPacket,
        geonetError_send_LSReply_discardedPacket,
        geonetError_send_LSReply_destinationAddress,
        // LSReply Forward Errors
        geonetError_forward_LSReply_bufferedPacket,
        geonetError_forward_LSReply_discardedPacket,
        geonetError_forward_LSReply_destinationAddress,
        // GAC Send Errors
        tmp_geonetError_send_gac_securedPacket,
        geonetError_send_gac_noDestinationArea,
        geonetError_send_gac_areaSize,
        geonetError_send_gac_unknownCommunicationProfile,
        geonetError_send_gac_unicast_bufferedPacket,
        geonetError_send_gac_unicast_discardedPacket,
        geonetError_send_gac_broadcast_bufferedPacket,
        geonetError_send_gac_broadcast_discardedPacket,
        geonetError_send_gac_destinationAddress,
        geonetError_send_gac_noAreaLineForwarding,
        // GAC Forward Errors
        geonetError_forward_gac_areaSize,
        geonetError_forward_gac_bufferedPacket,
        geonetError_forward_gac_discardedPacket,
        geonetError_forward_gac_destinationAddress,
        geonetError_forward_gac_noAreaLineForwarding,
        // GBC Send Errors
        tmp_geonetError_send_gbc_securedPacket,
        geonetError_send_gbc_noDestinationArea,
        geonetError_send_gbc_areaSize,
        geonetError_send_gbc_unknownCommunicationProfile,
        geonetError_send_gbc_bufferedPacket,
        geonetError_send_gbc_discardedPacket,
        geonetError_send_gbc_destinationAddress,
        // GBC Forward Errors
        geonetError_forward_gbc_areaSize,
        geonetError_forward_gbc_bufferedPacket,
        geonetError_forward_gbc_discardedPacket,
        geonetError_forward_gbc_destinationAddress,
        // GUC Send Errors
        geonetError_send_guc_noMID,
        tmp_geonetError_send_guc_MIDNotFound,
        tmp_geonetError_send_guc_securedPacket,
        geonetError_send_guc_unknownCommunicationProfile,
        geonetError_send_guc_bufferedPacket,
        geonetError_send_guc_discardedPacket,
        geonetError_send_guc_destinationAddress,
        // GUC Forward Errors
        geonetError_forward_guc_bufferedPacket,
        geonetError_forward_guc_discardedPacket,
        geonetError_forward_guc_destinationAddress,
        // SHB Send Errors
        tmp_geonetError_send_shb_securedPacket,
        geonetError_send_shb_unknownCommunicationProfile,
        geonetError_send_shb_bufferedPacket,
        // TSB Send Errors
        tmp_geonetError_send_tsb_securedPacket,
        geonetError_send_tsb_unknownCommunicationProfile,
        geonetError_send_tsb_bufferedPacket,
        // TSB Forward Errors
        geonetError_forward_tsb_unknownCommunicationProfile,
        geonetError_forward_tsb_bufferedPacket,
        // Receive Errors
        // Basic Header Errors
        geonetError_processing_bh_gnProtocolVersion,
        geonetError_processing_bh_nextHeader,
        geonetError_processing_bh_securedHeader,
        // Common Header Errors
        geonetError_processing_ch_hopLimit,
        geonetError_processing_ch_headerType,
        geonetError_processing_ch_headerSubType_TSB_unknown,
        geonetError_processing_ch_headerSubType_LS_unknown,
        // Duplicate Packet Address Errors
        geonetError_processing_beacon_DAD,
        geonetError_processing_LSRequest_DAD,
        geonetError_processing_LSReply_DAD,
        geonetError_processing_gac_DAD,
        geonetError_processing_gbc_DAD,
        geonetError_processing_guc_DAD,
        geonetError_processing_shb_DAD,
        geonetError_processing_tsb_DAD,
        // Duplicate Packet Timestamp &&/|| SN Errors
        geonetError_processing_beacon_DPD,
        geonetError_processing_LSRequest_DPD,
        geonetError_processing_LSReply_DPD,
        geonetError_processing_gac_DPD,
        geonetError_processing_gbc_DPD,
        geonetError_processing_guc_DPD,
        geonetError_processing_shb_DPD,
        geonetError_processing_tsb_DPD
    };

    GeoNet();
    GeoNet(Manager* m, bool geonetFlag, bool hybridFlag, QMutex* mutex = nullptr);
    ~GeoNet();

    int send(gnDataRequest_t gnDR);
    //static int send(FakeApplicationProvider* paramAppli, FakeGPSProvider* paramGPS, ParameterConfiguration* paramConf, ParameterNetwork* paramNetwork, GnAddr* gnAddr, HistoryPacketBuffer* hpb);
    //static int send(QByteArray payload, ParameterConfiguration* paramConf, ParameterNetwork* paramNetwork, bool containLPV);
    int send(QByteArray payloadToSend, bool containLPV, BasicHeader bh);

    //static QElapsedTimer timeLastLPVSent;
    static quint16 sequenceNumber;
    ForwardingAlgorithmResponse greedy(BasicHeader bh, CommonHeader ch, GACPacket packet, QByteArray payload, QByteArray sender, uchar* destination, uchar* forwarder);
    ForwardingAlgorithmResponse greedy(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray payload, QByteArray sender, uchar *destination, uchar *forwarder);
    ForwardingAlgorithmResponse greedy(BasicHeader bh, CommonHeader ch, GUCPacket packet, QByteArray payload, QByteArray sender);
    ForwardingAlgorithmResponse greedy(BasicHeader bh, CommonHeader ch, LSReplyPacket packet, QByteArray sender);

    ForwardingAlgorithmResponse simpleForwardingAlgorithm(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray packetPayload, e_shape shape, QByteArray sender, bool flagSrc);

    ForwardingAlgorithmResponse contentionBasedForwardingAlgorithm(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray packetPayload, e_shape shape, QByteArray sender, bool flagSrc);

    ForwardingAlgorithmResponse advancedForwarding(BasicHeader bh, CommonHeader ch, GBCPacket packet, QByteArray packetPayload, e_shape shape, QByteArray sender, uchar* destEth, uchar* forwarderEth, bool flagSrc);

    ForwardingAlgorithmResponse CBFUnicast(BasicHeader bh, CommonHeader ch, GACPacket packet, QByteArray packetPayload);
    ForwardingAlgorithmResponse CBFUnicast(BasicHeader bh, CommonHeader ch, GUCPacket packet, QByteArray packetPayload);


    QHash<int, QString> geonetErrors;
signals:
    void lpvSent();
    void packetReceived(QByteArray);

public slots:
    void execute();
    void treatPackets(QByteArray);
    void sendPacketFromRPB(gnDataRequest_t rawPacket);
    void lpvUpdate();
    void sendBeacon();
    void utInitialize();
    int lsRetransmit(GnAddr destination, QByteArray lsRequestData, BasicHeader bh);

private slots:
    int sendGUC(gnDataRequest_t gnDR);
    void socketReadyRead();

private:
    void initGeoNetErrors();


    int sendLsRequest(GnAddr dest, gnDataRequest_t gnDR);
    int sendGAC(gnDataRequest_t gnDR);
    int sendGBC(gnDataRequest_t gnDR);
    //int sendGUC(gnDataRequest_t gnDR);
    int sendSHB(gnDataRequest_t gnDR);
    int sendTSB(gnDataRequest_t gnDR);

    int basicHeaderProcessing(uchar* packet, int len, sniff_ethernet_t* eth);
    int commonHeaderProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh);
    int beaconPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int gacPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int gbcPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int gucPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int shbPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int tsbPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int LSRequestPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);
    int LSReplyPacketProcessing(uchar* packet, sniff_ethernet_t* eth, BasicHeader bh, CommonHeader ch);

    void sendEventIndicationToUT(uchar* packetFull, int packetLen);

    //void handleBasicHeader(BasicHeader);
    int InitRawSocket_send();

    void verifLocT();

    QTimer *m_beacon;
    QUdpSocket* gen2fac;
    QUdpSocket* gen2ut;
    QSslSocket* m_sslSocket;
    QTcpSocket* m_tcpSocket;
    ParameterHybrid* m_paramHybrid;
    bool m_hybridFlag;
    bool m_geonetFlag;
    void initHybridSocket();
    void sslErrors(const QList<QSslError> &errors);
    void socketError(QAbstractSocket::SocketError);
    void setupUnsecureSocket();
    void setupSecureSocket();
    int hybridSend(QByteArray payload);

    FakeGPSProvider* m_paramGPS;
    FakeCANProvider* m_paramCAN;
    FakeApplicationProvider* m_paramAppli;
    ParameterConfiguration* m_paramConf;
    ParameterUpperTester* m_paramUpperTester;
    ParameterNetwork* m_paramNetwork;
    ParameterSecurity* m_paramSecu;
    GnAddr* m_gnAddr;
    Manager* m_manager;
    HistoryPacketBuffer* m_HPB;
    BroadcastForwardingPacketBuffer* m_BCFPB;
    UnicastForwardingPacketBuffer* m_UCFPB;
    CBFPacketBuffer* m_CBFPB;
    RepetitionPacketBuffer* m_RPB;
    LocationServicePacketBuffer* m_LSPB;
    QHash<QByteArray, LocationTableEntry>* m_locationTable;
    ReceivePackets* m_RP;
    QHash<QByteArray, int> m_lsRetransmission;
    QMutex* m_mutex;
    QMutex* m_mutexLocT;
    QHash<QByteArray, int> m_CBFPBCounter;
    void flushPB(GnAddr destination);

    void flushLSPB(GnAddr destination);
    void checkUCFPB();
    void flushUCFPB(GnAddr destination);
    void checkBCFPB();

    int TO_CBF_GBC(int distance);
    int TO_CBF_GUC(int distance);

    void calculAngleThreshold();

    int m_angleThreshold;
    ForwardingAlgorithmResponse greedy(PacketBuffersEntry packet, QByteArray sender);

    /* Security layer */
    QByteArray getSecuredPayload(QByteArray payload, BasicHeader bh);
    QByteArray verifySecuredPayload(QByteArray payload, bool *success);
    QUdpSocket *m_signatureSocket;
    QUdpSocket *m_verifySocket;
    SecurityManager m_securityManager;
};

#endif // _Geonet_H_