|| || || || || || || ||

---

AlertRelay.h

Go to the documentation of this file.

#ifndef Impala_Application_SDash_AlertRelay_h
#define Impala_Application_SDash_AlertRelay_h

#include <string>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>

#define DEFAULT_TCP_BUFLEN 512

namespace Impala {
namespace Application {
namespace SDash {

class AlertRelay
{

public:

    AlertRelay(const std::string& ipAddress = DEFAULT_IP, const std::string& port = DEFAULT_PORT) : mState(-1)
    {
        mState = Initialize(ipAddress, port);
    }

    virtual ~AlertRelay()
    {
        if (IsReady())
        {
            int result = CloseSockets();
            mState = -1;
        }
    }

    bool IsReady()
    {
        return (mState == 0);
    }

    int Relay(const std::string& msg)
    {
        if (!IsReady())
        {
            printf("AlertRelay not ready; unable to send message: %s", msg);
            return 1;
        }

        std::string completeMsg = "05" + msg;
        if (mClientSocket == INVALID_SOCKET)
        {
            //if (AcceptWithoutBlocking(&mListenSocket, &mClientSocket) != 0)
            //{
            //    closesocket(mClientSocket);
            //    mClientSocket = INVALID_SOCKET;
            //    return 2; // transmission error; exit
            //}
            AcceptWithoutBlocking(&mListenSocket, &mClientSocket);
        }
        //else
        //{
        //    // test if recent client is still alive;
        //    // SK: this impl. does NOT work!
        //    fd_set currentClientSocketSet;
        //    FD_ZERO(&currentClientSocketSet);
        //    FD_SET(mClientSocket, &currentClientSocketSet);
        //    TIMEVAL timeVal = {2, 0};
        //    int validmClientSockets = select(0, 0, &currentClientSocketSet, 0, &timeVal);
        //    if (validmClientSockets < 1)
        //    {
        //        printf("client socket has become obsolete\n");

        //        if (AcceptWithoutBlocking(&mListenSocket, &mClientSocket) != 0)
        //            return 3; // transmission error; exit
        //    }
        //}

        //int iResult, iSendResult;
        if (mClientSocket != INVALID_SOCKET)
        {
            int len = completeMsg.length();
            int iSendResult = send( mClientSocket, completeMsg.c_str(), len, 0);
            int err = WSAGetLastError();
            if (iSendResult == SOCKET_ERROR) 
            {
                printf("send failed: %d\n", err);
                printf("Transmission of message failed: %s\n", completeMsg.c_str());
                closesocket(mClientSocket);
                mClientSocket = INVALID_SOCKET;
                return 4;;
            }
            printf("Message sent: %s\n", completeMsg.c_str());
        }
        else
            printf("Transmission of message skipped: %s\n", completeMsg.c_str());

        return 0;
    }


private:

    static const char* DEFAULT_PORT;
    static const char* DEFAULT_IP;

    int mState;
    
    SOCKET mListenSocket;
    SOCKET mClientSocket;

    int Initialize(const std::string& ipAddress, const std::string& port)
    {
            mListenSocket = SetupListening(ipAddress, port);
            if (mListenSocket == INVALID_SOCKET)
        {
            printf("Setting up listening socket failed failed; unable to relay messages\n");
                    return 1;
        }

        mClientSocket = INVALID_SOCKET;

        return 0;
    }

    SOCKET SetupListening(const std::string& ipAddress, const std::string& port)
    {
        WSADATA wsaData;
        SOCKET ListenSocket = INVALID_SOCKET;
        struct addrinfo *result = NULL,
                        hints;
        
        // Initialize Winsock
        int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
        if (iResult != 0) {
            printf("WSAStartup failed: %d\n", iResult);
            return INVALID_SOCKET;
        }

        ZeroMemory(&hints, sizeof(hints));
        hints.ai_family = AF_INET;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
        hints.ai_flags = AI_PASSIVE;

        // Resolve the server address and port
        iResult = getaddrinfo(ipAddress.c_str(), port.c_str(), &hints, &result);
        if ( iResult != 0 ) {
            printf("getaddrinfo failed: %d\n", iResult);
            WSACleanup();
            return INVALID_SOCKET;
        }
        
        // Create a SOCKET for connecting to server
        ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
        if (ListenSocket == INVALID_SOCKET) {
            printf("socket failed: %ld\n", WSAGetLastError());
            freeaddrinfo(result);
            WSACleanup();
            return INVALID_SOCKET;
        }

        // Setup the TCP listening socket
        iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
        if (iResult == SOCKET_ERROR) {
            printf("bind failed: %d (error 10049: is the server IP address %s valid?)\n", WSAGetLastError(), ipAddress.c_str());
            freeaddrinfo(result);
            closesocket(ListenSocket);
            WSACleanup();
            return INVALID_SOCKET;
        }

        freeaddrinfo(result);

        iResult = listen(ListenSocket, SOMAXCONN);
        if (iResult == SOCKET_ERROR) {
            printf("listen failed: %d\n", WSAGetLastError());
            closesocket(ListenSocket);
            WSACleanup();
            return INVALID_SOCKET;
        }

        // set to non-blocking mode
        u_long argp = 1;
        int rc = ioctlsocket(ListenSocket, FIONBIO, &argp); 

        //Sleep(250);
            return ListenSocket;
    }

    // accepts a pending socket request if present; 
    // wont block, and skip transmission in case no request pending
    int AcceptWithoutBlocking(SOCKET* listenSocket, SOCKET* clientSocket)
    {
        *clientSocket = accept(*listenSocket, NULL, NULL);
        int err = WSAGetLastError();
        if (*clientSocket == INVALID_SOCKET) 
        {
            if (err == WSAEWOULDBLOCK)
            {
                printf("No pending connection requests\n");
            }
            else
            {
                printf("accept failed: %d\n", err);
                return 1;
            }
        }

        return 0;
    }

    int CloseSockets()
    {
        // No longer need server socket
        closesocket(mListenSocket);

        if (mClientSocket != INVALID_SOCKET)
        {
            // shutdown the connection since we're done
            int iResult = shutdown(mClientSocket, SD_SEND);
            if (iResult == SOCKET_ERROR) {
                printf("shutdown failed: %d\n", WSAGetLastError());
                closesocket(mClientSocket);
                WSACleanup();
                return 1;
            }

            // cleanup
            closesocket(mClientSocket);
        }

        WSACleanup();
        return 0;
    }

}; // class AlertRelay

const char* AlertRelay::DEFAULT_IP = "127.0.0.1";
const char* AlertRelay::DEFAULT_PORT = "10000";

}
}
}

#endif

---