XPSocket.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
/* XPSocket.h */
#ifndef _XPSOCK_H_
#define _XPSOCK_H_
#include "RNPlatform/Inc/DLLExportAPI.h"

#include <string>
#include "RNPlatform/Inc/MessageHelper.h"

namespace RNReplicaNet
{

#define _XPSOCK_VERSION 1500


/* Some error return defines */
#define XPSOCK_EOK                  (0)                     
#define XPSOCK_EERROR               (-1)                    
#define XPSOCK_EWOULDBLOCK          (-2)                    
#define XPSOCK_ECLOSED              (-3)                    
#define XPSOCK_ENOEXIST             (-4)                    
#define XPSOCK_ENOMEMORY            (-5)                    
#define XPSOCK_ENOTASOCKET          (-6)                    
#define XPSOCK_ECANTLISTEN          (-7)                    
#define XPSOCK_ENOTALISTEN          (-8)                    
#define XPSOCK_ENOTCONNECTED        (-9)                    
#define XPSOCK_EBUFFEROVERFLOW      (-10)                   
#define XPSOCK_EUDPSENDFAILED       (-11)                   
#define XPSOCK_ECANTBIND            (-12)                   
#define XPSOCK_ECANTRESOLVE         (-13)                   
#define XPSOCK_EURGENTTOOBIG        (-14)                   
#define XPSOCK_BUFFERTOOSMALL       (-15)                   
#define XPSOCK_ILLEGALOPERATION     (-16)                   
#define XPSOCK_ECONNINPROGRESS      (-17)                   
#define XPSOCK_ESTACKSTARTFAILURE   (-18)                   
#define XPSOCK_ESTACKNOTSTARTED     (-19)                   
#define pXPSOCK_EERROR  ((t_XPSocket *) XPSOCK_EERROR)  
/* Probable XPSocket types */
#define XPSOCK_TLOCALHOST   (0)
#define XPSOCK_TINET        (1)

/* XPSocket status */
#define XPSOCK_SNULL        (0)
#define XPSOCK_SLISTEN      (1)
#define XPSOCK_SCONNECT     (2)
#define XPSOCK_SCLOSE       (3)

/* Flags to pass to XPSock_Recv */
#define XPSOCK_FNULL            (0)                 
#define XPSOCK_FPEEK            (1)                 
#define XPSOCK_PORT_ANY         (0)                 
#define XPSOCK_PORT_LOCAL       (-1)                
#define XPSOCK_MAXPACKETSIZE    (8192)              
#define XPSOCK_URGENTMAXPACKETSIZE  (2048)          
/* Some constants for the local loop back sockets */
#define XPSOCK_LOOPBACKBUFFER   20480

/* Flags returned by XPSock_GetHardwareStatus */
#define XPSOCK_HARDWARE_AVAILABLE           (1<<0)
#define XPSOCK_HARDWARE_CABLE_CONNECTED     (1<<1)
#define XPSOCK_HARDWARE_10MBS               (1<<2)
#define XPSOCK_HARDWARE_100MBS              (1<<3)
#define XPSOCK_HARDWARE_FULL_DUPLEX         (1<<4)
#define XPSOCK_HARDWARE_HALF_DUPLEX         (1<<5)


/* Structs and their type defs */

struct XPAddress
{
    XPAddress(const int port,unsigned char addr1,unsigned char addr2,unsigned char addr3,unsigned char addr4);

    XPAddress(const int port);

    XPAddress(std::string addr);

    XPAddress();

    std::string Export(void) const;

    bool Import(const std::string address);

    void MakeAny(const int port = XPSOCK_PORT_ANY);

    static XPAddress Null(void);

