Ticket #563: SocketEnhanced.d

/*
        Copyright (C) 2004 Christopher E. Miller

        This software is provided 'as-is', without any express or implied
        warranty.  In no event will the authors be held liable for any damages
        arising from the use of this software.

        Permission is granted to anyone to use this software for any purpose,
        including commercial applications, and to alter it and redistribute it
        freely, subject to the following restrictions:

        1. The origin of this software must not be misrepresented; you must not
           claim that you wrote the original software. If you use this software
           in a product, an acknowledgment in the product documentation would be
           appreciated but is not required.

        2. Altered source versions must be plainly marked as such, and must not be
           misrepresented as being the original software.

        3. This notice may not be removed or altered from any source distribution.

*/

/*******************************************************************************

        copyright:      Copyright (c) 2004 Kris Bell. All rights reserved

        license:        BSD style: $(LICENSE)

        version:        Initial release: March 2004

        author:         Christopher Miller
                        Kris Bell
                        Anders F Bjorklund (Darwin patches)


        The original code has been modified in several ways:

        1) It has been altered to fit within the Tango environment, meaning
           that certain original classes have been reorganized, and/or have
           subclassed Tango base-classes. For example, the original Socket
           class has been wrapped with three distinct subclasses, and now
           derives from class tango.io.Resource.

        2) All exception instances now subclass the Tango IOException.

        3) Construction of new Socket instances via accept() is now
           overloadable.

        4) Constants and enums have been moved within a class boundary to
           ensure explicit namespace usage.

        5) changed Socket.select() to loop if it was interrupted.


        All changes within the main body of code all marked with "Tango:"

        For a good tutorial on socket-programming I highly recommend going
        here: http://www.ecst.csuchico.edu/~beej/guide/net/

*******************************************************************************/

module tango.net.SocketEnhanced;

private import  tango.sys.Common;

private import  tango.core.Exception;

private import  tango.core.Type : Interval;


/*******************************************************************************


*******************************************************************************/

version=Tango;
version (Tango)
{
        private {
        char[] toString (char[] tmp, int i)
        {
                int j = tmp.length;
                do {
                   tmp[--j] = i % 10 + '0';
                   } while (i /= 10);

                return tmp [j .. $];
        }
        }
}

version (linux)
         version = BsdSockets;

version (darwin)
         version = BsdSockets;

version (Posix)
         version = BsdSockets;


/*******************************************************************************


*******************************************************************************/

struct addrinfo
{
    int         ai_flags;
    int         ai_family;
    int         ai_socktype;
    int         ai_protocol;
    size_t      ai_addrln;
    sockaddr    *ai_addr;
    char        *ai_canonname;
    addrinfo    *ai_next;
};

private const int INET_ADDRSTRLEN = 16;
private const int NI_MAXHOST = 1025;
private const int NI_MAXSERVER = 32;
private const int AI_CANONNAME = 0x0002;


