gzNetwork.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzNetwork.h
// Module       : gzBase
// Description  : Class definition of Network classes
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training System AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010404  Created file    
//
// ******************************************************************************

#ifndef __GZ_NETWORK_H__
#define __GZ_NETWORK_H__

#include "gzBasicTypes.h"
#include "gzMemory.h"
#include "gzDynamic.h"
#include "gzThread.h"
#include "gzNotify.h"


#ifdef WIN32
    typedef UINT_PTR    gzSocketHandle;
#else
    typedef gzLong      gzSocketHandle;
#endif


enum gzSocketFamily
{
    GZ_SOCKET_FAMILY_INET,  
    GZ_SOCKET_FAMILY_IRDA,  
    GZ_SOCKET_FAMILY_INET6  
};


enum gzSocketType
{
    GZ_SOCKET_TYPE_STREAM,
    GZ_SOCKET_TYPE_DATAGRAM
};


enum gzSocketOption
{
    GZ_SOCKET_OPTION_BROADCAST,                 
    GZ_SOCKET_OPTION_DONTROUTE,
    GZ_SOCKET_OPTION_USE_LINGER,                
    GZ_SOCKET_OPTION_DONT_USE_LINGER,           
    GZ_SOCKET_OPTION_KEEPALIVE,
    GZ_SOCKET_OPTION_REUSE_ADDR_PORT,
    GZ_SOCKET_OPTION_MULTICAST_TTL,
    GZ_SOCKET_OPTION_MULTICAST_INTERFACE,
    GZ_SOCKET_OPTION_MULTICAST_LOOPBACK,
    GZ_SOCKET_OPTION_ADD_MULTICAST_MEMBERSHIP,
    GZ_SOCKET_OPTION_DROP_MULTICAST_MEMBERSHIP,
    GZ_SOCKET_OPTION_RECEIVE_BUFFER,            
    GZ_SOCKET_OPTION_SEND_BUFFER,               
    GZ_SOCKET_OPTION_RECEIVE_TIMEOUT,           
};


enum gzSocketError
{
    GZ_SOCKET_ERROR_NO_ERROR = 0,
    GZ_SOCKET_ERROR_CHECK_FOR_ERROR,
    GZ_SOCKET_ERROR_UNKNOWN_ERROR,
    GZ_SOCKET_ERROR_PROTOCOL_FAMILY_NOT_SUPPORTED,
    GZ_SOCKET_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED,
    GZ_SOCKET_ERROR_PERMISSION_DENIED,
    GZ_SOCKET_ERROR_PROTOCOL_NOT_SUPPORTED,
    GZ_SOCKET_ERROR_NETWORK_NOT_INITIALISED,
    GZ_SOCKET_ERROR_CONNECTION_CLOSED,
    GZ_SOCKET_ERROR_UNKNOWN_SOCKET_OPTION,
    GZ_SOCKET_ERROR_SOCKET_NOT_CONFIGURED,
    GZ_SOCKET_ERROR_HOST_UNREACHABLE,
    GZ_SOCKET_ERROR_NETWORK_UNREACHABLE,
    GZ_SOCKET_ERROR_OPTION_NOT_SUPPORTED,
    GZ_SOCKET_ERROR_INVALID_DESCRIPTOR,
    GZ_SOCKET_ERROR_INVALID_ARGUMENT,
    GZ_SOCKET_ERROR_ADDRESS_IN_USE,
    GZ_SOCKET_ERROR_ADDRESS_NOT_AVAILABLE,
    GZ_SOCKET_ERROR_IS_CONNECTED,
    GZ_SOCKET_ERROR_NOT_CONNECTED,
    GZ_SOCKET_ERROR_CONNECTION_RESET,
    GZ_SOCKET_ERROR_CONNECTION_ABORTED,
    GZ_SOCKET_ERROR_CONNECTION_REFUSED,
    GZ_SOCKET_ERROR_CONNECTION_TIMEDOUT,
    GZ_SOCKET_ERROR_WOULD_BLOCK,
    GZ_SOCKET_ERROR_MESSAGE_SIZE,
    GZ_SOCKET_ERROR_OPERTATION_ABORTED,
    GZ_SOCKET_ERROR_NO_DEVICE,
    GZ_SOCKET_ERROR_XXX
};


// ------- Notification commands -----------

const gzString GZ_NET_DATA  = "NetData";


