pinet.h



#ifndef __PINET_H__ 
#define __PINET_H__ 

#ifndef __PPORT_H__ 
#include "pport.h" 
#endif 

#ifndef __PTYPES_H__ 
#include "ptypes.h" 
#endif 

#ifndef __PSTREAMS_H__ 
#include "pstreams.h" 
#endif 


#ifdef WIN32 
#  include <winsock2.h> 
#else 
#  include <netdb.h>       // for socklen_t 
#  include <sys/types.h> 
#  include <sys/socket.h> 
#endif 


PTYPES_BEGIN


#ifdef _MSC_VER 
#pragma pack(push, 4) 
#endif 


//
// BSD-compatible socket error codes for Win32
//

#if defined(WSAENOTSOCK) && !defined(ENOTSOCK) 

#define EWOULDBLOCK             WSAEWOULDBLOCK 
#define EINPROGRESS             WSAEINPROGRESS 
#define EALREADY                WSAEALREADY 
#define ENOTSOCK                WSAENOTSOCK 
#define EDESTADDRREQ            WSAEDESTADDRREQ 
#define EMSGSIZE                WSAEMSGSIZE 
#define EPROTOTYPE              WSAEPROTOTYPE 
#define ENOPROTOOPT             WSAENOPROTOOPT 
#define EPROTONOSUPPORT         WSAEPROTONOSUPPORT 
#define ESOCKTNOSUPPORT         WSAESOCKTNOSUPPORT 
#define EOPNOTSUPP              WSAEOPNOTSUPP 
#define EPFNOSUPPORT            WSAEPFNOSUPPORT 
#define EAFNOSUPPORT            WSAEAFNOSUPPORT 
#define EADDRINUSE              WSAEADDRINUSE 
#define EADDRNOTAVAIL           WSAEADDRNOTAVAIL 
#define ENETDOWN                WSAENETDOWN 
#define ENETUNREACH             WSAENETUNREACH 
#define ENETRESET               WSAENETRESET 
#define ECONNABORTED            WSAECONNABORTED 
#define ECONNRESET              WSAECONNRESET 
#define ENOBUFS                 WSAENOBUFS 
#define EISCONN                 WSAEISCONN 
#define ENOTCONN                WSAENOTCONN 
#define ESHUTDOWN               WSAESHUTDOWN 
#define ETOOMANYREFS            WSAETOOMANYREFS 
#define ETIMEDOUT               WSAETIMEDOUT 
#define ECONNREFUSED            WSAECONNREFUSED 
#define ELOOP                   WSAELOOP 
// #define ENAMETOOLONG            WSAENAMETOOLONG
#define EHOSTDOWN               WSAEHOSTDOWN 
#define EHOSTUNREACH            WSAEHOSTUNREACH 
// #define ENOTEMPTY               WSAENOTEMPTY
#define EPROCLIM                WSAEPROCLIM 
#define EUSERS                  WSAEUSERS 
#define EDQUOT                  WSAEDQUOT 
#define ESTALE                  WSAESTALE 
#define EREMOTE                 WSAEREMOTE 

// NOTE: these are not errno constants in UNIX!
#define HOST_NOT_FOUND          WSAHOST_NOT_FOUND 
#define TRY_AGAIN               WSATRY_AGAIN 
#define NO_RECOVERY             WSANO_RECOVERY 
#define NO_DATA                 WSANO_DATA 

#endif 


// shutdown() constants

#if defined(SD_RECEIVE) && !defined(SHUT_RD) 
#  define SHUT_RD       SD_RECEIVE 
#  define SHUT_WR       SD_SEND 
#  define SHUT_RDWR     SD_BOTH 
#endif 


// max backlog value for listen()

#ifndef SOMAXCONN 
#  define SOMAXCONN -1 
#endif 

typedef char* sockval_t;

#ifndef WIN32 
#  define closesocket close 
#endif 


#if (defined(__DARWIN__) && !defined(_SOCKLEN_T)) || defined(WIN32) || defined(__hpux) 
  typedef int psocklen;
#else 
  typedef socklen_t psocklen;
#endif 


// -------------------------------------------------------------------- //
// ---  IP address class and DNS utilities ---------------------------- //
// -------------------------------------------------------------------- //

//
// IP address
//

struct ipaddress
{
public:
    union
    {
        uchar   data[4];
        ulong   ldata;
    };
    ipaddress()                                 {}
    ipaddress(ulong a)                          { ldata = a; }
    ipaddress(const ipaddress& a)               { ldata = a.ldata; }
    ipaddress(int a, int b, int c, int d);
    ipaddress& operator= (ulong a)              { ldata = a; return *this; }
    ipaddress& operator= (const ipaddress& a)   { ldata = a.ldata; return *this; }
    uchar& operator [] (int i)                  { return data[i]; }
    operator ulong() const                      { return ldata; }
};


extern ipaddress ipnone;
extern ipaddress ipany;
extern ipaddress ipbcast;


//
// IP peer info: host name, IP and the port name
// used internally in ipstream and ipmessage
//


class ippeerinfo: public noncopyable
{
protected:
    ipaddress ip;         // target IP
    string    host;       // target host name; either IP or hostname must be specified
    int       port;       // target port number

    void      notfound(); // throws a (estream*) exception

