cmd/lms/LMEConnection.h

/*******************************************************************************
 * Copyright (C) 2004-2008 Intel Corp. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  - Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *  - Neither the name of Intel Corp. nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/

#ifndef __LME_CONNECTION_H__
#define __LME_CONNECTION_H__

#if defined(__sun) || defined(_LINUX)
#include "HECIUnix.h"
#else
#include "HECIWin.h"
#endif

#include <map>
#include <string>
#include "LMS_if.h"
#include "Thread.h"
#include "Semaphore.h"
#include "Event.h"
#include "ATNetworkTool.h"


struct AuthMethodData {
};

struct AuthPasswordData : AuthMethodData {
    std::string Password;
};

struct LMEMessage {

    LMEMessage(APF_MESSAGE_TYPE type) :
        MessageType(type) {}

    const APF_MESSAGE_TYPE MessageType;
};

struct LMEDisconnectMessage : LMEMessage {

    LMEDisconnectMessage(APF_DISCONNECT_REASON_CODE reasonCode) :
        LMEMessage(APF_DISCONNECT),
        ReasonCode(reasonCode) {}

    APF_DISCONNECT_REASON_CODE ReasonCode;
};

struct LMEServiceRequestMessage : LMEMessage {

    LMEServiceRequestMessage(std::string serviceName = "") :
        LMEMessage(APF_SERVICE_REQUEST),
        ServiceName(serviceName) {}

    std::string ServiceName;
};

struct LMEGlobalRequestMessage : LMEMessage {

    enum REQUEST_TYPE {
        TCP_FORWARD_REQUEST,
        TCP_FORWARD_CANCEL_REQUEST,
        UDP_SEND_TO
    };

    LMEGlobalRequestMessage(REQUEST_TYPE type) :
        LMEMessage(APF_GLOBAL_REQUEST),
        RequestType(type) {}

    const REQUEST_TYPE RequestType;
};

struct LMEProtocolVersionMessage : LMEMessage {

    LMEProtocolVersionMessage(UINT32 majorVersion = 0,
                  UINT32 minorVersion = 0,
                  APF_TRIGGER_REASON triggerReason = LME_REQUEST) :
        LMEMessage(APF_PROTOCOLVERSION),
        MajorVersion(majorVersion),
        MinorVersion(minorVersion),
        TriggerReason(triggerReason) {}

    UINT32 MajorVersion;
    UINT32 MinorVersion;
    APF_TRIGGER_REASON TriggerReason;

    struct LMEProtocolVersionMessage &operator=(const struct LMEProtocolVersionMessage &y)
    {
        if (this != &y) {
            this->MajorVersion = y.MajorVersion;
            this->MinorVersion = y.MinorVersion;
        }
        return *this;
    };
    bool operator<(const struct LMEProtocolVersionMessage &y) const
    {
        if (this->MajorVersion != y.MajorVersion) {
            return (this->MajorVersion < y.MajorVersion);
        }
        return (this->MinorVersion < y.MinorVersion);
    }
    bool operator>(const struct LMEProtocolVersionMessage &y) const
    {
        if (this->MajorVersion != y.MajorVersion) {
            return (this->MajorVersion > y.MajorVersion);
        }
        return (this->MinorVersion > y.MinorVersion);
    }
};

struct LMEUserAuthRequestMessage : LMEMessage {

    LMEUserAuthRequestMessage(std::string username = "",
                  std::string serviceName = "",
                  std::string methodName = "",
                  AuthMethodData *methodData = NULL) :
        LMEMessage(APF_USERAUTH_REQUEST),
        Username(username),
        ServiceName(ServiceName),
        MethodName(methodName),
        MethodData(methodData) {}

    std::string Username;
    std::string ServiceName;
    std::string MethodName;

    AuthMethodData *MethodData;
};


struct LMETcpForwardRequestMessage : LMEGlobalRequestMessage {

    LMETcpForwardRequestMessage(std::string address = "", UINT32 port = 0) :
        LMEGlobalRequestMessage(TCP_FORWARD_REQUEST),
        Address(address),
        Port(port) {}

    std::string Address;
    UINT32 Port;
};

struct LMETcpForwardCancelRequestMessage : LMEGlobalRequestMessage {

    LMETcpForwardCancelRequestMessage(std::string address = "", UINT32 port = 0) :
        LMEGlobalRequestMessage(TCP_FORWARD_CANCEL_REQUEST),
        Address(address),
        Port(port) {}

    std::string Address;
    UINT32 Port;
};

struct LMEUdpSendToMessage : LMEGlobalRequestMessage {

    LMEUdpSendToMessage(std::string address = "", UINT32 port = 0,
                UINT32 dataLength = 0, UINT8 *data = NULL) :
        LMEGlobalRequestMessage(UDP_SEND_TO),
        Address(address),
        Port(port),
        DataLength(dataLength)
    {
        if ((data != NULL) && (dataLength != 0)) {
            Data = new UINT8[dataLength];
            memcpy(Data, data, dataLength);
        } else {
            Data = NULL;
        }

    }

    ~LMEUdpSendToMessage()
    {
        if (Data != NULL) {
            delete[] Data;
            Data = NULL;
        }
    }

    std::string Address;
    UINT32 Port;
    UINT32 DataLength;
    UINT8 *Data;
};

struct LMEChannelOpenRequestMessage : LMEMessage {

    enum CHANNEL_TYPE {
        FORWARDED,
        DIRECT
    };

    LMEChannelOpenRequestMessage(CHANNEL_TYPE channelType = FORWARDED,
                     UINT32 senderChannel = 0,
                     UINT32 initialWindow = 0,
                     std::string address = "", UINT32 port = 0) :
        LMEMessage(APF_CHANNEL_OPEN),
        ChannelType(channelType),
        SenderChannel(senderChannel),
        InitialWindow(initialWindow),
        Address(address),
        Port(port) {}

    CHANNEL_TYPE ChannelType;
    UINT32 SenderChannel;
    UINT32 InitialWindow;
    std::string Address;
    UINT32 Port;
};

struct LMEChannelOpenReplaySuccessMessage : LMEMessage {

    LMEChannelOpenReplaySuccessMessage(UINT32 recipientChannel = 0,
                       UINT32 senderChannel = 0,
                       UINT32 initialWindow = 0) :
        LMEMessage(APF_CHANNEL_OPEN_CONFIRMATION),
        RecipientChannel(recipientChannel),
        SenderChannel(senderChannel),
        InitialWindow(initialWindow) {}

    UINT32 RecipientChannel;
    UINT32 SenderChannel;
    UINT32 InitialWindow;
};

struct LMEChannelOpenReplayFailureMessage : LMEMessage {

    LMEChannelOpenReplayFailureMessage(UINT32 recipientChannel = 0,
        OPEN_FAILURE_REASON reasonCode = OPEN_FAILURE_REASON_ADMINISTRATIVELY_PROHIBITED) :
        LMEMessage(APF_CHANNEL_OPEN_FAILURE),
        RecipientChannel(recipientChannel),
        ReasonCode(reasonCode) {}

    UINT32 RecipientChannel;
    OPEN_FAILURE_REASON ReasonCode;
};

struct LMEChannelCloseMessage : LMEMessage {

    LMEChannelCloseMessage(UINT32 recipientChannel = 0) :
        LMEMessage(APF_CHANNEL_CLOSE),
        RecipientChannel(recipientChannel) {}

    UINT32 RecipientChannel;
};

struct LMEChannelDataMessage : LMEMessage {

    LMEChannelDataMessage(UINT32 recipientChannel = 0,
                  UINT32 dataLength = 0,
                  UINT8 *data = NULL) :
        LMEMessage(APF_CHANNEL_DATA),
        RecipientChannel(recipientChannel),
        DataLength(dataLength)
    {
        if ((data != NULL) && (dataLength != 0)) {
            Data = new UINT8[dataLength];
            memcpy(Data, data, dataLength);
        } else {
            Data = NULL;
        }
    }

    ~LMEChannelDataMessage()
    {
        if (Data != NULL) {
            delete[] Data;
            Data = NULL;
        }
    }

    const UINT32 RecipientChannel;
    const UINT32 DataLength;
    UINT8 *Data;
};

struct LMEChannelWindowAdjustMessage : LMEMessage {

    LMEChannelWindowAdjustMessage(UINT32 recipientChannel = 0,
                      UINT32 bytesToAdd = 0) :
        LMEMessage(APF_CHANNEL_WINDOW_ADJUST),
        RecipientChannel(recipientChannel),
        BytesToAdd(bytesToAdd) {}

    UINT32 RecipientChannel;
    UINT32 BytesToAdd;
};

typedef void (*HECICallback)(void *param, void *buffer, unsigned int len, int *status);

class LMEConnection
{
public:
    LMEConnection(bool verbose = false);
    ~LMEConnection();

    bool Init(HECICallback cb, void *param);
    bool IsInitialized();
    bool Disconnect(APF_DISCONNECT_REASON_CODE reasonCode);
    bool ServiceAccept(std::string serviceName);
    bool UserAuthSuccess();
    bool ProtocolVersion(const LMEProtocolVersionMessage versionMessage);
    bool TcpForwardReplySuccess(UINT32 port);
    bool TcpForwardReplyFailure();
    bool TcpForwardCancelReplySuccess();
    bool TcpForwardCancelReplyFailure();
    bool ChannelOpenForwardedRequest(UINT32 sender, UINT32 connectedPort,
                     std::string originatorIP, UINT32 originatorPort);
    bool ChannelOpenReplaySuccess(UINT32 recipient, UINT32 sender);
    bool ChannelOpenReplayFailure(UINT32 recipient, UINT32 reason);
    bool ChannelClose(UINT32 recipient);
    int  ChannelData(UINT32 recipient, UINT32 len, unsigned char *buffer);
    bool ChannelWindowAdjust(UINT32 recipient, UINT32 len);

    //BACKWARD COMPATIBLE PUBLIC - BEGIN
    bool CompatProtocolVersion();
    bool CompatRequestIPFQDN();
    bool CompatOpenConnection(in_port_t mePort, ATAddress addr, unsigned int &connID);
    int  CompatSendMessage(UINT8 connID, UINT32 len, unsigned char *buffer);
    void CompatCloseConnection(int connID, int status);
    //BACKWARD COMPATIBLE PUBLIC - END

    void Deinit();
    unsigned int GetHeciBufferSize() const;

    enum INIT_STATES {
        INIT_STATE_DISCONNECTED = 0,
        INIT_STATE_CONNECTING,
        INIT_STATE_CONNECTED
    };

    static const UINT32 RX_WINDOW_SIZE;

    unsigned char protocolVer;

private:
    static const GUID _guid;

    static void _rxThreadFunc(void *param);

    void _doRX();
    int _receiveMessage(unsigned char *buffer, int len);
    int _sendMessage(unsigned char *buffer, int len);
    bool _checkMinMsgSize(unsigned char *buf, unsigned int bytesRead);
    void _apfGlobalRequest(unsigned char *rxBuffer, unsigned int bytesRead, int *status);
    void _apfUserAuthRequest(unsigned char *rxBuffer, unsigned int bytesRead, int *status);
    void _apfChannelOpen(unsigned char *rxBuffer, unsigned int bytesRead, int *status);
    void _apfChannelOpenDirect(unsigned char *rxBuffer, unsigned int bytesRead, UINT32 *senderChannel, int *status);


    unsigned char _reqID;
    unsigned char *_txBuffer;
    Thread *_rxThread;
    HECICallback _cb;
    void *_cbParam;
    Semaphore _initLock;
    Semaphore _sendMessageLock;
    INIT_STATES _initState;
    Event _threadStartedEvent;
#if defined(__sun) || defined(_LINUX)
    HECILinux _heci;
#else
    HECIWin _heci;
#endif

    //BACKWARD COMPATIBLE PRIVATE - BEGIN
    static const GUID _guidCompat;

    void _doRXCompat();

    struct CompatConnection {
        Event *event;
        int connID;
        UINT8 status;
    };
    typedef std::map<int, CompatConnection> CompatConnMap;
    CompatConnMap _compatPendingConnections;
    Semaphore _compatMapLock;
#if defined(__sun) || defined(_LINUX)
    HECILinux _heciCompat;
#else
    HECIWin _heciCompat;
#endif
    //BACKWARD COMPATIBLE PRIVATE - END

    HECI *_pHeci;
};

#endif