enum gzHostAddressType
{
    GZ_HOST_ADDRESS_TYPE_INVALID,
    GZ_HOST_ADDRESS_TYPE_DOT_4,
};


class gzHostAddress 
{
public:

    GZ_BASE_EXPORT gzHostAddress();

    GZ_BASE_EXPORT gzHostAddress(gzUByte a,gzUByte b,gzUByte c,gzUByte d);

    GZ_BASE_EXPORT gzHostAddress(const gzString &name);

    GZ_BASE_EXPORT explicit gzHostAddress(gzULong address);

    GZ_BASE_EXPORT virtual ~gzHostAddress() { m_address.setSize(0); }


    GZ_BASE_EXPORT gzBool operator==(const gzHostAddress &right);
    GZ_BASE_EXPORT gzBool operator!=(const gzHostAddress &right) { return !operator==(right); }


    GZ_BASE_EXPORT gzString             asString() const;

    GZ_BASE_EXPORT gzHostAddressType    getHostAddressType() const;

    GZ_BASE_EXPORT gzLongLong           asLongLong() const;

    GZ_BASE_EXPORT gzULong              asULong() const;

    GZ_BASE_EXPORT gzBool               isValid() const;

private:

    gzHostAddressType   m_type;
    gzArray<gzUByte>    m_address;
};


class gzHostInfo 
{
public:

    GZ_BASE_EXPORT gzHostInfo() : isValid(FALSE) {};

    gzString                hostName;

    gzArray<gzString>       hostAlias;

    gzArray<gzHostAddress>  hostAddress;

    gzBool                  isValid;
};


enum gzSocketAddressType
{
    GZ_SOCKET_ADDRESS_TYPE_UNKNOWN,
    GZ_SOCKET_ADDRESS_TYPE_INET,
};


class gzSocketAddress 
{
public:

    GZ_BASE_EXPORT gzSocketAddress();
    GZ_BASE_EXPORT virtual ~gzSocketAddress() {};

    GZ_BASE_EXPORT gzSocketAddress(gzUByte *sockaddr, gzULong bytes);
    GZ_BASE_EXPORT gzSocketAddress(gzUShort portNumber);
    GZ_BASE_EXPORT gzSocketAddress(const gzHostAddress &address, gzUShort portNumber);
    GZ_BASE_EXPORT gzSocketAddress(const gzString &name, gzUShort portNumber);

    GZ_BASE_EXPORT gzBool operator==(const gzSocketAddress &right);
    GZ_BASE_EXPORT gzSocketAddressType getAddressType();

    GZ_BASE_EXPORT gzULong getLength() const;
    GZ_BASE_EXPORT gzUByte * getData() const;


    GZ_BASE_EXPORT gzHostAddress    getHostAddress();
    GZ_BASE_EXPORT gzUShort         getPort();

protected:

    friend class gzSocket;

    gzArray<gzUByte>    m_addressData;
};


class gzNetData : public gzReference
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT)

    gzSocketAddress     sender;
    gzArray<gzUByte>    data;
};