    int port;                                       
    unsigned char addr[4];                          
};
typedef struct XPAddress t_XPAddress;
typedef struct XPAddress XPAddress;

// Useful operators to compare addresses
inline bool operator== (const t_XPAddress& a,const t_XPAddress& b)
{
    return (a.addr[0] == b.addr[0]) && (a.addr[1] == b.addr[1]) && (a.addr[2] == b.addr[2]) && (a.addr[3] == b.addr[3]) && (a.port == b.port);
}

inline bool operator!= (const t_XPAddress& a,const t_XPAddress& b)
{
    return !(a == b);
}

// Can be used with STL less<> tests
inline bool operator< (const t_XPAddress& a,const t_XPAddress& b)
{
    if (a.addr[0] < b.addr[0])
    {
        return true;
    }
    else if(a.addr[0] == b.addr[0])
    {
        if (a.addr[1] < b.addr[1])
        {
            return true;
        }
        else if (a.addr[1] == b.addr[1])
        {
            if (a.addr[2] < b.addr[2])
            {
                return true;
            }
            else if (a.addr[2] == b.addr[2])
            {
                if (a.addr[3] < b.addr[3])
                {
                    return true;
                }
                else if (a.addr[3] == b.addr[3])
                {
                    return (a.port < b.port);
                }
            }
        }
    }
    return false;
}

inline void operator<< (RNReplicaNet::DynamicMessageHelper &message,const XPAddress &a)
{
    message << a.addr[0];
    message << a.addr[1];
    message << a.addr[2];
    message << a.addr[3];
    message << a.port;
}
inline void operator>> (RNReplicaNet::DynamicMessageHelper &message,XPAddress &a)
{
    message >> a.addr[0];
    message >> a.addr[1];
    message >> a.addr[2];
    message >> a.addr[3];
    message >> a.port;
}

typedef struct s_XPSocket t_XPSocket;

typedef struct s_XPSocket {
    int type;                                       
    int state;                                      
    int total_sent;                                 
    int total_received;                             
    int total_accepts;                              
    int total_connects;                             
    int urgent;                                     
    t_XPAddress addr;                               
    int wins_socket;                                
    t_XPSocket *loopback_socket;                    
    char *loopback_recvbuffer;                      
    int loopback_recvpos;                           
    int loopback_readpos;                           
    int loopback_pending;                           
    int port;                                       
    } t_XPSocket;                                   
typedef struct s_XPErrorTranslate {
    int error;                                      
    char *text;                                     
    char *longtext;                                 
    } t_XPErrorTranslate;                           
/* Macros to make life easier */
#define XPSOCK_PARANOID(x)  if ((x) == NULL || (x) == pXPSOCK_EERROR)\
    {\
        asocket_lasterror = XPSOCK_ENOTASOCKET;\
        return XPSOCK_EERROR;\
    }


#define XPSOCK_S_PARANOID(x)    if ((x) == NULL || (x) == pXPSOCK_EERROR)\
    {\
        asocket_lasterror = XPSOCK_ENOTASOCKET;\
        return (t_XPSocket *) XPSOCK_EERROR;\
    }

} // namespace RNXPSockets

// Return error values are either pXPSOCK_EERROR, XPSOCK_EERROR or pXPSOCK_EOK

/* All the global functions */
extern int XPSock_Init(void);
extern int XPSock_Quit(void);
extern RNReplicaNet::t_XPSocket *XPSock_Create(void);
extern int XPSock_SetSendBuffer(RNReplicaNet::t_XPSocket * /*socket*/,int /*size*/);
extern int XPSock_SetRecvBuffer(RNReplicaNet::t_XPSocket * /*socket*/,int /*size*/);
extern int XPSock_Connect(RNReplicaNet::t_XPSocket * /*socket*/,const RNReplicaNet::t_XPAddress * /*addr*/);
extern int XPSock_Send(RNReplicaNet::t_XPSocket * /*socket*/,const char * /*data*/,const int /*len*/);
extern int XPSock_Recv(RNReplicaNet::t_XPSocket * /*socket*/,char * /*data*/,int /*maxlen*/,int /*flag*/);
extern int XPSock_Close(RNReplicaNet::t_XPSocket * /*socket*/);
extern int XPSock_Listen(RNReplicaNet::t_XPSocket * /*socket*/,int /*port*/);
extern int XPSock_Listen(RNReplicaNet::t_XPSocket * /*socket*/,const RNReplicaNet::t_XPAddress * /*addr*/);
extern RNReplicaNet::t_XPSocket *XPSock_Accept(RNReplicaNet::t_XPSocket * /*socket*/);