    friend bool psockname(int, ippeerinfo&);

public:
    ippeerinfo();
    ippeerinfo(ipaddress iip, const string& ihost, int iport);

    ipaddress get_ip();     // resolves the host name if necessary (only once)
    string    get_host();   // performs reverse-lookup if necessary (only once)
    int       get_port()    { return port; }
    void      clear();
    string    asstring(bool showport) const;
};


string    iptostring(ipaddress ip);
ipaddress phostbyname(const char* name);
string    phostbyaddr(ipaddress ip);
string    phostcname(const char* name);

// internal utilities
int usockerrno();
const char* usockerrmsg(int code);
bool psockwait(int handle, int timeout);
bool psockname(int handle, ippeerinfo&);


// -------------------------------------------------------------------- //
// ---  TCP socket classes -------------------------------------------- //
// -------------------------------------------------------------------- //


// additional IO status codes

const int IO_RESOLVING  = 10;
const int IO_RESOLVED   = 11;
const int IO_CONNECTING = 20;
const int IO_CONNECTED  = 21;


//
// ipstream
//

class ipstream: public fdxstm, public ippeerinfo
{
    friend class ipstmserver;

protected:
    int svsocket;   // server socket descriptor, used internally by ipstmserver

#ifdef WIN32 
    // sockets are not compatible with file handles on Windows
    virtual int dorawread(char* buf, int count);
    virtual int dorawwrite(const char* buf, int count);
#endif 

    virtual int  uerrno();
    virtual const char* uerrmsg(int code);
    virtual void doopen();
    virtual large doseek(large newpos, ioseekmode mode);
    virtual void doclose();
    virtual void sockopt(int socket);
    void closehandle();

public:
    ipstream();
    ipstream(ipaddress ip, int port);
    ipstream(const char* host, int port);
    ipstream(const string& host, int port);
    virtual ~ipstream();
    virtual int classid();

    virtual string get_streamname();

    bool      waitfor(int timeout);
    ipaddress get_myip();
    int       get_myport();
    void      set_ip(ipaddress);
    void      set_host(const string&);
    void      set_host(const char*);
    void      set_port(int);
};


//
// common internal interfaces for ipstmserver and ipmsgserver
//

class ipbindinfo: public unknown, public ippeerinfo
{
public:
    int handle;

    ipbindinfo(ipaddress iip, const string& ihost, int iport);
    virtual ~ipbindinfo();
};


class ipsvbase: public unknown
{
protected:
    int     socktype;
    bool    active;
    tobjlist<ipbindinfo> addrlist;       // list of local socket addresses to bind to

    void error(ippeerinfo& peer, int code, const char* defmsg);
    bool dopoll(int* i, int timeout);
    void setupfds(void* set, int i);
    virtual void open();
    virtual void close();
    virtual void dobind(ipbindinfo*) = 0;
    virtual void sockopt(int socket);

public:
    ipsvbase(int isocktype);
    virtual ~ipsvbase();

    int bind(ipaddress ip, int port);
    int bindall(int port);

    int get_addrcount()                  { return addrlist.get_count(); }
    const ipbindinfo& get_addr(int i)    { return *addrlist[i]; }
    void clear();
};


//
// ipstmserver
//

class ipstmserver: public ipsvbase
{
protected:
    virtual void dobind(ipbindinfo*);

public:
    ipstmserver();
    virtual ~ipstmserver();

    bool poll(int i = -1, int timeout = 0);
    bool serve(ipstream& client, int i = -1, int timeout = -1);
};


// -------------------------------------------------------------------- //
// ---  UDP socket classes -------------------------------------------- //
// -------------------------------------------------------------------- //


//
// ipmessage
//

class ipmessage: public unknown, public ippeerinfo
{
protected:
    int handle;

    void error(int code, const char* msg);
    void open();
    void close();
    virtual void sockopt(int socket);

public:
    ipmessage();
    ipmessage(ipaddress ip, int port);
    ipmessage(const char* host, int port);
    ipmessage(const string& host, int port);
    virtual ~ipmessage();

    void set_ip(ipaddress iip);
    void set_host(const string&);
    void set_host(const char*);
    void set_port(int);
    ipaddress get_myip();
    int get_myport();
    int get_handle()                            { return handle; }

    bool   waitfor(int timeout);
    int    receive(char* buf, int count, ipaddress& src);
    int    receive(char* buf, int count);
    string receive(int max, ipaddress& src);
    string receive(int max);
    void   send(const char* buf, int count);
    void   send(const string& s)                { send(s, length(s)); }
};


//
// ipmsgserver
//

class ipmsgserver: public ipsvbase, public ippeerinfo
{
protected:
    int handle;

    virtual void close();
    virtual void dobind(ipbindinfo*);

public:
    ipmsgserver();
    virtual ~ipmsgserver();

    int get_handle()                            { return handle; }

    bool   poll(int i = -1, int timeout = 0);
    int    receive(char* buf, int count);
    string receive(int max);
    void   send(const char* buf, int count);
    void   send(const string& s)                { send(s, length(s)); }
    void   sendto(const char* buf, int count, ipaddress ip, int port);
    void   sendto(const string& s, ipaddress ip, int port)
                                                { sendto(s, length(s), ip, port); }
};


#ifdef _MSC_VER 
#pragma pack(pop) 
#endif 


PTYPES_END


#endif // __PINET_H__