//******************************************************************************
// Class    : gzSocket
//                                  
// Purpose  : Binding to tcp/udp ports
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010409  Created 
//                                  
//******************************************************************************
class   gzSocket : public gzThreadTicker , public gzNotifyManager , public gzTypeInterface
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);

    GZ_BASE_EXPORT  gzSocket();

    GZ_BASE_EXPORT  virtual ~gzSocket();


    // --- Setup routines ---

    GZ_BASE_EXPORT  gzBool create(gzSocketFamily family , gzSocketType type=GZ_SOCKET_TYPE_STREAM);
    
    GZ_BASE_EXPORT  gzVoid close(gzBool waitForRemoteConnection=TRUE);

    GZ_BASE_EXPORT  gzBool setOption(gzSocketOption option, gzDynamicType value);
 
    GZ_BASE_EXPORT  gzDynamicType getOption(gzSocketOption option);

    GZ_BASE_EXPORT  gzBool bind(const gzSocketAddress &address=gzSocketAddress());


    // --- Connection management ---

    GZ_BASE_EXPORT  gzBool listen(gzULong maxConnections=0);

    GZ_BASE_EXPORT  gzSocket *accept();
    
    GZ_BASE_EXPORT  gzBool connect(const gzSocketAddress &address);


    GZ_BASE_EXPORT gzBool isActive();


    // --- Send and receive data ---

    GZ_BASE_EXPORT  gzInt receive(gzUByte *buffer,gzULong len);
    GZ_BASE_EXPORT  gzInt bufferReceive(gzUByte *buffer,gzULong len);

    GZ_BASE_EXPORT  gzInt receiveFrom(gzSocketAddress & address , gzUByte *buffer,gzULong len);
    GZ_BASE_EXPORT  gzInt bufferReceiveFrom(gzSocketAddress & address , gzUByte *buffer,gzULong len);

    GZ_BASE_EXPORT  gzVoid bufferPushBack(gzUByte *buffer,gzULong len);

    GZ_BASE_EXPORT  gzInt send(const gzUByte *buffer,gzULong len);

    GZ_BASE_EXPORT  gzInt sendTo(const gzSocketAddress & address ,const gzUByte *buffer,gzULong len);



    GZ_BASE_EXPORT gzBool isReadyToReceive(gzULong timeout = 0);


    GZ_BASE_EXPORT gzBool isReadyToSend(gzULong timeout = 0);


    // --- Error management ---


    GZ_BASE_EXPORT  gzSocketError getSocketError() const;

    GZ_BASE_EXPORT  gzBool hasSocketError() const;

    GZ_BASE_EXPORT  gzVoid setSocketError(gzSocketError error=GZ_SOCKET_ERROR_CHECK_FOR_ERROR);

    GZ_BASE_EXPORT  gzVoid clearSocketError();


    GZ_BASE_EXPORT  gzVoid useExceptions(gzBool on);


    // --- Utilities ---

    GZ_BASE_EXPORT  gzBool isBindTo(const gzSocketAddress &address);

    GZ_BASE_EXPORT  gzBool isConnectedTo(const gzSocketAddress &address);

    GZ_BASE_EXPORT  gzSocketAddress getBindAddress();
    
    GZ_BASE_EXPORT  gzSocketAddress getConnectAddress();


    // --- Ioctl based utilities ---

    GZ_BASE_EXPORT  gzULong getPendingBytes();
    GZ_BASE_EXPORT  gzULong bufferGetPendingBytes();
    

    GZ_BASE_EXPORT  gzVoid setBlocking(gzBool on = TRUE);

    GZ_BASE_EXPORT gzBool isBlocking() const;
    

    GZ_BASE_EXPORT  gzHostAddress   getBroadcastAddress();
    

    GZ_BASE_EXPORT  gzHostAddress   getNetworkMask();


    // --- Setup utilities ---


    GZ_BASE_EXPORT  gzBool enableMulticast(const gzHostAddress& group, gzUShort port, gzULong ttl=255);
    

    GZ_BASE_EXPORT  gzBool enableMulticast(const gzHostAddress& group, gzUShort port, const gzHostAddress& iface, gzULong ttl=255);


    GZ_BASE_EXPORT  gzBool enableBroadcast(gzUShort port);


    GZ_BASE_EXPORT  gzBool enableBroadcast(gzUShort port, const gzHostAddress& iface);

    GZ_BASE_EXPORT gzVoid setReceiveBufferSize(gzULong messageSize,gzULong bufferSize=0);

private:

    virtual gzVoid onTick();


    gzSocketHandle          m_sockHandle;

    gzSocketError           m_error;

    gzSocketAddress         m_bind;

    gzSocketAddress         m_connect;

    gzBool                  m_useExceptions;

    gzBool                  m_blocking;

    gzSocketType            m_type;

    gzDynamicArray<gzUByte> m_buffer;

};


// ---------------- Utilites ---------------------

GZ_BASE_EXPORT gzHostInfo       getHostInfo();  // Default local host
GZ_BASE_EXPORT gzHostAddress    getLocalHostAddress();
GZ_BASE_EXPORT gzHostInfo       getHostInfo(const gzString &hostName);
GZ_BASE_EXPORT gzHostInfo       getHostInfo(const gzHostAddress &hostAddress);
GZ_BASE_EXPORT gzString         getNetworkClientID();


// ------------- GizmoBase implementation ---------------

GZ_BASE_EXPORT gzULong          gzSwapNetworkBytesL(gzULong value);
GZ_BASE_EXPORT gzUShort         gzSwapNetworkBytesS(gzUShort value);


#endif // __GZ_NETWORK_H__

---