mainGeonet.cpp

Go to the documentation of this file.

#include <stdlib.h>
#include <signal.h>
#include <iostream>
#include <QMutex>
#include <QCoreApplication>
#include <GPSProvider.h>
#include <Geonet.h>
#include <Manager.h>
#include <UpperTester.h>
#include <QTimer>
#include <QThread>
#include <Facilities.h>
#include <getopt.h>
#include <unistd.h>
#include <ParameterUpperTester.h>
#include <ParameterDENM.h>
#include <QMetaType>
//#include <BluetoothBridge.h>
#include <DENM.h>
#include <ApplicationManagement.h>

#include <decodeSecurity.h>

Q_DECLARE_METATYPE(ActionID_t)
Q_DECLARE_METATYPE(DENM_t*)

void help(char* argv)
{
    fprintf(stderr, "Usage : %s <abcfCDgHnuh>\n"
                    "-a --application     Activate the application management\n"
                    "-b --bluetooth       Activate the Bluetooth communication\n"
                    "-c --can             Use the CAN provider\n"
                    "-f --facilities      Activate the facilities layer\n"
                    "    -C --cam         Activate CAM only\n"
                    "    -D --denm        Activate DENM only\n"
                    "-g --gps             Use the GPS provider\n"
                    "-H --hybrid          Activate the hybridization\n"
                    "-n --geonet          Activate the GeoNetworking layer\n"
                    "-u --upperTester     Activate the UpperTester\n"
                    "-h --help            Print this message and quit\n", argv);
    QFile file("/etc/its/security/FR01IDN00000001-AT16-verification.cert");
    file.open(QIODevice::ReadOnly);
    QByteArray content = file.readAll();
    file.close();
    Certificate_t cert;
    decode_Certificate((unsigned char*)content.data(), &cert);
    asn_fprint(stdout, &asn_DEF_Certificate, &cert);
}

void cleanExit(int sig)
{
    Q_UNUSED(sig);
    printf("\nFin volontaire\n\n");
    exit(0);
}

int main(int argc, char *argv[])
{
    signal(SIGINT, cleanExit);
    QCoreApplication a(argc, argv);

    setenv("TZ", "UTC", 1);
    tzset();

    qRegisterMetaType<gnDataRequest_t>("gnDataRequest_t");
    qRegisterMetaType<GBCPacket>("GBCPacket");
    qRegisterMetaType<GUCPacket>("GUCPacket");
    qRegisterMetaType<ActionID_t>("ActionID_t");
    qRegisterMetaType<DENM_t*>("DENM_t*");

    char c;
    bool applicationFlag = false, bluetoothFlag = false, canFlag = false, facilitiesFlag = false, geonetFlag = false,
            gpsFlag = false, upperTesterFlag = false, helpFlag = false, camFlag = false, denmFlag = false, hybridFlag = false;

    static struct option long_options[] =
    {
    {"application",     no_argument, 0, 'a'},
    {"bluetooth",       no_argument, 0, 'b'},
    {"can",             no_argument, 0, 'c'},
    {"facilities",      no_argument, 0, 'f'},
        {"cam",         no_argument, 0, 'C'},
        {"denm",        no_argument, 0, 'D'},
    {"gpsProvider",     no_argument, 0, 'g'},
    {"hybrid",          no_argument, 0, 'H'},
    {"geonet",          no_argument, 0, 'n'},
    {"upperTester",     no_argument, 0, 'u'},
    {"help",            no_argument, 0, 'h'},
    {0, 0, 0, 0}
    };

    int option_index = 0;
    if(argc > 1)
    {
        while((c = getopt_long(argc, argv, "abcfCDgHnuh", long_options, &option_index)) != -1)
        {
            switch(c)
            {
            case 0:
                if (long_options[option_index].flag != 0)
                    break;
                printf ("option %s", long_options[option_index].name);
                if (optarg)
                    printf (" with arg %s", optarg);
                printf ("\n");
                return -1;
                break;
            case 'a':
                applicationFlag = true;
                break;
            case 'b':
                bluetoothFlag = true;
                break;
            case 'c':
                canFlag = true;
                break;
            case 'f':
                facilitiesFlag = true;
                break;
            case 'n':
                geonetFlag = true;
                break;
            case 'g':
                gpsFlag = true;
                break;
            case 'u':
                upperTesterFlag = true;
                break;
            case 'h':
                helpFlag = true;
                break;
            case 'H':
                hybridFlag = true;
                break;
            case 'C':
                facilitiesFlag = true;
                camFlag = true;
                break;
            case 'D':
                facilitiesFlag = true;
                denmFlag = true;
                break;
            default:
                return -1;
                break;
            }
        }
    }
    else
    {
        help(argv[0]);
        exit(EXIT_FAILURE);
    }

    if(helpFlag)
    {
        help(argv[0]);
        exit(EXIT_SUCCESS);
    }

    qsrand(time(NULL));

    QMutex* mutex = new QMutex;

    ParameterDENM* denm;
    ParameterUpperTester* paramUt;
    FakeGPSProvider* gps = 0;
    FakeCANProvider* can = 0;
    FakeApplicationProvider* application = 0 ;
    Manager* man = 0;
    GeoNet* gn = 0;
    Facilities* fac = 0;
    UpperTester* ut = 0;

    denm = new ParameterDENM;

    if(upperTesterFlag)
        paramUt = new ParameterUpperTester;
    else
        paramUt = 0;

    if(gpsFlag && !upperTesterFlag)
    {
        QThread* threadGPS = new QThread;
        gps = new GPSProvider();
        gps->moveToThread(threadGPS);
        QObject::connect(threadGPS, SIGNAL(started()), gps, SLOT(execute()));
        threadGPS->start();
    }
    else
        gps = new FakeGPSProvider(mutex);

    if(canFlag && !upperTesterFlag)
        can = new FakeCANProvider(mutex);
    else
        can = new FakeCANProvider(mutex);

    if(applicationFlag && !upperTesterFlag)
        application = new FakeApplicationProvider(mutex);
    else
        application = new FakeApplicationProvider(mutex);


    QThread* threadManager = new QThread;
    man = new Manager(mutex, gps, can, denm, application, paramUt);
    man->moveToThread(threadManager);
    QObject::connect(threadManager, SIGNAL(started()), man, SLOT(execute()));
    threadManager->start();

    QThread* threadGeonet = new QThread;
    gn = new GeoNet(man, geonetFlag, hybridFlag, mutex);
    gn->moveToThread(threadGeonet);
    QObject::connect(threadGeonet, SIGNAL(started()), gn, SLOT(execute()));
    threadGeonet->start();


    ApplicationManagement *appManagement = new ApplicationManagement(man, bluetoothFlag, upperTesterFlag, applicationFlag);
    QThread* threadApplication = new QThread;
    appManagement->moveToThread(threadApplication);
    //QObject::connect(threadApplication, SIGNAL(started()), appManagement, SLOT(execute()));
    threadApplication->start();

    if(facilitiesFlag)
    {
        printf("UT = %d\n", upperTesterFlag);
        QThread* threadFacilities = new QThread;
        fac = new Facilities(man, gn, camFlag, denmFlag, bluetoothFlag, upperTesterFlag, mutex);
        fac->moveToThread(threadFacilities);
        QObject::connect(threadFacilities, SIGNAL(started()), fac, SLOT(execute()));
        threadFacilities->start();
    }

    if(upperTesterFlag)
    {
        ut = new UpperTester(man, can, gps, gn, fac, mutex);
    }

    return a.exec();
}