Download Reference Manual
The Developer's Library for D
About Wiki Forums Source Search Contact

Ticket #1239: IPv6.patch

File IPv6.patch, 34.9 kB (added by Wazar, 11 years ago)
  • /root/buff/trunk-r5403/trunk/tango/net/device/Berkeley.d

    old new  
    66 
    77import  consts=tango.sys.consts.socket; 
    88 
     9private import  tango.stdc.stringz; 
     10 
     11private import  Integer = tango.text.convert.Integer;  
     12 
     13version(Win32)  
     14{  
     15        private import tango.sys.SharedLib;  
     16} 
     17 
    918/******************************************************************************* 
    1019 
    1120*******************************************************************************/ 
     
    136145        NOSIGNAL =       0x4000,                /// inhibit signals 
    137146} 
    138147 
     148enum AIFlags: int  
     149{ 
     150        PASSIVE = consts.AI_PASSIVE, /// get address to use bind() 
     151        CANONNAME = consts.AI_CANONNAME, /// fill ai_canonname 
     152        NUMERICHOST = consts.AI_NUMERICHOST, /// prevent host name resolution 
     153        NUMERICSERV = consts.AI_NUMERICSERV, /// prevent service name resolution valid flags for addrinfo (not a standard def, apps should not use it) 
     154        ALL = consts.AI_ALL, /// IPv6 and IPv4-mapped (with AI_V4MAPPED)  
     155        ADDRCONFIG = consts.AI_ADDRCONFIG, /// only if any address is assigned 
     156        V4MAPPED = consts.AI_V4MAPPED, /// accept IPv4-mapped IPv6 address special recommended flags for getipnodebyname 
     157        MASK = consts.AI_MASK, 
     158        DEFAULT = consts.AI_DEFAULT, 
     159} 
     160 
     161enum AIError 
     162{ 
     163        BADFLAGS = consts.EAI_BADFLAGS, /// Invalid value for `ai_flags' field. 
     164        NONAME = consts.EAI_NONAME, /// NAME or SERVICE is unknown. 
     165        AGAIN = consts.EAI_AGAIN,   /// Temporary failure in name resolution. 
     166        FAIL = consts.EAI_FAIL, /// Non-recoverable failure in name res. 
     167        NODATA = consts.EAI_NODATA, /// No address associated with NAME. 
     168        FAMILY = consts.EAI_FAMILY, /// `ai_family' not supported. 
     169        SOCKTYPE = consts.EAI_SOCKTYPE, /// `ai_socktype' not supported. 
     170        SERVICE = consts.EAI_SERVICE,   /// SERVICE not supported for `ai_socktype'. 
     171        MEMORY = consts.EAI_MEMORY, /// Memory allocation failure. 
     172} 
     173 
     174 
     175enum NIFlags: int  
     176{ 
     177        MAXHOST = consts.NI_MAXHOST, 
     178        MAXSERV = consts.NI_MAXSERV, 
     179        NUMERICHOST = consts.NI_NUMERICHOST, /// Don't try to look up hostname. 
     180        NUMERICSERV = consts.NI_NUMERICSERV, /// Don't convert port number to name. 
     181        NOFQDN = consts.NI_NOFQDN, /// Only return nodename portion. 
     182        NAMEREQD = consts.NI_NAMEREQD, /// Don't return numeric addresses. 
     183        DGRAM = consts.NI_DGRAM, /// Look up UDP service rather than TCP. 
     184} 
     185 
     186              
    139187/******************************************************************************* 
    140188 
    141189        conversions for network byte-order 
     
    208256                char* inet_ntoa(uint ina); 
    209257                NetHost.hostent* gethostbyname(char* name); 
    210258                NetHost.hostent* gethostbyaddr(void* addr, int len, int type); 
     259                                /** 
     260                                    The gai_strerror function translates error codes of getaddrinfo, freeaddrinfo and getnameinfo to a human readable string, 
     261                                    suitable for error reporting. 
     262                                    (C) MAN 
     263                                */ 
     264                                char* gai_strerror(int errcode); 
    211265        } 
    212266 
    213267        package extern (Windows) 
    214268        { 
     269                                /** 
     270                                    Given node and service, which identify an Internet host and a service, getaddrinfo() returns one or more addrinfo structures, 
     271                                    each of which contains an Internet address that can be specified in a call to bind or connect. 
     272                                    The getaddrinfo() function combines the functionality provided by the getservbyname and getservbyport functions into a single interface, 
     273                                    but unlike the latter functions, getaddrinfo() is reentrant and allows programs to eliminate IPv4-versus-IPv6 dependencies. 
     274                                    (C) MAN 
     275                                */ 
     276                                int function(char* node, char* service, Address.addrinfo* hints, Address.addrinfo** res) getaddrinfo; 
     277 
     278                                /** 
     279                                    The freeaddrinfo() function frees the memory that was allocated for the dynamically allocated linked list res.   
     280                                    (C) MAN 
     281                                */                               
     282                void function(Address.addrinfo *res) freeaddrinfo;  
     283                                 
     284                                /** 
     285                                    The getnameinfo() function is the inverse of getaddrinfo: it converts a socket address to a corresponding host and service, 
     286                                    in a protocol-independent manner. It combines the functionality of gethostbyaddr and getservbyport, but unlike those functions, 
     287                                    getaddrinfo is reentrant and allows programs to eliminate IPv4-versus-IPv6 dependencies. 
     288                                    (C) MAN 
     289                                */ 
     290                int function(sockaddr* sa, int salen, char* host, int hostlen, char* serv, int servlen, int flags) getnameinfo;  
     291                                 
     292 
     293 
     294                 
    215295                bool function (socket_t, uint, void*, DWORD, DWORD, DWORD, DWORD*, OVERLAPPED*) AcceptEx; 
    216296                bool function (socket_t, HANDLE, DWORD, DWORD, OVERLAPPED*, void*, DWORD) TransmitFile; 
    217297                bool function (socket_t, void*, int, void*, DWORD, DWORD*, OVERLAPPED*) ConnectEx; 
    218298        } 
    219299 
     300                private SharedLib lib = null; 
     301                 
    220302        static this() 
    221303        { 
     304 
     305                                lib = SharedLib.load("Ws2_32.dll");  
     306                  getnameinfo = cast(typeof(getnameinfo))lib.getSymbolNoThrow("getnameinfo");  
     307                  if(!getnameinfo)  
     308                                {  
     309                        lib.unload();  
     310                        lib = SharedLib.load("Wship6.dll"); // "Trying Wship6.dll (Windows 2000 with IPv6 technology preview)..." 
     311                           
     312                  }  
     313                  getnameinfo = cast(typeof(getnameinfo))lib.getSymbolNoThrow("getnameinfo");  
     314                  if(!getnameinfo)  
     315                                {  
     316                          
     317                        lib.unload(); //"No IPv6 support.;  
     318                                            lib = null; 
     319                                              
     320                  }  
     321                  getaddrinfo = cast(typeof(getaddrinfo))lib.getSymbol("getaddrinfo");  
     322                  freeaddrinfo = cast(typeof(freeaddrinfo))lib.getSymbol("freeaddrinfo");  
     323 
     324 
    222325                WSADATA wd = void; 
    223326                if (WSAStartup (0x0202, &wd)) 
    224327                    throw new SocketException("version of socket library is too old"); 
    225328 
    226329                DWORD result; 
    227  
     330                             
     331                                 
    228332                Guid acceptG   = {0xb5367df1, 0xcbac, 0x11cf, [0x95,0xca,0x00,0x80,0x5f,0x48,0xa1,0x92]}; 
    229333                Guid connectG  = {0x25a207b9, 0xddf3, 0x4660, [0x8e,0xe9,0x76,0xe5,0x8c,0x74,0x06,0x3e]}; 
    230334                Guid transmitG = {0xb5367df0, 0xcbac, 0x11cf, [0x95,0xca,0x00,0x80,0x5f,0x48,0xa1,0x92]}; 
    231335 
    232336                auto s = cast(HANDLE) socket (AddressFamily.INET, SocketType.STREAM, ProtocolType.TCP); 
    233337                assert (s != cast(HANDLE) -1); 
     338                                 
    234339                WSAIoctl (s, SIO_GET_EXTENSION_FUNCTION_POINTER,  
    235340                          &connectG, connectG.sizeof, &ConnectEx,  
    236341                          ConnectEx.sizeof, &result, null, null); 
     
    247352 
    248353        static ~this() 
    249354        { 
    250                 WSACleanup(); 
     355                    if(lib) 
     356                        lib.unload; 
     357          WSACleanup(); 
    251358        } 
    252359} 
    253360else 
     
    280387                char* inet_ntoa(uint ina); 
    281388                NetHost.hostent* gethostbyname(char* name); 
    282389                NetHost.hostent* gethostbyaddr(void* addr, int len, int type); 
     390                                 
     391                                /** 
     392                                    Given node and service, which identify an Internet host and a service, getaddrinfo() returns one or more addrinfo structures, 
     393                                    each of which contains an Internet address that can be specified in a call to bind or connect. 
     394                                    The getaddrinfo() function combines the functionality provided by the getservbyname and getservbyport functions into a single interface, 
     395                                    but unlike the latter functions, getaddrinfo() is reentrant and allows programs to eliminate IPv4-versus-IPv6 dependencies. 
     396                                    (C) MAN 
     397                                */ 
     398                                int getaddrinfo(char* node, char* service, Address.addrinfo* hints, Address.addrinfo** res);  
     399                                 
     400                                /** 
     401                                    The freeaddrinfo() function frees the memory that was allocated for the dynamically allocated linked list res.   
     402                                    (C) MAN 
     403                                */ 
     404                    void freeaddrinfo(Address.addrinfo *res);  
     405                                 
     406                                /** 
     407                                    The getnameinfo() function is the inverse of getaddrinfo: it converts a socket address to a corresponding host and service, 
     408                                    in a protocol-independent manner. It combines the functionality of gethostbyaddr and getservbyport, but unlike those functions, 
     409                                    getaddrinfo is reentrant and allows programs to eliminate IPv4-versus-IPv6 dependencies. 
     410                                    (C) MAN 
     411                                */ 
     412                    int getnameinfo(Address.sockaddr* sa, int salen, char* host, int hostlen, char* serv, int servlen, int flags);  
     413                                 
     414                                /** 
     415                                    The gai_strerror function translates error codes of getaddrinfo, freeaddrinfo and getnameinfo to a human readable string, 
     416                                    suitable for error reporting. 
     417                                    (C) MAN 
     418                                */ 
     419                    char* gai_strerror(int errcode);  
    283420       } 
    284421} 
    285422 
     
    9321069                char[14] sa_data = 0; 
    9331070        } 
    9341071 
     1072                struct addrinfo  
     1073                {  
     1074                    int       ai_flags;  
     1075                    int       ai_family;  
     1076                    int       ai_socktype;  
     1077                    int       ai_protocol;  
     1078                    uint      ai_addrlen;  
     1079                    sockaddr* ai_addr;  
     1080                    char*     ai_canonname;  
     1081                    addrinfo* ai_next;  
     1082                }  
     1083 
    9351084        abstract sockaddr*      name(); 
    9361085        abstract int            nameLen(); 
    937         abstract char[]         toString(); 
    938         abstract AddressFamily  addressFamily(); 
     1086        //abstract char[]         toString(); 
     1087        //abstract AddressFamily  addressFamily(); 
    9391088 
    9401089        /*********************************************************************** 
    9411090 
     
    10091158        { 
    10101159                throw new SocketException (msg); 
    10111160        } 
     1161                 
     1162        static Address create(sockaddr* sa) {  
     1163                switch(sa.sa_family) {  
     1164                case AddressFamily.INET:  
     1165                    return new IPv4Address(sa);  
     1166                case AddressFamily.INET6:  
     1167                    return new IPv6Address(sa);  
     1168                default:  
     1169                    return null;  
     1170                }  
     1171        }  
     1172                 
     1173        public:  
     1174          
     1175        static Address resolve(char[] host, char[] service = null, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1176            return resolveAll(host, service, af, flags)[0];  
     1177        }  
     1178          
     1179        static Address resolve(char[] host, ushort port, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1180            return resolveAll(host, port, af, flags)[0];  
     1181        }  
     1182          
     1183        /***********************************************************************  
     1184  
     1185  
     1186        ***********************************************************************/  
     1187          
     1188        static Address[] resolveAll(char[] host, char[] service = null, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1189                Address[] retVal;  
     1190                version(Win32) {  
     1191                        if(!getaddrinfo) { // *old* windows, let's fall back to NetHost  
     1192                                uint port = cast(uint)Integer.toInt(service);  
     1193                                if(flags & AIFlags.PASSIVE && host is null) {  
     1194                                        return [new IPv4Address(0, port)];  
     1195                                }  
     1196                                auto nh = new NetHost;  
     1197                                if(!nh.getHostByName(host)) {  
     1198                                        throw new AddressException("couldn't resolve " ~ host);  
     1199                                }  
     1200                                retVal.length = nh.addrList.length;  
     1201                                foreach(i, addr; nh.addrList) {  
     1202                                        retVal[i] = new IPv4Address(addr, port);  
     1203                                }  
     1204                                return retVal;  
     1205                        }  
     1206                }  
     1207                addrinfo* info;  
     1208                addrinfo hints;  
     1209                hints.ai_flags = flags;  
     1210                hints.ai_family = flags & AIFlags.PASSIVE && af == AddressFamily.UNSPEC ? AddressFamily.INET6 : af;  
     1211                hints.ai_socktype = SocketType.STREAM;  
     1212                int error = getaddrinfo(toStringz(host), service.length == 0 ? null : toStringz(service), &hints, &info);  
     1213                if(error != 0) {  
     1214                        throw new AddressException(fromStringz(gai_strerror(error)));  
     1215                }  
     1216                retVal.length = 16;  
     1217                retVal.length = 0;  
     1218                while(info) {  
     1219                        if(auto addr = create(info.ai_addr)) {  
     1220                                retVal ~= addr;  
     1221                        }  
     1222                        info = info.ai_next;  
     1223                }  
     1224                freeaddrinfo(info);  
     1225                return retVal;  
     1226        }  
     1227          
     1228        /***********************************************************************  
     1229  
     1230  
     1231        ***********************************************************************/  
     1232          
     1233        static Address[] resolveAll(char host[], ushort port, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1234                char[16] buf;  
     1235                return resolveAll(host, Integer.itoa(buf, port), af, flags);  
     1236        }  
     1237          
     1238        /***********************************************************************  
     1239  
     1240  
     1241        ***********************************************************************/  
     1242          
     1243        static Address passive(char[] service, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1244                return resolve(null, service, af, flags | AIFlags.PASSIVE);  
     1245        }  
     1246          
     1247        /***********************************************************************  
     1248  
     1249  
     1250        ***********************************************************************/  
     1251          
     1252        static Address passive(ushort port, AddressFamily af = AddressFamily.UNSPEC, AIFlags flags = cast(AIFlags)0) {  
     1253                return resolve(null, port, af, flags | AIFlags.PASSIVE);  
     1254        }  
     1255          
     1256        /***********************************************************************  
     1257  
     1258  
     1259        ***********************************************************************/  
     1260  
     1261        char[] toAddrString()  
     1262        {  
     1263                char[1025] host = void;  
     1264                                /*Getting name info. Don't look up hostname, returns numeric name. (NIFlags.NUMERICHOST)*/ 
     1265                getnameinfo(name, nameLen, host.ptr, host.length, null, 0, NIFlags.NUMERICHOST);  
     1266                return fromStringz(host.ptr);  
     1267        }  
     1268  
     1269        /***********************************************************************  
     1270  
     1271  
     1272        ***********************************************************************/  
     1273  
     1274        char[] toPortString()  
     1275        {  
     1276                char[32] service = void;  
     1277                                /*Getting name info. Returns port number, not service name. (NIFlags.NUMERICSERV)*/ 
     1278                getnameinfo(name, nameLen, null, 0, service.ptr, service.length, NIFlags.NUMERICSERV);  
     1279                foreach(i, c; service) {  
     1280                        if(c == '\0') {  
     1281                                return service[0..i].dup;  
     1282                        }  
     1283                }  
     1284        }  
     1285          
     1286  
     1287        /***********************************************************************  
     1288  
     1289  
     1290        ***********************************************************************/  
     1291  
     1292        char[] toString()  
     1293        {  
     1294                return toAddrString ~ ":" ~ toPortString;  
     1295        }  
     1296          
     1297          
     1298        /***********************************************************************  
     1299  
     1300  
     1301        ***********************************************************************/  
     1302  
     1303        AddressFamily addressFamily()  
     1304        {  
     1305                return cast(AddressFamily)name.sa_family;  
     1306        }  
    10121307} 
    10131308 
    10141309 
     
    11511446                        if(!ih.getHostByName(addr)) 
    11521447                          { 
    11531448                          char[16] tmp = void; 
    1154                           exception ("Unable to resolve "~addr~":"~fromInt(tmp, port)); 
     1449                          exception ("Unable to resolve "~addr~":"~Integer.itoa(tmp, port)); 
    11551450                          } 
    11561451                        uiaddr = ih.addrList[0]; 
    11571452                } 
     
    11641459 
    11651460        ***********************************************************************/ 
    11661461 
     1462                this(sockaddr* addr)  
     1463        {  
     1464                sin = *(cast(sockaddr_in*)addr);  
     1465        }  
     1466                 
     1467        /*********************************************************************** 
     1468 
     1469 
     1470        ***********************************************************************/ 
     1471                 
    11671472        sockaddr* name() 
    11681473        { 
    11691474                return cast(sockaddr*)&sin; 
     
    12641569        } 
    12651570} 
    12661571 
     1572/***********************************************************************  
     1573         
     1574                IPv6 is the next-generation Internet Protocol version 
     1575                designated as the successor to IPv4, the first 
     1576                implementation used in the Internet that is still in 
     1577                dominant use currently. 
     1578                 
     1579                More information: http://ipv6.com/ 
     1580                 
     1581                IPv6 supports 128-bit address space as opposed to 32-bit 
     1582                address space of IPv4. 
     1583                 
     1584                IPv6 is written as 8 blocks of 4 octal digits (16 bit) 
     1585                separated by a colon (":"). 
     1586                Zero block can be replaced by "::". 
     1587                 
     1588                For example:  
     1589                0000:0000:0000:0000:0000:0000:0000:0001 
     1590                is equal 
     1591                ::0001 
     1592                is equal 
     1593                ::1 
     1594                is analogue IPv4 127.0.0.1 
     1595                 
     1596                0000:0000:0000:0000:0000:0000:0000:0000 
     1597                is equal 
     1598                :: 
     1599                is analogue IPv4 0.0.0.0 
     1600                 
     1601                2001:cdba:0000:0000:0000:0000:3257:9652  
     1602                is equal 
     1603                2001:cdba::3257:9652 
     1604                 
     1605                IPv4 address can be submitted through IPv6 as ::ffff:xx.xx.xx.xx, 
     1606                where xx.xx.xx.xx 32-bit IPv4 addresses. 
     1607                 
     1608                ::ffff:51b0:ec6d 
     1609                is equal 
     1610                ::ffff:81.176.236.109 
     1611                is analogue IPv4 81.176.236.109 
     1612                 
     1613                The URL for the IPv6 address will be of the form: 
     1614                http://[2001:cdba:0000:0000:0000:0000:3257:9652]/ 
     1615                 
     1616                If needed to specify a port, it will be listed after the 
     1617                closing square bracket followed by a colon. 
     1618                 
     1619                http://[2001:cdba:0000:0000:0000:0000:3257:9652]:8080/ 
     1620                address: "2001:cdba:0000:0000:0000:0000:3257:9652" 
     1621                port: 8080 
     1622                 
     1623                IPv6Address can be used as well as IPv4Address. 
     1624                 
     1625                scope addr = new IPv6Address(8080);  
     1626                address: "::" 
     1627                port: 8080 
     1628                 
     1629                scope addr_2 = new IPv6Address("::1", 8081);  
     1630                address: "::1" 
     1631                port: 8081 
     1632                 
     1633                scope addr_3 = new IPv6Address("::1");  
     1634                address: "::1" 
     1635                port: PORT_ANY 
     1636                 
     1637                Also in the IPv6Address constructor can specify the service name 
     1638                or port as string 
     1639                 
     1640                scope addr_3 = new IPv6Address("::", "ssh");  
     1641                address: "::" 
     1642                port: 22 (ssh service port) 
     1643                 
     1644                scope addr_4 = new IPv6Address("::", "8080");  
     1645                address: "::" 
     1646                port: 8080 
     1647                 
     1648***********************************************************************/  
     1649                 
     1650class IPv6Address : Address  
     1651{  
     1652        protected:  
     1653          
     1654        this() {  
     1655        }  
     1656  
     1657        /***********************************************************************  
     1658          
     1659  
     1660        ***********************************************************************/  
     1661  
     1662        struct sockaddr_in6  
     1663        {  
     1664                ushort sin_family;  
     1665                ushort sin_port;  
     1666                  
     1667                uint sin6_flowinfo;  
     1668                ubyte[16] sin6_addr;  
     1669                uint sin6_scope_id;  
     1670        }  
     1671          
     1672        sockaddr_in6 sin;  
     1673  
     1674        this(sockaddr* sa) {  
     1675                sin = *cast(sockaddr_in6*)sa;  
     1676        }  
     1677          
     1678        /***********************************************************************  
     1679  
     1680  
     1681        ***********************************************************************/  
     1682  
     1683        sockaddr* name()  
     1684        {  
     1685                return cast(sockaddr*)&sin;  
     1686        }  
     1687  
     1688  
     1689        /***********************************************************************  
     1690  
     1691  
     1692        ***********************************************************************/  
     1693  
     1694        int nameLen()  
     1695        {  
     1696                return sin.sizeof;  
     1697        }  
     1698  
     1699  
     1700        public:  
     1701  
     1702        const ushort PORT_ANY = 0;  
     1703  
     1704  
     1705        /***********************************************************************  
     1706  
     1707  
     1708        ***********************************************************************/  
     1709  
     1710        ushort port()  
     1711        {  
     1712                return ntohs(sin.sin_port);  
     1713        }  
     1714  
     1715                /*********************************************************** 
     1716                 
     1717                Create IPv6Address with zero address 
     1718                                 
     1719                ***********************************************************/ 
     1720                 
     1721        this(int port)  
     1722        {  
     1723          this("::", port); 
     1724        }  
     1725                 
     1726                /***********************************************************************  
     1727  
     1728                -port- can be PORT_ANY  
     1729                -addr- is an IP address or host name  
     1730  
     1731        ***********************************************************************/  
     1732                 
     1733        this(char[] addr, int port = PORT_ANY)  
     1734        {  
     1735                version(Win32)  
     1736                                {  
     1737                  if(!getaddrinfo) exception("This platform does not support IPv6.");  
     1738                }  
     1739                addrinfo* info;  
     1740                addrinfo hints;  
     1741                hints.ai_family = AddressFamily.INET6;  
     1742                int error = getaddrinfo((addr ~ '\0').ptr, null, &hints, &info);  
     1743                if(error != 0) {  
     1744                        exception(fromStringz(gai_strerror(error)));  
     1745                }  
     1746                sin = *cast(sockaddr_in6*)(info.ai_addr);  
     1747                sin.sin_port = htons(port);  
     1748        }  
     1749          
     1750          
     1751        /***********************************************************************  
     1752  
     1753                -service- can be a port number or service name  
     1754                -addr- is an IP address or host name  
     1755  
     1756        ***********************************************************************/  
     1757  
     1758        this(char[] addr, char[] service)  
     1759        {  
     1760                version(Win32)  
     1761                                {  
     1762                  if(!getaddrinfo) exception("This platform does not support IPv6.");  
     1763                }  
     1764                addrinfo* info;  
     1765                addrinfo hints;  
     1766                hints.ai_family = AddressFamily.INET6;  
     1767                int error = getaddrinfo((addr ~ '\0').ptr, (service ~ '\0').ptr, &hints, &info);  
     1768                if(error != 0) {  
     1769                        exception(fromStringz(gai_strerror(error)));  
     1770                }  
     1771                sin = *cast(sockaddr_in6*)(info.ai_addr);  
     1772        }  
     1773  
     1774  
     1775        ubyte[] addr()  
     1776        {  
     1777                return sin.sin6_addr;  
     1778        }  
     1779  
     1780  
     1781        /***********************************************************************  
     1782  
     1783  
     1784        ***********************************************************************/  
     1785  
     1786        char[] toString()  
     1787        {  
     1788                return "[" ~ toAddrString ~ "]:" ~ toPortString;  
     1789        }  
     1790}  
    12671791 
     1792debug(Unittest) 
     1793{ 
     1794        unittest 
     1795        { 
     1796        IPv6Address ia = new IPv6Address("7628:0d18:11a3:09d7:1f34:8a2e:07a0:765d", 8080); 
     1797        assert(ia.toString() == "[7628:0d18:11a3:09d7:1f34:8a2e:07a0:765d]:8080"); 
     1798        } 
     1799} 
    12681800/******************************************************************************* 
    12691801 
    12701802 
  • /root/buff/trunk-r5403/trunk/tango/net/device/Socket.d

    old new  
    6969 
    7070        /*********************************************************************** 
    7171         
     72                Create an Internet Socket with the provided characteristics 
     73 
     74        ***********************************************************************/ 
     75 
     76                this (Address addr)  
     77                {  
     78                                this (addr.addressFamily, SocketType.STREAM, ProtocolType.TCP);  
     79                } 
     80                 
     81        /*********************************************************************** 
     82         
    7283                Create an Internet socket 
    7384 
    7485        ***********************************************************************/ 
     
    546557 
    547558        this (Address addr, int backlog=32, bool reuse=false) 
    548559        { 
     560                super (addr); 
    549561                berkeley.addressReuse(reuse).bind(addr).listen(backlog); 
    550562        } 
    551563 
  • /root/buff/trunk-r5403/trunk/tango/sys/darwin/consts/socket.d

    old new  
    8484        SHUT_WR = 1, 
    8585        SHUT_RDWR = 2 
    8686    } 
     87 
     88     enum: int 
     89     { 
     90        AI_PASSIVE = 0x00000001, /// get address to use bind() 
     91        AI_CANONNAME = 0x00000002, /// fill ai_canonname 
     92        AI_NUMERICHOST = 0x00000004, /// prevent host name resolution 
     93        AI_NUMERICSERV = 0x00000008, /// prevent service name resolution valid flags for addrinfo (not a standard def, apps should not use it) 
     94        AI_ALL = 0x00000100, /// IPv6 and IPv4-mapped (with AI_V4MAPPED)  
     95        AI_V4MAPPED_CFG = 0x00000200, /// accept IPv4-mapped if kernel supports 
     96        AI_ADDRCONFIG = 0x00000400, /// only if any address is assigned 
     97        AI_V4MAPPED = 0x00000800, /// accept IPv4-mapped IPv6 address special recommended flags for getipnodebyname 
     98        AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG), 
     99        AI_DEFAULT = (AI_V4MAPPED_CFG | AI_ADDRCONFIG), 
     100     } 
     101 
     102    enum 
     103    { 
     104        EAI_BADFLAGS = 3,   /// Invalid value for `ai_flags' field. 
     105        EAI_NONAME = 8, /// NAME or SERVICE is unknown. 
     106        EAI_AGAIN = 2,  /// Temporary failure in name resolution. 
     107        EAI_FAIL = 4,   /// Non-recoverable failure in name res. 
     108        EAI_NODATA = 7, /// No address associated with NAME. 
     109        EAI_FAMILY = 5, /// `ai_family' not supported. 
     110        EAI_SOCKTYPE = 10,  /// `ai_socktype' not supported. 
     111        EAI_SERVICE = 9,    /// SERVICE not supported for `ai_socktype'. 
     112        EAI_MEMORY = 6, /// Memory allocation failure. 
     113    }    
     114 
     115    enum 
     116    { 
     117        NI_MAXHOST = 1025, 
     118        NI_MAXSERV = 32, 
     119        NI_NUMERICHOST = 0x00000002,    /// Don't try to look up hostname. 
     120        NI_NUMERICSERV = 0x00000008,    /// Don't convert port number to name. 
     121        NI_NOFQDN = 0x00000001, /// Only return nodename portion. 
     122        NI_NAMEREQD = 0x00000004,   /// Don't return numeric addresses. 
     123        NI_DGRAM = 0x00000010,  /// Look up UDP service rather than TCP. 
     124    }    
  • /root/buff/trunk-r5403/trunk/tango/sys/freebsd/consts/socket.d

    old new  
    112112        SHUT_RDWR = 2 
    113113    } 
    114114 
     115     enum: int 
     116     { 
     117        AI_PASSIVE = 0x00000001, /// get address to use bind() 
     118        AI_CANONNAME = 0x00000002, /// fill ai_canonname 
     119        AI_NUMERICHOST = 0x00000004, /// prevent host name resolution 
     120        AI_NUMERICSERV = 0x00000008, /// prevent service name resolution valid flags for addrinfo (not a standard def, apps should not use it) 
     121        AI_ALL = 0x00000100, /// IPv6 and IPv4-mapped (with AI_V4MAPPED)  
     122        AI_V4MAPPED_CFG = 0x00000200, /// accept IPv4-mapped if kernel supports 
     123        AI_ADDRCONFIG = 0x00000400, /// only if any address is assigned 
     124        AI_V4MAPPED = 0x00000800, /// accept IPv4-mapped IPv6 address special recommended flags for getipnodebyname 
     125        AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG), 
     126        AI_DEFAULT = (AI_V4MAPPED_CFG | AI_ADDRCONFIG), 
     127     } 
     128                 
     129 
     130    enum 
     131    { 
     132        EAI_BADFLAGS = 3,   /// Invalid value for `ai_flags' field. 
     133        EAI_NONAME = 8, /// NAME or SERVICE is unknown. 
     134        EAI_AGAIN = 2,  /// Temporary failure in name resolution. 
     135        EAI_FAIL = 4,   /// Non-recoverable failure in name res. 
     136        EAI_NODATA = 7, /// No address associated with NAME. 
     137        EAI_FAMILY = 5, /// `ai_family' not supported. 
     138        EAI_SOCKTYPE = 10,  /// `ai_socktype' not supported. 
     139        EAI_SERVICE = 9,    /// SERVICE not supported for `ai_socktype'. 
     140        EAI_MEMORY = 6, /// Memory allocation failure. 
     141    }    
     142 
     143    enum 
     144    { 
     145        NI_MAXHOST = 1025, 
     146        NI_MAXSERV = 32, 
     147        NI_NUMERICHOST = 0x00000002,    /// Don't try to look up hostname. 
     148        NI_NUMERICSERV = 0x00000008,    /// Don't convert port number to name. 
     149        NI_NOFQDN = 0x00000001, /// Only return nodename portion. 
     150        NI_NAMEREQD = 0x00000004,   /// Don't return numeric addresses. 
     151        NI_DGRAM = 0x00000010,  /// Look up UDP service rather than TCP. 
     152    }    
     153 
     154             
  • /root/buff/trunk-r5403/trunk/tango/sys/linux/consts/socket.d

    old new  
    109109      SHUT_WR, /* No more transmissions.  */ 
    110110      SHUT_RDWR /* No more receptions or transmissions.  */ 
    111111    } 
    112      
     112                 
     113    enum: int 
     114    { 
     115        AI_PASSIVE  = 0x0001,   /// Socket address is intended for `bind' 
     116        AI_CANONNAME =  0x0002, /// Request for canonical name. 
     117        AI_NUMERICHOST = 0x0004,    /// Don't use name resolution. 
     118        AI_V4MAPPED = 0x0008,   /// IPv4 mapped addresses are acceptable. 
     119        AI_ALL = 0x0010,    /// Return IPv4 mapped and IPv6 addresses. 
     120        AI_ADDRCONFIG = 0x0020, /// Use configuration of this host to choose returned address type. 
     121        AI_NUMERICSERV = 0x0400,    /// Don't use name resolution.   
     122        AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG), 
     123        AI_DEFAULT = (AI_V4MAPPED | AI_ADDRCONFIG), 
     124    } 
     125 
     126    enum 
     127    { 
     128        EAI_BADFLAGS = -1,  /// Invalid value for `ai_flags' field. 
     129        EAI_NONAME = -2,    /// NAME or SERVICE is unknown. 
     130        EAI_AGAIN = -3, /// Temporary failure in name resolution. 
     131        EAI_FAIL = -4,  /// Non-recoverable failure in name res. 
     132        EAI_NODATA = -5,    /// No address associated with NAME. 
     133        EAI_FAMILY = -6,    /// `ai_family' not supported. 
     134        EAI_SOCKTYPE = -7,  /// `ai_socktype' not supported. 
     135        EAI_SERVICE = -8,   /// SERVICE not supported for `ai_socktype'. 
     136        EAI_MEMORY = -10,   /// Memory allocation failure. 
     137    }    
     138 
     139    enum 
     140    { 
     141        NI_MAXHOST = 1025, 
     142        NI_MAXSERV = 32, 
     143        NI_NUMERICHOST = 1, /// Don't try to look up hostname. 
     144        NI_NUMERICSERV = 2, /// Don't convert port number to name. 
     145        NI_NOFQDN = 4,  /// Only return nodename portion. 
     146        NI_NAMEREQD = 8,    /// Don't return numeric addresses. 
     147        NI_DGRAM = 16,  /// Look up UDP service rather than TCP. 
     148    }    
     149 
     150     
    113151    // non cross platform. 
    114152    /+ 
    115153        /* Bits in the FLAGS argument to `send', `recv', et al.  */ 
  • /root/buff/trunk-r5403/trunk/tango/sys/solaris/consts/socket.d

    old new  
    111111        SHUT_RDWR = 2 
    112112    } 
    113113         
     114    enum: int 
     115    { 
     116         AI_PASSIVE = 0x0008,   /// intended for bind() + listen() 
     117         AI_CANONNAME = 0x0010, /// return canonical version of host 
     118         AI_NUMERICHOST = 0x0020,   /// use numeric node address string 
     119         AI_NUMERICSERV = 0x0040,   /// servname is assumed numeric 
     120         AI_V4MAPPED = 0x0001,  /// IPv4 mapped addresses if no IPv6 
     121         AI_ALL = 0x0002,   /// IPv6 and IPv4 mapped addresses 
     122         AI_ADDRCONFIG = 0x0004,    /// AAAA or A records only if IPv6/IPv4 cnfg'd 
     123         AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG), 
     124         AI_DEFAULT = (AI_V4MAPPED | AI_ADDRCONFIG), 
     125    } 
     126 
     127     
     128    enum 
     129    { 
     130        EAI_BADFLAGS = 3,   /// Invalid value for `ai_flags' field. 
     131        EAI_NONAME = 8, /// NAME or SERVICE is unknown. 
     132        EAI_AGAIN = 2,  /// Temporary failure in name resolution. 
     133        EAI_FAIL = 4,   /// Non-recoverable failure in name res. 
     134        EAI_NODATA = 7, /// No address associated with NAME. 
     135        EAI_FAMILY = 5, /// `ai_family' not supported. 
     136        EAI_SOCKTYPE = 10,  /// `ai_socktype' not supported. 
     137        EAI_SERVICE = 9,    /// SERVICE not supported for `ai_socktype'. 
     138        EAI_MEMORY = 6, /// Memory allocation failure. 
     139    }    
     140 
     141    enum 
     142    { 
     143        NI_MAXHOST = 1025, 
     144        NI_MAXSERV = 32, 
     145        NI_NUMERICHOST = 0x0002,    /// Don't try to look up hostname. 
     146        NI_NUMERICSERV = 0x0008,    /// Don't convert port number to name. 
     147        NI_NOFQDN = 0x0001, /// Only return nodename portion. 
     148        NI_NAMEREQD = 0x0004,   /// Don't return numeric addresses. 
     149        NI_DGRAM = 0x0010,  /// Look up UDP service rather than TCP. 
     150    }    
     151 
  • /root/buff/trunk-r5403/trunk/tango/sys/win32/consts/socket.d

    old new  
    129129    SHUT_WR = 1, 
    130130    SHUT_RDWR = 2 
    131131} 
     132 
     133enum: int 
     134{ 
     135     AI_PASSIVE = 0x00000001, /// Socket address will be used in bind() call 
     136     AI_CANONNAME = 0x00000002,  /// Return canonical name in first ai_canonname 
     137     AI_NUMERICHOST = 0x00000004 , /// Nodename must be a numeric address string 
     138     AI_NUMERICSERV = 0x00000008,  /// Servicename must be a numeric port number 
     139     AI_ALL = 0x00000100,  /// Query both IP6 and IP4 with AI_V4MAPPED 
     140     AI_ADDRCONFIG = 0x00000400,  /// Resolution only if global address configured 
     141     AI_V4MAPPED = 0x00000800,  /// On v6 failure, query v4 and convert to V4MAPPED format 
     142     AI_NON_AUTHORITATIVE = 0x00004000,  /// LUP_NON_AUTHORITATIVE 
     143     AI_SECURE = 0x00008000,  /// LUP_SECURE 
     144     AI_RETURN_PREFERRED_NAMES = 0x00010000,  /// LUP_RETURN_PREFERRED_NAMES 
     145     AI_FQDN = 0x00020000,  /// Return the FQDN in ai_canonname 
     146     AI_FILESERVER = 0x00040000, /// Resolving fileserver name resolution  
     147     AI_MASK = (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST | AI_NUMERICSERV | AI_ADDRCONFIG), 
     148     AI_DEFAULT = (AI_V4MAPPED | AI_ADDRCONFIG), 
     149} 
     150 
     151enum 
     152{ 
     153    EAI_BADFLAGS = 10022,   /// Invalid value for `ai_flags' field. 
     154    EAI_NONAME = 11001, /// NAME or SERVICE is unknown. 
     155    EAI_AGAIN = 11002,  /// Temporary failure in name resolution. 
     156    EAI_FAIL = 11003,   /// Non-recoverable failure in name res. 
     157    EAI_NODATA = 11001, /// No address associated with NAME. 
     158    EAI_FAMILY = 10047, /// `ai_family' not supported. 
     159    EAI_SOCKTYPE = 10044,   /// `ai_socktype' not supported. 
     160    EAI_SERVICE = 10109,    /// SERVICE not supported for `ai_socktype'. 
     161    EAI_MEMORY = 8, /// Memory allocation failure. 
     162}    
     163 
     164 
     165  
     166enum 
     167{ 
     168    NI_MAXHOST = 1025, 
     169    NI_MAXSERV = 32, 
     170    NI_NUMERICHOST = 0x01,  /// Don't try to look up hostname. 
     171    NI_NUMERICSERV = 0x02,  /// Don't convert port number to name. 
     172    NI_NOFQDN = 0x04,   /// Only return nodename portion. 
     173    NI_NAMEREQD = 0x08, /// Don't return numeric addresses. 
     174    NI_DGRAM = 0x10,    /// Look up UDP service rather than TCP. 
     175}    
     176