XSocket.h

Go to the documentation of this file.

//! @file XSocket.h
//! A convenient socket class for sending information over the network
//! 
//////////////////////////////////////////////////////////////////
#if !defined(XSOCKET_H)
#define XSOCKET_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
#ifdef __WINDOWS__
#include <Winsock2.h>
typedef SOCKET xSocket;
#elif defined(__APPLE__) || defined(__LINUX__)
typedef int xSocket;
#endif
 
#define XSOCKET_INVALID_HANDLE ((xSocket)(-1))
#define XSOCKET_INVALID_SIZE ((fileuint)(-1))
 
class CServerListenThread;
class CCustomData;
class CXThread;
class DLL_TOOLSFUNCTION CXSocket : public CXObject
{
    DECLARE_DYNAMIC_XOBJECT(CXSocket)
 
    friend CServerListenThread;
 
    public:
        typedef enum
        {
            SOCKET_IDLE_MESSAGE = 0, // Can be used to check if socket still exists on the client side (SendDatas(SOCKET_IDLE_MESSAGE, NULL, 0)). If data provided with this message, it will be ignored by the server socket.
        } SocketMessageID;
        
    typedef struct
    {
        const void *data;
        fileuint size;
    } DataBlockInfo;
 
    typedef enum  SocketError XEnumType(unsigned int)
    {
        SOCKET_ERROR_NONE = 0,
        SOCKET_ERROR_NO_SERVICE,
        SOCKET_ERROR_CANT_GET_HOST_ADDRESS,
        SOCKET_ERROR_NOT_CREATED, // The socket as not be created
        SOCKET_ERROR_CANT_CREATE,
        SOCKET_ERROR_CANT_CLOSE,
        SOCKET_ERROR_CANT_CONNECT,
        SOCKET_ERROR_CANT_LISTEN,
        SOCKET_ERROR_CANT_BIND,
        SOCKET_ERROR_INIT_FAILS_FIRST = SOCKET_ERROR_NO_SERVICE,
        SOCKET_ERROR_INIT_FAILS_LAST = SOCKET_ERROR_CANT_BIND,
        SOCKET_ERROR_CANT_SEND,
        SOCKET_ERROR_CANT_SELECT,
        SOCKET_ERROR_CANCEL, // Reception cancel
        SOCKET_ERROR_NO_DATA_AVAILABLE, // There is no data available when calling ReadData with ONLY_IF_AVAILABLE_DATA or WAIT_FOR_AVAILABLE_DATA
        SOCKET_ERROR_CONNECTION_CLOSED,
        SOCKET_ERROR_CANT_RECEIVE,
    } SocketError;
 
    typedef enum  SocketFlags XEnumType(unsigned int)
    {
        SOCKET_FLAGS_NONE = 0x00,
        SOCKET_FLAGS_CLIENT = 0x01,
        SOCKET_FLAGS_SERVER = 0x02, // Client and server flags are mutually exclusive
 
        // Internal flags
        SOCKET_FLAGS_KEEP_OPEN_ON_DESTROY = 0x10000,
    } SocketFlags;
 
    typedef enum  ReadDataMode XEnumType(unsigned int)
    {
        READ_WAITING_DATA = 0, // We know some waiting data exists
        ONLY_IF_AVAILABLE_DATA, // If data is available get it, otherwise return immediately
        WAIT_FOR_AVAILABLE_DATA // Wait until some data is available
    } ReadDataMode;
 
    typedef CXArray<DataBlockInfo> CDataBlockArray;
    typedef bool (*SocketReceiveDataCallback)(CXSocket& clientSocket, unsigned int messageID, const void *memory, fileuint dataSize, const CDataBlockArray& blocks, void *callbackData);
    typedef bool (*SocketUserCancelCallback)(void *callbackData);
 
    protected:
        mutable SocketError errorCode;
        unsigned int flags;
        unsigned int maxClient, clientCount; // Max client number for a server socket, and client count
        xSocket *clientSockets;
        xSocket socketHandle;
        CXThread *serverListening;
        void *callbackUserData;
        SocketReceiveDataCallback receiveDataCallback;
        SocketUserCancelCallback userCancelCallback;
 