version (Win32)
        {
        pragma(lib, "ws2_32.lib");

        private typedef int socket_t = ~0;

        private const int IOCPARM_MASK =  0x7f;
        private const int IOC_IN =        cast(int)0x80000000;
        private const int FIONBIO =       cast(int) (IOC_IN | ((int.sizeof & IOCPARM_MASK) << 16) | (102 << 8) | 126);

        private const int WSADESCRIPTION_LEN = 256;
        private const int WSASYS_STATUS_LEN = 128;
        private const int WSAEWOULDBLOCK =  10035;
        private const int WSAEINTR =        10004;

        struct WSADATA
        {
                        WORD wVersion;
                        WORD wHighVersion;
                        char szDescription[WSADESCRIPTION_LEN+1];
                        char szSystemStatus[WSASYS_STATUS_LEN+1];
                        ushort iMaxSockets;
                        ushort iMaxUdpDg;
                        char* lpVendorInfo;
        }
        alias WSADATA* LPWSADATA;

        extern  (Windows)
                {
                int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
                int WSACleanup();
                socket_t socket(int af, int type, int protocol);
                int ioctlsocket(socket_t s, int cmd, uint* argp);
                uint inet_addr(char* cp);
                int bind(socket_t s, sockaddr* name, int namelen);
                int connect(socket_t s, sockaddr* name, int namelen);
                int listen(socket_t s, int backlog);
                socket_t accept(socket_t s, sockaddr* addr, int* addrlen);
                int closesocket(socket_t s);
                int shutdown(socket_t s, int how);
                int getpeername(socket_t s, sockaddr* name, int* namelen);
                int getsockname(socket_t s, sockaddr* name, int* namelen);
                int send(socket_t s, void* buf, int len, int flags);
                int sendto(socket_t s, void* buf, int len, int flags, sockaddr* to, int tolen);
                int recv(socket_t s, void* buf, int len, int flags);
                int recvfrom(socket_t s, void* buf, int len, int flags, sockaddr* from, int* fromlen);
                int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* errorfds, timeval* timeout);
                //int __WSAFDIsSet(socket_t s, fd_set* fds);
                int getsockopt(socket_t s, int level, int optname, void* optval, int* optlen);
                int setsockopt(socket_t s, int level, int optname, void* optval, int optlen);
                int gethostname(void* namebuffer, int buflen);
                char* inet_ntoa(uint ina);
                char* inet_ntop(int af, void *src, char *dst, int len);
                int getaddrinfo(char *node, char *service, addrinfo *hints, addrinfo **res);
                void freeaddrinfo(addrinfo *res);
                int getnameinfo(sockaddr *sa, size_t len, char *host, size_t hostlen, char *server, size_t servlen, int flags);
                hostent* gethostbyname(char* name);
                hostent* gethostbyaddr(void* addr, int len, int type);
                int WSAGetLastError();
                }

        static this()
        {
                WSADATA wd;
                if (WSAStartup (0x0101, &wd))
                    throw new SocketException("Unable to initialize socket library");
        }


        static ~this()
        {
                WSACleanup();
        }

        }

version (BsdSockets)
        {
        private import tango.stdc.errno;

        private typedef int socket_t = -1;

        private const int F_GETFL       = 3;
        private const int F_SETFL       = 4;
        version (darwin)
                 private const int O_NONBLOCK = 0x0004;
           else
                 private const int O_NONBLOCK = 04000;  // OCTAL! Thx to volcore

        extern  (C)
                {
                socket_t socket(int af, int type, int protocol);
                int fcntl(socket_t s, int f, ...);
                uint inet_addr(char* cp);
                int bind(socket_t s, sockaddr* name, int namelen);
                int connect(socket_t s, sockaddr* name, int namelen);
                int listen(socket_t s, int backlog);
                socket_t accept(socket_t s, sockaddr* addr, int* addrlen);
                int close(socket_t s);
                int shutdown(socket_t s, int how);
                int getpeername(socket_t s, sockaddr* name, int* namelen);
                int getsockname(socket_t s, sockaddr* name, int* namelen);
                int send(socket_t s, void* buf, int len, int flags);
                int sendto(socket_t s, void* buf, int len, int flags, sockaddr* to, int tolen);
                int recv(socket_t s, void* buf, int len, int flags);
                int recvfrom(socket_t s, void* buf, int len, int flags, sockaddr* from, int* fromlen);
                int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* errorfds, timeval* timeout);
                int getsockopt(socket_t s, int level, int optname, void* optval, int* optlen);
                int setsockopt(socket_t s, int level, int optname, void* optval, int optlen);
                int gethostname(void* namebuffer, int buflen);
                char* inet_ntoa(uint ina);
                hostent* gethostbyname(char* name);
                hostent* gethostbyaddr(void* addr, int len, int type);
                char* inet_ntop(int af, void *src, char *dst, int len);
                int getaddrinfo(char *node, char *service, addrinfo *hints, addrinfo **res);
                int getnameinfo(sockaddr *sa, size_t len, char *host, size_t hostlen, char *server, size_t servlen, int flags);
                void freeaddrinfo(addrinfo *res);           
               }
        }


/*******************************************************************************


*******************************************************************************/

private const socket_t INVALID_SOCKET = socket_t.init;
private const int SOCKET_ERROR = -1;



/*******************************************************************************

        Internal structs:

*******************************************************************************/

struct timeval
{
        int tv_sec; //seconds
        int tv_usec; //microseconds
}


