gzDistTransport.h

Go to the documentation of this file.

//***************************************************************************
// File         : gzDistTransport.h
// Module       : gzRemoteDistribution
// Description  : Definition of gzDistTransportInterface
// Author       : Anders Sandblad       
// Product      : GizmoDistribution 2.1.1
//      
// Copyright © 2004 - Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoDistribution is a toolkit used for implementing distributed 
//          objects and events in C++
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// XAA  031113  Created file    
//
//***************************************************************************
#ifndef __GZ_DIST_TRANSPORT_H__
#define __GZ_DIST_TRANSPORT_H__

// Includes
#include "gzDistBase.h"


// Default socket buffer size for sending an receiving
#ifdef GZ_WIN32

    const gzULong GZ_DIST_DEFAULT_SEND_SOCKET_BUFFER = 256 * 1024 - 1;  // 256 kB

    const gzULong GZ_DIST_DEFAULT_RECV_SOCKET_BUFFER = 1024 * 1024 - 1; // 1 MB

#else

    // Unix usually limit the buffer size to 65535 bytes.
    // System parameters will have to be changed if you need larger buffers.
    // On Linux that would be sysctl net.core.wmem_max and net.core.rmem_max.

    const gzULong GZ_DIST_DEFAULT_SEND_SOCKET_BUFFER = 64 * 1024 - 1;   // 64 kB

    const gzULong GZ_DIST_DEFAULT_RECV_SOCKET_BUFFER = 64 * 1024 - 1;   // 64 kB

#endif


//------------------------ gzDistTransportInterface -------------------------


class GZ_REMOTE_EXPORT gzDistTransportInterface
{
    public:

        gzDistTransportInterface() { };

        virtual ~gzDistTransportInterface() { };


        virtual gzBool open() = 0;

        virtual gzVoid close() = 0;

        virtual gzBool isOpen() const = 0; 
        
        virtual gzBool isConnected() = 0;



        virtual gzBool send(const gzUByte* buffer, gzULong length) = 0;


        virtual gzInt receive(gzUByte* buffer, gzULong length,  gzULong timeout = 0) = 0;


};


//--------------------------- gzDistTransportUDP ----------------------------


class gzDistTransportUDP : public gzDistTransportInterface
{
    public:


        GZ_REMOTE_EXPORT explicit gzDistTransportUDP(gzULong sendBuffer = GZ_DIST_DEFAULT_SEND_SOCKET_BUFFER,
                                                        gzULong recvBuffer = GZ_DIST_DEFAULT_RECV_SOCKET_BUFFER);

        GZ_REMOTE_EXPORT virtual ~gzDistTransportUDP();



        GZ_REMOTE_EXPORT gzBool createUnicast(const gzHostAddress& destAddress, gzUShort port, const gzHostAddress& interfaceAddress = gzHostAddress());


        GZ_REMOTE_EXPORT gzBool createMulticast(const gzSocketAddress& multicastAddress, const gzHostAddress& interfaceAddress = gzHostAddress());
        

        GZ_REMOTE_EXPORT gzBool createBroadcast(gzUShort port, const gzHostAddress& interfaceAddress = gzHostAddress());


        GZ_REMOTE_EXPORT gzBool open();

        GZ_REMOTE_EXPORT gzVoid close();

        GZ_REMOTE_EXPORT gzBool isOpen() const;

        GZ_REMOTE_EXPORT gzBool isConnected();

        GZ_REMOTE_EXPORT gzBool send(const gzUByte* buffer, gzULong length);

        GZ_REMOTE_EXPORT gzInt receive(gzUByte* buffer, gzULong length,  gzULong timeout = 0);



    private:

        // UDP protocol type
        enum gzDistProtocolType
        {
            UNDEF = 0,
            UNICAST,
            MULTICAST,
            BROADCAST
        };

        gzDistProtocolType m_protocolType;

        gzBool m_open;

        gzULong m_sendBufferSize;
        gzULong m_recvBufferSize;

        gzSocketAddress m_destinationAddress;
        gzHostAddress m_interfaceAddress;

        gzSocket m_sendSocket;
        gzSocketAddress m_sendSocketAddress;

        gzSocket m_receiveSocket;
        gzSocketAddress m_receiveSocketAddress;

        gzSocketAddress m_senderAddress;
};


//--------------------------- gzDistTransportTCP ----------------------------


class gzDistTransportTCP : public gzDistTransportInterface, protected gzThread
{
    public:
        