        // Init the socket service if needed by the O/S (automatically done)
        static bool InitService();
        static void CloseService(); // (automatically done when calling CloseMootoolsApplication), otherwise DIY
 
        bool SendData(const void *data, fileuint datasize) const; // Return true if all the data has been sent
        bool ReadDataStream(void *message, void *&data, ReadDataMode mode) const; // Return true if data read correctly, false otherwise. In such case GetErrorCode allow to know what occured (SOCKET_ERROR_CANCEL, SOCKET_ERROR_NO_DATA_AVAILABLE, SOCKET_ERROR_CONNECTION_CLOSE or SOCKET_ERROR_CANT_RECEIVE)
        static unsigned int GetDataBlocks(void *message, const void *data, CDataBlockArray& blocks);
 
    public:
        CXSocket();
        virtual ~CXSocket();
 
        // Socket useful methods
        xSocket GetHandle();
        const xSocket GetHandle() const;
        bool Attach(xSocket handle, bool clientSocket, bool closeOnDestroy); // Return false if a socket is already attached
        bool Attach(const xSocket handle); // Return false if a socket is already attached
        bool CloseSocket();
 
        // Callback events
        void SetCallbackData(void *callbackUserData); // Set the user data use in the callbacks.
        virtual bool UserCancel() const; // Return true if the data exchange should be cancel. This is used both for client and server, reception and sending.
        void SetUserCancelCallback(SocketUserCancelCallback callback); // Can be used if you don't want to override CXSocket class. Cf. UserCancel
 
        virtual bool ReceiveData(CXSocket& clientSocket, unsigned int messageID, const void *memory, fileuint dataSize, const CDataBlockArray& blocks); // Called by an external thread when server receive a message and some data. Return true to confirm that you handle it. memory is a temporary pointer and should not be stored. clientSocket can be used to send a confirmation to the client. It is temporary and should not be stored. Blocks has a least one element. It contains pointer to each data block, if several blocks are sent.
        void SetReceiveDataCallback(SocketReceiveDataCallback callback); // Can be used if you don't want to override CXSocket class. Cf. ReceiveData
 
        // Error information
        SocketError GetErrorCode() const { return errorCode; }
        void SetErrorCode(CXSocket::SocketError error) { errorCode = error; }
 
        // Read / write  data
        bool SendCustomData(unsigned int messageID, const CCustomData& data) const;
        bool SendDatas(unsigned int messageID, const void *data, fileuint size, ...) const; // Send multiple datas block in a single message. At reception, each data block is preceed by a fileuint which inform about the size block of the following memory. ReceiveData contains the description of each blocks. Sum of the this fileuint is egal to total ReceiveData dataSize
 
        bool ReadCustomData(unsigned int& messageID, CCustomData& data, ReadDataMode mode = ONLY_IF_AVAILABLE_DATA) const; // Return true if some data has been read. false otherwise, which means that an error might occured (socket connection fails...)
        void *ReadDatas(unsigned int & messageID, fileuint & datasize, CDataBlockArray& blocks, ReadDataMode mode) const; // Retrieve information that has been sent with SendDatas. Return the global memory blocks and its datasize. Return also block array, that contains the pointer of the data memory for each block. Uses Free to delete the return memory.
        SocketError HasDataAvailable(bool waitForData) const;
 
        // Client socket
        bool CreateClient(unsigned short socketPort, bool nonBlockingConnection = false, const CXString& address = _T("localhost")); // Create a client socket. If socket handle is not null, check that the server is still available. If not close and reinit the socket
 
        // Server socket
        bool CreateServer(unsigned short socketPort, unsigned int maxClientCount, bool startListening = true);
        bool StartListening(); // Start async server listening in a different thread.
        bool StopListening(bool wait);  // Stop server listening in a different thread.
        unsigned int GetMaxClient() const { return maxClient; } // The maximum allowed clients
        const xSocket *GetClients(unsigned int& clientNbr) const; // Return the client socket and the client nbr
 
        // Memory features
        static void Free(void *data); // This free a memory block returned by ReadData for example.
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(XSOCKET_H)