//transparent
struct fd_set
{
}


struct sockaddr
{
        ushort sa_family;
        char[14] sa_data = [0];
}


struct hostent
{
        char* h_name;
        char** h_aliases;
        version(Win32)
        {
                short h_addrtype;
                short h_length;
        }
        else version(BsdSockets)
        {
                int h_addrtype;
                int h_length;
        }
        char** h_addr_list;


        char* h_addr()
        {
                return h_addr_list[0];
        }
}


/*******************************************************************************

        conversions for network byte-order

*******************************************************************************/

version(BigEndian)
{
        ushort htons(ushort x)
        {
                return x;
        }


        uint htonl(uint x)
        {
                return x;
        }
}
else version(LittleEndian)
{
        import tango.core.BitManip;


        ushort htons(ushort x)
        {
                return cast(ushort) ((x >> 8) | (x << 8));
        }


        uint htonl(uint x)
        {
                return bswap(x);
        }
}
else
{
        static assert(0);
}


ushort ntohs(ushort x)
{
        return htons(x);
}


uint ntohl(uint x)
{
        return htonl(x);
}


/*******************************************************************************


*******************************************************************************/

private extern (C) int strlen(char*);

private static char[] toUtf8(char* s)
{
        return s ? s[0 .. strlen(s)] : cast(char[])null;
}

private static char* convert2C (char[] input, char[] output)
{
        output [0 .. input.length] = input;
        output [input.length] = 0;
        return output.ptr;
}


/*******************************************************************************

        Public interface ...

*******************************************************************************/

public:


/*******************************************************************************


*******************************************************************************/

static int lastError ()
{
        version (Win32)
                {
                return WSAGetLastError();
                }
        version (Posix)
                {
                return errno;
                }
}


/***********************************************************************


***********************************************************************/