extern int XPSock_GetAddress(RNReplicaNet::t_XPSocket * /*socket*/,RNReplicaNet::t_XPAddress * /*addr*/);
extern int XPSock_GetPeerAddress(RNReplicaNet::t_XPSocket * /*socket*/,RNReplicaNet::t_XPAddress * /*addr*/);

extern RNReplicaNet::t_XPSocket *XPSock_UrgentCreate(int /*port*/);
extern RNReplicaNet::t_XPSocket *XPSock_UrgentCreate(const RNReplicaNet::t_XPAddress * /*addr*/);
extern int XPSock_UrgentMakeBroadcast(RNReplicaNet::t_XPSocket * /*socket*/);
extern int XPSock_UrgentSend(RNReplicaNet::t_XPSocket * /*socket*/,const char * /*data*/,int /*len*/,const RNReplicaNet::t_XPAddress * /*addr*/);
extern int XPSock_UrgentRecv(RNReplicaNet::t_XPSocket * /*socket*/,char *const /*data*/,int /*maxlen*/,int /*flag*/,RNReplicaNet::t_XPAddress *const /*addr*/);

extern RNReplicaNet::t_XPSocket *XPSock_ICMPCreate(void);
extern int XPSock_ICMPSendPing(RNReplicaNet::t_XPSocket * /*socket*/,const RNReplicaNet::t_XPAddress * /*addr*/,unsigned short *retID,unsigned short *retSeq,unsigned int *retTimeSent);
extern int XPSock_ICMPRecvPing(RNReplicaNet::t_XPSocket * /*socket*/,RNReplicaNet::t_XPAddress *const /*addr*/,unsigned short *retID,unsigned short *retSeq,unsigned int *retTimeElapsed);
extern int XPSock_ICMPWaitForPing(RNReplicaNet::t_XPSocket * socket,const float timeoutSeconds = 1.0f);


extern char *XPSock_TranslateError(int /*errno*/);
extern char *XPSock_TranslateErrorLong(int /*errno*/);

extern int XPSock_GetHostName(char * /*name*/,int /*name_len*/);
extern int XPSock_GetHostAddress(RNReplicaNet::XPAddress * /*addr*/);
extern int XPSock_Resolve(RNReplicaNet::t_XPAddress * /*resolve*/,const char * /*input*/);

extern int XPSock_UtilityGetFragment(char * /*buffer*/,int /*maxlen*/);
extern int XPSock_UtilityGetInt(char * /*buffer*/,int /*offset*/);
extern void XPSock_UtilitySetInt(char * /*buffer*/,int /*offset*/,int /*value*/);
extern short XPSock_UtilityGetShort(char * /*buffer*/,int /*offset*/);
extern void XPSock_UtilitySetShort(char * /*buffer*/,int /*offset*/,short /*value*/);

extern int XPSock_UtilityChecksum(char * /*buffer*/,int /*length*/);

extern void XPSock_Poll(void);

extern void XPSock_SentHistogram(unsigned int * /*classes*/,int /*numClasses*/);
extern void XPSock_RecvHistogram(unsigned int * /*classes*/,int /*numClasses*/);

extern int XPSock_GetHardwareStatus(void);

// The global variables
extern int asocket_lasterror;                       
/* Extern the counters */
extern int  asocket_packets_got;                    
extern int  asocket_packets_sent;                   
extern int  asocket_packets_got_size;               
extern int  asocket_packets_sent_size;              
// Only use these if you know exactly what you are doing
extern bool gXPSock_PacketLossEmulation;
extern float gXPSock_PacketLossEmulationPercent;
extern bool gXPSock_PacketLatencyEmulation;
extern float gXPSock_PacketLatencyEmulationBase;
extern float gXPSock_PacketLatencyEmulationJitter;
extern int gXPSock_UDPProtoParameter;

#endif

---