EthernetCommunication.h

#pragma once
#include <string>
#include <tchar.h>
#include <iostream>
#include <atomic>
#include <Ws2tcpip.h>
#include <winsock2.h>
#include <Windows.h>
#include <thread>
#include <sstream>
#include <semaphore> 
#include <queue>
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "Iphlpapi.lib")
#include "BaseCommunication.h"
#include "EthernetSettings.h"
#include "BaseDataExtractor.h"
#include "Utility.h"
#include "DevicePinger.h"
#include "CommunicationStructures.h"
#include "CommunicationEnumeration.h"
#include "ClockUtilities.h"
#include <IPTypes.h>
#include <iphlpapi.h>
 
using namespace std;
 
#ifdef STARFLEETTOOLBOX_EXPORTS
#define ETHCOMM __declspec(dllexport)
#else
#define ETHCOMM __declspec(dllimport)
#endif
 
#define DATA_READY 1
#define DATA_NOT_READY 0
 
#define INTERFACE_IS_IN_SAME_NET 0
#define INTERFACE_IS_NOT_IN_SAME_NET 1
#define INTERFACE_NOT_USED 2
#define INTERFACE_INVALID_MASKING 3
 
 
class ETHCOMM EthernetCommunication :
    public BaseCommunication
{
public:
    const int TCP_NEWORKQUEUE_OVERFLOWLIMIT = 20;
    const int TCP_RAWDATA_QUEUE_OVERFLOWLIMIT = 20;
    const int MAX_SIZE_TO_READ = 40000;
    const int COMMAND_ACK_TIMEOUT = 8000;
 
    EthernetCommunication();
 
 
    EthernetCommunication(MONITORING_MODE monitoring);
 
    EthernetCommunication(EthernetSettings* settings);
 
    EthernetCommunication(EthernetSettings* settings, MONITORING_MODE monitoring);
 
    ~EthernetCommunication();
 
    CommunicationStatus Connect();
 
 
    void Disconnect();
 
    string SendCommand(string commandToSend);
 
    string SendCommand(string commandToSend, int specificTimeout);
 
    RawData WaitForRawData(int waitTimeout, unsigned long* semStatus);
 
private:
    in_addr stringToInAddr(const string& ipStr);
    int isInSameSubnet(const string& ipAddr, const string& subnetAddr, const string& subnetMask);
    ConnectionState IsSensorInSameNet(const string& sensorIp);
    PIP_ADAPTER_INFO FindAdapterForSecoket(SOCKET s);
 
    PIP_ADAPTER_INFO _tcpAdapterInfo;
 
    atomic<chrono::time_point<std::chrono::steady_clock>> _lastTcpDataTime;
    atomic<chrono::time_point<std::chrono::steady_clock>> _lastUdpDataTime;
 
    CommErrorCode GetLastErrorCode();
    CommunicationStatus GetConnectionStatus();
 
    CommunicationStatus Reconnect();
 
    void StopAndClean();
 
    CommunicationStatus ConnectTcp();
 
    CommunicationStatus ConnectUdp();
 
    void DisconnectTcp();
 
    void DisconnectUdp();
 
    // TCP WORKER VARIABLES AND METHODS
    thread _tcpWorker;
 
    void StartTcpWorker();
 
    void TcpWorkerBusiness(string name);
    std::atomic<bool>  _stopTcpThread;
    string _commandAckAnswer;
    HANDLE _mutexcommandAckAnswer;      // semaphore to protect the _commandAckAnswer concurent access
    HANDLE _semCommandAckAvailable;     // semaphore to warn that Command ACK is available
    HANDLE _mutexSendAvailable;         // prevent the socket to be used from another process to send data
    void setCommandAckAnswer(string pCommandAckAnswer);
 
    string getCommandAckAnswer();
    // END OF TCP WORKER VARIABLES AND METHODS
 
    // UDP WORKER VARIABLES AND METHODS
    thread _udpWorker;
 
    void StartUdpWorker();
 
    void UdpWorkerBusiness(string name);
    std::atomic<bool>  _stopUdpThread;
    // END UDP WORKER VARIABLES AND METHODS
 
    
    int ProcessRawData(string dataPacket, vector<string>* dataVector);
 
    queue<RawData> _rawDataQueue;       // the MDI Raw data queue that contains the encapsulated raw data    
    HANDLE _mutexRawDataQueue;          // protects the MDI Raw data queue from multi process access
    HANDLE _semRawDataAvailable;        // semaphore to warn that RAW Data are available
    // END OF WORKER VARIABLES AND METHODS
    
    //MODE _mode = UDP;
    SOCKET _tcpSocket;
    SOCKET _udpSocket;   
    DevicePinger _pinger;
    std::atomic<bool> _wasWired;
 
    bool _dataRequested = false;
};