version (Win32)
{
        /***************************************************************


        ***************************************************************/

        enum SocketOption: int
        {
                //consistent
                SO_DEBUG =         0x1,

                //possibly Winsock-only values
                SO_BROADCAST =  0x20,
                SO_REUSEADDR =  0x4,
                SO_LINGER =     0x80,
                SO_DONTLINGER = ~(SO_LINGER),
                SO_OOBINLINE =  0x100,
                SO_SNDBUF =     0x1001,
                SO_RCVBUF =     0x1002,
                SO_ERROR =      0x1007,

                SO_ACCEPTCONN =    0x2, // ?
                SO_KEEPALIVE =     0x8, // ?
                SO_DONTROUTE =     0x10, // ?
                SO_TYPE =          0x1008, // ?

                // OptionLevel.IP settings
                IP_MULTICAST_TTL = 10,
                IP_MULTICAST_LOOP = 11,
                IP_ADD_MEMBERSHIP = 12,
                IP_DROP_MEMBERSHIP = 13,

                // OptionLevel.TCP settings
                TCP_NODELAY = 0x0001,
        }

        /***************************************************************


        ***************************************************************/

        union linger
        {
                struct {
                       ushort l_onoff;          // option on/off
                       ushort l_linger;         // linger time
                       };
                ushort[2]       array;          // combined
        }

        /***************************************************************


        ***************************************************************/

        enum SocketOptionLevel
        {
                SOCKET =  0xFFFF,
                IP =      0,
                TCP =     6,
                UDP =     17,
        }
}
else version (darwin)
{
        enum SocketOption: int
        {
                SO_DEBUG        = 0x0001,       /* turn on debugging info recording */
                SO_BROADCAST    = 0x0020,       /* permit sending of broadcast msgs */
                SO_REUSEADDR    = 0x0004,       /* allow local address reuse */
                SO_LINGER       = 0x0080,       /* linger on close if data present */
                SO_DONTLINGER   = ~(SO_LINGER),
                SO_OOBINLINE    = 0x0100,       /* leave received OOB data in line */
                SO_ACCEPTCONN   = 0x0002,       /* socket has had listen() */
                SO_KEEPALIVE    = 0x0008,       /* keep connections alive */
                SO_DONTROUTE    = 0x0010,       /* just use interface addresses */
                SO_TYPE         = 0x1008,               /* get socket type */

                /*
                 * Additional options, not kept in so_options.
                 */
                SO_SNDBUF       = 0x1001,       /* send buffer size */
                SO_RCVBUF       = 0x1002,       /* receive buffer size */
                SO_ERROR        = 0x1007,       /* get error status and clear */

                // OptionLevel.IP settings
                IP_MULTICAST_TTL = 10,
                IP_MULTICAST_LOOP = 11,
                IP_ADD_MEMBERSHIP = 12,
                IP_DROP_MEMBERSHIP = 13,

                // OptionLevel.TCP settings
                TCP_NODELAY = 0x0001,
        }

        /***************************************************************


        ***************************************************************/

        union linger
        {
                struct {
                       int l_onoff;             // option on/off
                       int l_linger;            // linger time
                       };
                int[2]          array;          // combined
        }

        /***************************************************************

                Question: are these correct for Darwin?

        ***************************************************************/

        enum SocketOptionLevel
        {
                SOCKET =  1,  // correct for linux on x86
                IP =      0,  // appears to be correct
                TCP =     6,  // appears to be correct
                UDP =     17, // appears to be correct
        }
}
else version (linux)
{
        /***************************************************************

                these appear to be compatible with x86 platforms,
                but not others!

        ***************************************************************/

        enum SocketOption: int
        {
                //consistent
                SO_DEBUG        = 1,
                SO_BROADCAST    = 6,
                SO_REUSEADDR    = 2,
                SO_LINGER       = 13,
                SO_DONTLINGER   = ~(SO_LINGER),
                SO_OOBINLINE    = 10,
                SO_SNDBUF       = 7,
                SO_RCVBUF       = 8,
                SO_ERROR        = 4,

                SO_ACCEPTCONN   = 30,
                SO_KEEPALIVE    = 9,
                SO_DONTROUTE    = 5,
                SO_TYPE         = 3,

                // OptionLevel.IP settings
                IP_MULTICAST_TTL = 33,
                IP_MULTICAST_LOOP = 34,
                IP_ADD_MEMBERSHIP = 35,
                IP_DROP_MEMBERSHIP = 36,

                // OptionLevel.TCP settings
                TCP_NODELAY = 0x0001,
        }

        /***************************************************************


        ***************************************************************/

        union linger
        {
                struct {
                       int l_onoff;             // option on/off
                       int l_linger;            // linger time
                       };
                int[2]          array;          // combined
        }

        /***************************************************************


        ***************************************************************/

        enum SocketOptionLevel
        {
                SOCKET =  1,  // correct for linux on x86
                IP =      0,  // appears to be correct
                TCP =     6,  // appears to be correct
                UDP =     17, // appears to be correct
        }
} // end versioning

/***********************************************************************


***********************************************************************/

enum SocketShutdown: int
{
        RECEIVE =  0,
        SEND =     1,
        BOTH =     2,
}

/***********************************************************************


***********************************************************************/

enum SocketFlags: int
{
        NONE =           0,
        OOB =            0x1, //out of band
        PEEK =           0x02, //only for receiving
        DONTROUTE =      0x04, //only for sending
}

/***********************************************************************

         Communication semantics

***********************************************************************/

enum SocketType: int
{
        STREAM =     1,       /// sequenced, reliable, two-way communication-based byte streams
        DGRAM =      2,        /// connectionless, unreliable datagrams with a fixed maximum length; data may be lost or arrive out of order
        RAW =        3,          /// raw protocol access
        RDM =        4,          /// reliably-delivered message datagrams
        SEQPACKET =  5,    /// sequenced, reliable, two-way connection-based datagrams with a fixed maximum length
}


/***********************************************************************

        Protocol

***********************************************************************/

enum ProtocolType: int
{
        IP =    0,     /// internet protocol version 4
        ICMP =  1,   /// internet control message protocol
        IGMP =  2,   /// internet group management protocol
        GGP =   3,    /// gateway to gateway protocol
        TCP =   6,    /// transmission control protocol
        PUP =   12,    /// PARC universal packet protocol
        UDP =   17,    /// user datagram protocol
        IDP =   22,    /// Xerox NS protocol
}


/***********************************************************************


***********************************************************************/

version(Win32)
{
      &n