        GZ_REMOTE_EXPORT gzDistTransportTCP(gzULong sendBuffer = GZ_DIST_DEFAULT_SEND_SOCKET_BUFFER,
                                            gzULong recvBuffer = GZ_DIST_DEFAULT_RECV_SOCKET_BUFFER);

        GZ_REMOTE_EXPORT virtual ~gzDistTransportTCP();

        

        GZ_REMOTE_EXPORT gzBool createClient(const gzSocketAddress& remoteAddress);


        GZ_REMOTE_EXPORT gzBool createClient(gzSocket* connection);
        

        GZ_REMOTE_EXPORT gzBool createServer(gzUShort listenPort, const gzHostAddress& interfaceAddress = gzHostAddress(0,0,0,0));


        GZ_REMOTE_EXPORT gzBool open();

        GZ_REMOTE_EXPORT gzVoid close();



        GZ_REMOTE_EXPORT gzBool isOpen() const; 


        GZ_REMOTE_EXPORT gzBool isConnected();

        GZ_REMOTE_EXPORT gzBool isServer() const;

        GZ_REMOTE_EXPORT gzBool send(const gzUByte* buffer, gzULong length);

        GZ_REMOTE_EXPORT gzInt receive(gzUByte* buffer, gzULong length,  gzULong timeout = 0);



        GZ_REMOTE_EXPORT gzSocketAddress getClientConnectAddress();


        GZ_REMOTE_EXPORT gzSocketAddress getServerListenAddress();


    private:

        gzVoid process();

        gzVoid serverProcess();

        
        gzBool openClient();

        gzVoid closeClient();

        gzBool openServer();

        gzVoid closeServer(gzBool wait = TRUE);


    private:

        static const gzULong PROTOCOL_ID; // "magic" protocol identifier

        gzBool m_open;
        gzBool m_server;

        gzULong m_sendBufferSize;
        gzULong m_recvBufferSize;

        gzSocketAddress m_remoteAddress;

        gzSocket* m_clientSocket;
        gzSocketAddress m_clientSocketAddress;

        gzSocket* m_serverSocket;
        gzSocketAddress m_serverSocketAddress;

        gzArray<gzUByte> m_pendingBuffer;
        gzUByte* m_pendingPos;
        gzULong m_pendingLength;

};


//------------------------- gzDistTransportPipe -----------------------------


class gzDistTransportPipe : public gzDistTransportInterface, protected gzThread
{
    public:


        GZ_REMOTE_EXPORT gzDistTransportPipe(const gzString& name, gzBool server = FALSE, gzPipeConnection connection = GZ_PIPE_GLOBAL);

        GZ_REMOTE_EXPORT virtual ~gzDistTransportPipe();


        GZ_REMOTE_EXPORT gzBool open();

        GZ_REMOTE_EXPORT gzVoid close();

        GZ_REMOTE_EXPORT gzBool isOpen() const;

        GZ_REMOTE_EXPORT gzBool isConnected();

        GZ_REMOTE_EXPORT gzBool isServer() const;

        GZ_REMOTE_EXPORT gzBool send(const gzUByte* buffer, gzULong length);

        GZ_REMOTE_EXPORT gzInt receive(gzUByte* buffer, gzULong length,  gzULong timeout = 0);


    private:

        gzVoid process();

        gzVoid serverProcess();


    private:

        static const gzULong PROTOCOL_ID; // "magic" protocol identifier

        gzBool m_open;
        gzBool m_server;

        gzString m_name;
        gzPipeConnection m_connection;

        gzPipe* m_serverPipe;
        gzPipe* m_clientPipe;

        gzArray<gzUByte> m_pendingBuffer;
        gzUByte* m_pendingPos;
        gzULong m_pendingLength;
};


//-------------------------- gzDistSocketServer -----------------------------


class gzDistSocketServer : public gzThread
{
    public:

        GZ_REMOTE_EXPORT gzDistSocketServer();

        GZ_REMOTE_EXPORT virtual ~gzDistSocketServer();


        GZ_REMOTE_EXPORT virtual gzBool run(gzUShort port, gzULong maxConn = 0, const gzHostAddress& ifaceAddr = gzHostAddress(0,0,0,0));


        GZ_REMOTE_EXPORT virtual gzVoid stop(gzBool wait = TRUE);
    


        GZ_REMOTE_EXPORT virtual gzVoid onConnect(gzSocket* socket) = 0;


    private:

        GZ_REMOTE_EXPORT gzVoid process();

        gzVoid listen();


    private:

        gzSocket m_socket;

        gzULong m_maxConnections;

};


#endif

---