mirror of
https://github.com/dlang/phobos.git
synced 2025-04-27 13:40:20 +03:00
3276 lines
94 KiB
D
3276 lines
94 KiB
D
// Written in the D programming language
|
|
|
|
/*
|
|
Copyright (C) 2004-2011 Christopher E. Miller
|
|
|
|
Boost Software License - Version 1.0 - August 17th, 2003
|
|
|
|
Permission is hereby granted, free of charge, to any person or organization
|
|
obtaining a copy of the software and accompanying documentation covered by
|
|
this license (the "Software") to use, reproduce, display, distribute,
|
|
execute, and transmit the Software, and to prepare derivative works of the
|
|
Software, and to permit third-parties to whom the Software is furnished to
|
|
do so, all subject to the following:
|
|
|
|
The copyright notices in the Software and this entire statement, including
|
|
the above license grant, this restriction and the following disclaimer,
|
|
must be included in all copies of the Software, in whole or in part, and
|
|
all derivative works of the Software, unless such copies or derivative
|
|
works are solely in the form of machine-executable object code generated by
|
|
a source language processor.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
|
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
|
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
DEALINGS IN THE SOFTWARE.
|
|
|
|
socket.d 1.4
|
|
Jan 2011
|
|
|
|
Thanks to Benjamin Herr for his assistance.
|
|
*/
|
|
|
|
/**
|
|
* Example: See $(SAMPLESRC listener.d) and $(SAMPLESRC htmlget.d)
|
|
* License: <a href="http://www.boost.org/LICENSE_1_0.txt">Boost License 1.0</a>.
|
|
* Authors: Christopher E. Miller, $(WEB klickverbot.at, David Nadlinger),
|
|
* $(WEB thecybershadow.net, Vladimir Panteleev)
|
|
* Source: $(PHOBOSSRC std/_socket.d)
|
|
* Macros:
|
|
* WIKI=Phobos/StdSocket
|
|
*/
|
|
|
|
module std.socket;
|
|
|
|
import core.stdc.stdint, std.string, std.c.string, std.c.stdlib, std.conv;
|
|
|
|
import core.stdc.config;
|
|
import core.time : dur, Duration;
|
|
import std.algorithm : max;
|
|
import std.exception : assumeUnique, enforce, collectException;
|
|
|
|
version(Windows)
|
|
{
|
|
pragma (lib, "ws2_32.lib");
|
|
pragma (lib, "wsock32.lib");
|
|
|
|
private import std.c.windows.windows, std.c.windows.winsock, std.windows.syserror;
|
|
private alias std.c.windows.winsock.timeval _ctimeval;
|
|
private alias std.c.windows.winsock.linger _clinger;
|
|
|
|
enum socket_t : SOCKET { INVALID_SOCKET }
|
|
private const int _SOCKET_ERROR = SOCKET_ERROR;
|
|
|
|
|
|
private int _lasterr()
|
|
{
|
|
return WSAGetLastError();
|
|
}
|
|
}
|
|
else version(Posix)
|
|
{
|
|
version(linux)
|
|
import std.c.linux.socket : AF_IPX, AF_APPLETALK, SOCK_RDM,
|
|
IPPROTO_IGMP, IPPROTO_GGP, IPPROTO_PUP, IPPROTO_IDP,
|
|
SD_RECEIVE, SD_SEND, SD_BOTH, MSG_NOSIGNAL, INADDR_NONE,
|
|
TCP_KEEPIDLE, TCP_KEEPINTVL;
|
|
else version(OSX)
|
|
import std.c.osx.socket : AF_IPX, AF_APPLETALK, SOCK_RDM,
|
|
IPPROTO_IGMP, IPPROTO_GGP, IPPROTO_PUP, IPPROTO_IDP,
|
|
SD_RECEIVE, SD_SEND, SD_BOTH, INADDR_NONE;
|
|
else version(FreeBSD)
|
|
{
|
|
import core.sys.posix.sys.socket;
|
|
import core.sys.posix.sys.select;
|
|
import std.c.freebsd.socket;
|
|
private enum SD_RECEIVE = SHUT_RD;
|
|
private enum SD_SEND = SHUT_WR;
|
|
private enum SD_BOTH = SHUT_RDWR;
|
|
}
|
|
else
|
|
static assert(false);
|
|
|
|
import core.sys.posix.netdb;
|
|
import core.sys.posix.sys.un : sockaddr_un;
|
|
private import core.sys.posix.fcntl;
|
|
private import core.sys.posix.unistd;
|
|
private import core.sys.posix.arpa.inet;
|
|
private import core.sys.posix.netinet.tcp;
|
|
private import core.sys.posix.netinet.in_;
|
|
private import core.sys.posix.sys.time;
|
|
//private import core.sys.posix.sys.select;
|
|
private import core.sys.posix.sys.socket;
|
|
private alias core.sys.posix.sys.time.timeval _ctimeval;
|
|
private alias core.sys.posix.sys.socket.linger _clinger;
|
|
|
|
private import core.stdc.errno;
|
|
|
|
enum socket_t : int32_t { init = -1 }
|
|
private const int _SOCKET_ERROR = -1;
|
|
|
|
|
|
private int _lasterr()
|
|
{
|
|
return errno;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
static assert(0); // No socket support yet.
|
|
}
|
|
|
|
version(unittest)
|
|
{
|
|
static assert(is(uint32_t == uint));
|
|
static assert(is(uint16_t == ushort));
|
|
|
|
private import std.stdio : writefln;
|
|
|
|
// Print a message on exception instead of failing the unittest.
|
|
private void softUnittest(void delegate() test, int line = __LINE__)
|
|
{
|
|
try
|
|
test();
|
|
catch (Throwable e)
|
|
{
|
|
writefln(" --- std.socket(%d) test fails depending on environment ---", line);
|
|
writefln(" (%s)", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Base exception thrown by $(D std.socket).
|
|
class SocketException: Exception
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, file, line, next);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__)
|
|
{
|
|
super(msg, next, file, line);
|
|
}
|
|
}
|
|
|
|
|
|
// Needs to be public so that SocketOSException can be thrown outside of
|
|
// std.socket (since it uses it as a default argument), but it probably doesn't
|
|
// need to actually show up in the docs, since there's not really any public
|
|
// need for it outside of being a default argument.
|
|
string formatSocketError(int err)
|
|
{
|
|
version(Posix)
|
|
{
|
|
char[80] buf;
|
|
const(char)* cs;
|
|
version (linux)
|
|
{
|
|
cs = strerror_r(err, buf.ptr, buf.length);
|
|
}
|
|
else version (OSX)
|
|
{
|
|
auto errs = strerror_r(err, buf.ptr, buf.length);
|
|
if (errs == 0)
|
|
cs = buf.ptr;
|
|
else
|
|
return "Socket error " ~ to!string(err);
|
|
}
|
|
else version (FreeBSD)
|
|
{
|
|
auto errs = strerror_r(err, buf.ptr, buf.length);
|
|
if (errs == 0)
|
|
cs = buf.ptr;
|
|
else
|
|
return "Socket error " ~ to!string(err);
|
|
}
|
|
else
|
|
static assert(0);
|
|
|
|
auto len = strlen(cs);
|
|
|
|
if(cs[len - 1] == '\n')
|
|
len--;
|
|
if(cs[len - 1] == '\r')
|
|
len--;
|
|
return cs[0 .. len].idup;
|
|
}
|
|
else
|
|
version(Windows)
|
|
{
|
|
return sysErrorString(err);
|
|
}
|
|
else
|
|
return "Socket error " ~ to!string(err);
|
|
}
|
|
|
|
/// Retrieve the error message for the most recently encountered network error.
|
|
@property string lastSocketError()
|
|
{
|
|
return formatSocketError(_lasterr());
|
|
}
|
|
|
|
/// Socket exceptions representing network errors reported by the operating
|
|
/// system.
|
|
class SocketOSException: SocketException
|
|
{
|
|
int errorCode; /// Platform-specific error code.
|
|
|
|
///
|
|
this(string msg,
|
|
string file = __FILE__,
|
|
size_t line = __LINE__,
|
|
Throwable next = null,
|
|
int err = _lasterr(),
|
|
string function(int) errorFormatter = &formatSocketError)
|
|
{
|
|
errorCode = err;
|
|
|
|
if (msg.length)
|
|
super(msg ~ ": " ~ errorFormatter(err), file, line, next);
|
|
else
|
|
super(errorFormatter(err), file, line, next);
|
|
}
|
|
|
|
///
|
|
this(string msg,
|
|
Throwable next,
|
|
string file = __FILE__,
|
|
size_t line = __LINE__,
|
|
int err = _lasterr(),
|
|
string function(int) errorFormatter = &formatSocketError)
|
|
{
|
|
this(msg, file, line, next, err, errorFormatter);
|
|
}
|
|
|
|
///
|
|
this(string msg,
|
|
int err,
|
|
string function(int) errorFormatter = &formatSocketError,
|
|
string file = __FILE__,
|
|
size_t line = __LINE__,
|
|
Throwable next = null)
|
|
{
|
|
this(msg, file, line, next, err, errorFormatter);
|
|
}
|
|
}
|
|
|
|
/// Socket exceptions representing invalid parameters specified by user code.
|
|
class SocketParameterException: SocketException
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, file, line, next);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__)
|
|
{
|
|
super(msg, next, file, line);
|
|
}
|
|
}
|
|
|
|
/// Socket exceptions representing attempts to use network capabilities not
|
|
/// available on the current system.
|
|
class SocketFeatureException: SocketException
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, file, line, next);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__)
|
|
{
|
|
super(msg, next, file, line);
|
|
}
|
|
}
|
|
|
|
|
|
/// Return $(D true) if the last socket operation failed because the socket
|
|
/// was in non-blocking mode and the operation would have blocked.
|
|
bool wouldHaveBlocked()
|
|
{
|
|
version(Windows)
|
|
return _lasterr() == WSAEWOULDBLOCK;
|
|
else version(Posix)
|
|
return _lasterr() == EAGAIN;
|
|
else
|
|
static assert(0);
|
|
}
|
|
|
|
private __gshared typeof(&getnameinfo) getnameinfoPointer;
|
|
private __gshared typeof(&getaddrinfo) getaddrinfoPointer;
|
|
private __gshared typeof(&freeaddrinfo) freeaddrinfoPointer;
|
|
|
|
shared static this()
|
|
{
|
|
version(Windows)
|
|
{
|
|
WSADATA wd;
|
|
|
|
// Winsock will still load if an older version is present.
|
|
// The version is just a request.
|
|
int val;
|
|
val = WSAStartup(0x2020, &wd);
|
|
if(val) // Request Winsock 2.2 for IPv6.
|
|
throw new SocketOSException("Unable to initialize socket library", val);
|
|
|
|
// These functions may not be present on older Windows versions.
|
|
// See the comment in InternetAddress.toHostNameString() for details.
|
|
auto ws2Lib = GetModuleHandleA("ws2_32.dll");
|
|
if (ws2Lib)
|
|
{
|
|
getnameinfoPointer = cast(typeof(getnameinfoPointer))
|
|
GetProcAddress(ws2Lib, "getnameinfo");
|
|
getaddrinfoPointer = cast(typeof(getaddrinfoPointer))
|
|
GetProcAddress(ws2Lib, "getaddrinfo");
|
|
freeaddrinfoPointer = cast(typeof(freeaddrinfoPointer))
|
|
GetProcAddress(ws2Lib, "freeaddrinfo");
|
|
}
|
|
}
|
|
else version(Posix)
|
|
{
|
|
getnameinfoPointer = &getnameinfo;
|
|
getaddrinfoPointer = &getaddrinfo;
|
|
freeaddrinfoPointer = &freeaddrinfo;
|
|
}
|
|
}
|
|
|
|
|
|
shared static ~this()
|
|
{
|
|
version(Windows)
|
|
{
|
|
WSACleanup();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The communication domain used to resolve an address.
|
|
*/
|
|
enum AddressFamily: int
|
|
{
|
|
UNSPEC = AF_UNSPEC, /// Unspecified address family
|
|
UNIX = AF_UNIX, /// Local communication
|
|
INET = AF_INET, /// Internet Protocol version 4
|
|
IPX = AF_IPX, /// Novell IPX
|
|
APPLETALK = AF_APPLETALK, /// AppleTalk
|
|
INET6 = AF_INET6, /// Internet Protocol version 6
|
|
}
|
|
|
|
|
|
/**
|
|
* Communication semantics
|
|
*/
|
|
enum SocketType: int
|
|
{
|
|
STREAM = SOCK_STREAM, /// Sequenced, reliable, two-way communication-based byte streams
|
|
DGRAM = SOCK_DGRAM, /// Connectionless, unreliable datagrams with a fixed maximum length; data may be lost or arrive out of order
|
|
RAW = SOCK_RAW, /// Raw protocol access
|
|
RDM = SOCK_RDM, /// Reliably-delivered message datagrams
|
|
SEQPACKET = SOCK_SEQPACKET, /// Sequenced, reliable, two-way connection-based datagrams with a fixed maximum length
|
|
}
|
|
|
|
|
|
/**
|
|
* Protocol
|
|
*/
|
|
enum ProtocolType: int
|
|
{
|
|
IP = IPPROTO_IP, /// Internet Protocol version 4
|
|
ICMP = IPPROTO_ICMP, /// Internet Control Message Protocol
|
|
IGMP = IPPROTO_IGMP, /// Internet Group Management Protocol
|
|
GGP = IPPROTO_GGP, /// Gateway to Gateway Protocol
|
|
TCP = IPPROTO_TCP, /// Transmission Control Protocol
|
|
PUP = IPPROTO_PUP, /// PARC Universal Packet Protocol
|
|
UDP = IPPROTO_UDP, /// User Datagram Protocol
|
|
IDP = IPPROTO_IDP, /// Xerox NS protocol
|
|
RAW = IPPROTO_RAW, /// Raw IP packets
|
|
IPV6 = IPPROTO_IPV6, /// Internet Protocol version 6
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D Protocol) is a class for retrieving protocol information.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* auto proto = new Protocol;
|
|
* writeln("About protocol TCP:");
|
|
* if (proto.getProtocolByType(ProtocolType.TCP))
|
|
* {
|
|
* writefln(" Name: %s", proto.name);
|
|
* foreach(string s; proto.aliases)
|
|
* writefln(" Alias: %s", s);
|
|
* }
|
|
* else
|
|
* writeln(" No information found");
|
|
* ---
|
|
*/
|
|
class Protocol
|
|
{
|
|
/// These members are populated when one of the following functions are called successfully:
|
|
ProtocolType type;
|
|
string name; /// ditto
|
|
string[] aliases; /// ditto
|
|
|
|
|
|
void populate(protoent* proto)
|
|
{
|
|
type = cast(ProtocolType)proto.p_proto;
|
|
name = to!string(proto.p_name);
|
|
|
|
int i;
|
|
for(i = 0;; i++)
|
|
{
|
|
if(!proto.p_aliases[i])
|
|
break;
|
|
}
|
|
|
|
if(i)
|
|
{
|
|
aliases = new string[i];
|
|
for(i = 0; i != aliases.length; i++)
|
|
{
|
|
aliases[i] =
|
|
to!string(proto.p_aliases[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aliases = null;
|
|
}
|
|
}
|
|
|
|
/** Returns: false on failure */
|
|
bool getProtocolByName(in char[] name)
|
|
{
|
|
protoent* proto;
|
|
proto = getprotobyname(toStringz(name));
|
|
if(!proto)
|
|
return false;
|
|
populate(proto);
|
|
return true;
|
|
}
|
|
|
|
|
|
/** Returns: false on failure */
|
|
// Same as getprotobynumber().
|
|
bool getProtocolByType(ProtocolType type)
|
|
{
|
|
protoent* proto;
|
|
proto = getprotobynumber(type);
|
|
if(!proto)
|
|
return false;
|
|
populate(proto);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
Protocol proto = new Protocol;
|
|
assert(proto.getProtocolByType(ProtocolType.TCP));
|
|
//writeln("About protocol TCP:");
|
|
//writefln("\tName: %s", proto.name);
|
|
// foreach(string s; proto.aliases)
|
|
// {
|
|
// writefln("\tAlias: %s", s);
|
|
// }
|
|
assert(proto.name == "tcp");
|
|
assert(proto.aliases.length == 1 && proto.aliases[0] == "TCP");
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D Service) is a class for retrieving service information.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* auto serv = new Service;
|
|
* writeln("About service epmap:");
|
|
* if (serv.getServiceByName("epmap", "tcp"))
|
|
* {
|
|
* writefln(" Service: %s", serv.name);
|
|
* writefln(" Port: %d", serv.port);
|
|
* writefln(" Protocol: %s", serv.protocolName);
|
|
* foreach (string s; serv.aliases)
|
|
* writefln(" Alias: %s", s);
|
|
* }
|
|
* else
|
|
* writefln(" No service for epmap.");
|
|
* ---
|
|
*/
|
|
class Service
|
|
{
|
|
/// These members are populated when one of the following functions are called successfully:
|
|
string name;
|
|
string[] aliases; /// ditto
|
|
ushort port; /// ditto
|
|
string protocolName; /// ditto
|
|
|
|
|
|
void populate(servent* serv)
|
|
{
|
|
name = to!string(serv.s_name);
|
|
port = ntohs(cast(ushort)serv.s_port);
|
|
protocolName = to!string(serv.s_proto);
|
|
|
|
int i;
|
|
for(i = 0;; i++)
|
|
{
|
|
if(!serv.s_aliases[i])
|
|
break;
|
|
}
|
|
|
|
if(i)
|
|
{
|
|
aliases = new string[i];
|
|
for(i = 0; i != aliases.length; i++)
|
|
{
|
|
aliases[i] =
|
|
to!string(serv.s_aliases[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aliases = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If a protocol name is omitted, any protocol will be matched.
|
|
* Returns: false on failure.
|
|
*/
|
|
bool getServiceByName(in char[] name, in char[] protocolName = null)
|
|
{
|
|
servent* serv;
|
|
serv = getservbyname(toStringz(name), protocolName !is null ? toStringz(protocolName) : null);
|
|
if(!serv)
|
|
return false;
|
|
populate(serv);
|
|
return true;
|
|
}
|
|
|
|
|
|
/// ditto
|
|
bool getServiceByPort(ushort port, in char[] protocolName = null)
|
|
{
|
|
servent* serv;
|
|
serv = getservbyport(port, protocolName !is null ? toStringz(protocolName) : null);
|
|
if(!serv)
|
|
return false;
|
|
populate(serv);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
Service serv = new Service;
|
|
if(serv.getServiceByName("epmap", "tcp"))
|
|
{
|
|
// writefln("About service epmap:");
|
|
// writefln("\tService: %s", serv.name);
|
|
// writefln("\tPort: %d", serv.port);
|
|
// writefln("\tProtocol: %s", serv.protocolName);
|
|
// foreach(string s; serv.aliases)
|
|
// {
|
|
// writefln("\tAlias: %s", s);
|
|
// }
|
|
// For reasons unknown this is loc-srv on Wine and epmap on Windows
|
|
assert(serv.name == "loc-srv" || serv.name == "epmap", serv.name);
|
|
assert(serv.port == 135);
|
|
assert(serv.protocolName == "tcp");
|
|
}
|
|
else
|
|
{
|
|
writefln("No service for epmap.");
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Class for exceptions thrown from an $(D InternetHost).
|
|
*/
|
|
class HostException: SocketOSException
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null, int err = _lasterr())
|
|
{
|
|
super(msg, file, line, next, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__, int err = _lasterr())
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, int err, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* $(D InternetHost) is a class for resolving IPv4 addresses.
|
|
*
|
|
* Consider using $(D getAddress), $(D parseAddress) and $(D Address) methods
|
|
* instead of using this class directly.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* auto ih = new InternetHost;
|
|
*
|
|
* // Forward lookup
|
|
* writeln("About www.digitalmars.com:");
|
|
* if (ih.getHostByName("www.digitalmars.com"))
|
|
* {
|
|
* writefln(" Name: %s", ih.name);
|
|
* auto ip = InternetAddress.addrToString(ih.addrList[0]);
|
|
* writefln(" IP address: %s", ip);
|
|
* foreach (string s; ih.aliases)
|
|
* writefln(" Alias: %s", s);
|
|
* writeln("---");
|
|
*
|
|
* // Reverse lookup
|
|
* writefln("About IP %s:", ip);
|
|
* if (ih.getHostByAddr(ih.addrList[0]))
|
|
* {
|
|
* writefln(" Name: %s", ih.name);
|
|
* foreach (string s; ih.aliases)
|
|
* writefln(" Alias: %s", s);
|
|
* }
|
|
* else
|
|
* writeln(" Reverse lookup failed");
|
|
* }
|
|
* else
|
|
* writeln(" Can't resolve www.digitalmars.com");
|
|
* ---
|
|
*/
|
|
class InternetHost
|
|
{
|
|
/// These members are populated when one of the following functions are called successfully:
|
|
string name;
|
|
string[] aliases; /// ditto
|
|
uint[] addrList; /// ditto
|
|
|
|
|
|
void validHostent(hostent* he)
|
|
{
|
|
if(he.h_addrtype != cast(int)AddressFamily.INET || he.h_length != 4)
|
|
throw new HostException("Address family mismatch");
|
|
}
|
|
|
|
|
|
void populate(hostent* he)
|
|
{
|
|
int i;
|
|
char* p;
|
|
|
|
name = to!string(he.h_name);
|
|
|
|
for(i = 0;; i++)
|
|
{
|
|
p = he.h_aliases[i];
|
|
if(!p)
|
|
break;
|
|
}
|
|
|
|
if(i)
|
|
{
|
|
aliases = new string[i];
|
|
for(i = 0; i != aliases.length; i++)
|
|
{
|
|
aliases[i] =
|
|
to!string(he.h_aliases[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aliases = null;
|
|
}
|
|
|
|
for(i = 0;; i++)
|
|
{
|
|
p = he.h_addr_list[i];
|
|
if(!p)
|
|
break;
|
|
}
|
|
|
|
if(i)
|
|
{
|
|
addrList = new uint[i];
|
|
for(i = 0; i != addrList.length; i++)
|
|
{
|
|
addrList[i] = ntohl(*(cast(uint*)he.h_addr_list[i]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
addrList = null;
|
|
}
|
|
}
|
|
|
|
private bool getHostNoSync(string opMixin, T)(T param)
|
|
{
|
|
mixin(opMixin);
|
|
if (!he)
|
|
return false;
|
|
validHostent(he);
|
|
populate(he);
|
|
return true;
|
|
}
|
|
|
|
version(Windows)
|
|
alias getHostNoSync getHost;
|
|
else
|
|
{
|
|
// posix systems use global state for return value, so we
|
|
// must synchronize across all threads
|
|
private bool getHost(string opMixin, T)(T param)
|
|
{
|
|
synchronized(this.classinfo)
|
|
return getHostNoSync!(opMixin, T)(param);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve host name.
|
|
* Returns: false if unable to resolve.
|
|
*/
|
|
bool getHostByName(in char[] name)
|
|
{
|
|
static if (is(typeof(gethostbyname_r)))
|
|
{
|
|
return getHostNoSync!q{
|
|
hostent he_v;
|
|
hostent* he;
|
|
ubyte[256] buffer_v = void;
|
|
auto buffer = buffer_v[];
|
|
auto param_z = std.string.toStringz(param);
|
|
while (true)
|
|
{
|
|
he = &he_v;
|
|
int errno;
|
|
if (gethostbyname_r(param_z, he, buffer.ptr, buffer.length, &he, &errno) == ERANGE)
|
|
buffer.length = buffer.length * 2;
|
|
else
|
|
break;
|
|
}
|
|
}(name);
|
|
}
|
|
else
|
|
{
|
|
return getHost!q{
|
|
auto he = gethostbyname(toStringz(param));
|
|
}(name);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve IPv4 address number.
|
|
*
|
|
* Params:
|
|
* addr = The IPv4 address to resolve, in host byte order.
|
|
* Returns:
|
|
* false if unable to resolve.
|
|
*/
|
|
bool getHostByAddr(uint addr)
|
|
{
|
|
return getHost!q{
|
|
auto x = htonl(param);
|
|
auto he = gethostbyaddr(&x, 4, cast(int)AddressFamily.INET);
|
|
}(addr);
|
|
}
|
|
|
|
/**
|
|
* Same as previous, but addr is an IPv4 address string in the
|
|
* dotted-decimal form $(I a.b.c.d).
|
|
* Returns: false if unable to resolve.
|
|
*/
|
|
bool getHostByAddr(in char[] addr)
|
|
{
|
|
return getHost!q{
|
|
auto x = inet_addr(std.string.toStringz(param));
|
|
enforce(x != INADDR_NONE,
|
|
new SocketParameterException("Invalid IPv4 address"));
|
|
auto he = gethostbyaddr(&x, 4, cast(int)AddressFamily.INET);
|
|
}(addr);
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
InternetHost ih = new InternetHost;
|
|
|
|
ih.getHostByAddr(0x7F_00_00_01);
|
|
assert(ih.addrList[0] == 0x7F_00_00_01);
|
|
ih.getHostByAddr("127.0.0.1");
|
|
assert(ih.addrList[0] == 0x7F_00_00_01);
|
|
|
|
softUnittest({
|
|
if (!ih.getHostByName("www.digitalmars.com"))
|
|
return; // don't fail if not connected to internet
|
|
//writefln("addrList.length = %d", ih.addrList.length);
|
|
assert(ih.addrList.length);
|
|
InternetAddress ia = new InternetAddress(ih.addrList[0], InternetAddress.PORT_ANY);
|
|
assert(ih.name == "www.digitalmars.com" || ih.name == "digitalmars.com",
|
|
ih.name);
|
|
// writefln("IP address = %s", ia.toAddrString());
|
|
// writefln("name = %s", ih.name);
|
|
// foreach(int i, string s; ih.aliases)
|
|
// {
|
|
// writefln("aliases[%d] = %s", i, s);
|
|
// }
|
|
// writefln("---");
|
|
|
|
//assert(ih.getHostByAddr(ih.addrList[0]));
|
|
// writefln("name = %s", ih.name);
|
|
// foreach(int i, string s; ih.aliases)
|
|
// {
|
|
// writefln("aliases[%d] = %s", i, s);
|
|
// }
|
|
});
|
|
}
|
|
|
|
|
|
/// Holds information about a socket _address retrieved by $(D getAddressInfo).
|
|
struct AddressInfo
|
|
{
|
|
AddressFamily family; /// Address _family
|
|
SocketType type; /// Socket _type
|
|
ProtocolType protocol; /// Protocol
|
|
Address address; /// Socket _address
|
|
string canonicalName; /// Canonical name, when $(D AddressInfoFlags.CANONNAME) is used.
|
|
}
|
|
|
|
// A subset of flags supported on all platforms with getaddrinfo.
|
|
/// Specifies option flags for $(D getAddressInfo).
|
|
enum AddressInfoFlags: int
|
|
{
|
|
/// The resulting addresses will be used in a call to $(D Socket.bind).
|
|
PASSIVE = AI_PASSIVE,
|
|
|
|
/// The canonical name is returned in $(D canonicalName) member in the first $(D AddressInfo).
|
|
CANONNAME = AI_CANONNAME,
|
|
|
|
/// The $(D node) parameter passed to $(D getAddressInfo) must be a numeric string.
|
|
/// This will suppress any potentially lengthy network host address lookups.
|
|
NUMERICHOST = AI_NUMERICHOST,
|
|
}
|
|
|
|
|
|
/// On POSIX, getaddrinfo uses its own error codes, and thus has its own
|
|
/// formatting function.
|
|
private string formatGaiError(int err)
|
|
{
|
|
version(Windows)
|
|
{
|
|
return sysErrorString(err);
|
|
}
|
|
else
|
|
{
|
|
synchronized
|
|
return to!string(gai_strerror(err));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Provides _protocol-independent translation from host names to socket
|
|
* addresses. If advanced functionality is not required, consider using
|
|
* $(D getAddress) for compatibility with older systems.
|
|
*
|
|
* Returns: Array with one $(D AddressInfo) per socket address.
|
|
*
|
|
* Throws: $(D SocketOSException) on failure, or $(D SocketFeatureException)
|
|
* if this functionality is not available on the current system.
|
|
*
|
|
* Params:
|
|
* node = string containing host name or numeric address
|
|
* options = optional additional parameters, identified by type:
|
|
* $(UL $(LI $(D string) - service name or port number)
|
|
* $(LI $(D AddressInfoFlags) - option flags)
|
|
* $(LI $(D AddressFamily) - address family to filter by)
|
|
* $(LI $(D SocketType) - socket type to filter by)
|
|
* $(LI $(D ProtocolType) - protocol to filter by))
|
|
*
|
|
* Example:
|
|
* ---
|
|
* // Roundtrip DNS resolution
|
|
* auto results = getAddressInfo("www.digitalmars.com");
|
|
* assert(results[0].address.toHostNameString() ==
|
|
* "digitalmars.com");
|
|
*
|
|
* // Canonical name
|
|
* results = getAddressInfo("www.digitalmars.com",
|
|
* AddressInfoFlags.CANONNAME);
|
|
* assert(results[0].canonicalName == "digitalmars.com");
|
|
*
|
|
* // IPv6 resolution
|
|
* results = getAddressInfo("ipv6.google.com");
|
|
* assert(results[0].family == AddressFamily.INET6);
|
|
*
|
|
* // Multihomed resolution
|
|
* results = getAddressInfo("google.com");
|
|
* assert(results.length > 1);
|
|
*
|
|
* // Parsing IPv4
|
|
* results = getAddressInfo("127.0.0.1",
|
|
* AddressInfoFlags.NUMERICHOST);
|
|
* assert(results.length && results[0].family ==
|
|
* AddressFamily.INET);
|
|
*
|
|
* // Parsing IPv6
|
|
* results = getAddressInfo("::1",
|
|
* AddressInfoFlags.NUMERICHOST);
|
|
* assert(results.length && results[0].family ==
|
|
* AddressFamily.INET6);
|
|
* ---
|
|
*/
|
|
AddressInfo[] getAddressInfo(T...)(in char[] node, T options)
|
|
{
|
|
const(char)[] service = null;
|
|
addrinfo hints;
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
foreach (option; options)
|
|
{
|
|
static if (is(typeof(option) : const(char)[]))
|
|
service = option;
|
|
else
|
|
static if (is(typeof(option) == AddressInfoFlags))
|
|
hints.ai_flags |= option;
|
|
else
|
|
static if (is(typeof(option) == AddressFamily))
|
|
hints.ai_family = option;
|
|
else
|
|
static if (is(typeof(option) == SocketType))
|
|
hints.ai_socktype = option;
|
|
else
|
|
static if (is(typeof(option) == ProtocolType))
|
|
hints.ai_protocol = option;
|
|
else
|
|
static assert(0, "Unknown getAddressInfo option type: " ~ typeof(option).stringof);
|
|
}
|
|
|
|
return getAddressInfoImpl(node, service, &hints);
|
|
}
|
|
|
|
private AddressInfo[] getAddressInfoImpl(in char[] node, in char[] service, addrinfo* hints)
|
|
{
|
|
if (getaddrinfoPointer && freeaddrinfoPointer)
|
|
{
|
|
addrinfo* ai_res;
|
|
|
|
int ret = getaddrinfoPointer(
|
|
node is null ? null : std.string.toStringz(node),
|
|
service is null ? null : std.string.toStringz(service),
|
|
hints, &ai_res);
|
|
scope(exit) if (ai_res) freeaddrinfoPointer(ai_res);
|
|
enforce(ret == 0, new SocketOSException("getaddrinfo error", ret, &formatGaiError));
|
|
|
|
AddressInfo[] result;
|
|
// Use const to force UnknownAddressReference to copy the sockaddr.
|
|
for (const(addrinfo)* ai = ai_res; ai; ai = ai.ai_next)
|
|
result ~= AddressInfo(
|
|
cast(AddressFamily) ai.ai_family,
|
|
cast(SocketType ) ai.ai_socktype,
|
|
cast(ProtocolType ) ai.ai_protocol,
|
|
new UnknownAddressReference(ai.ai_addr, cast(socklen_t) ai.ai_addrlen),
|
|
ai.ai_canonname ? to!string(ai.ai_canonname) : null);
|
|
|
|
assert(result.length > 0);
|
|
return result;
|
|
}
|
|
|
|
throw new SocketFeatureException("Address info lookup is not available " ~
|
|
"on this system.");
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
if (getaddrinfoPointer)
|
|
{
|
|
// Roundtrip DNS resolution
|
|
auto results = getAddressInfo("www.digitalmars.com");
|
|
assert(results[0].address.toHostNameString() == "digitalmars.com");
|
|
|
|
// Canonical name
|
|
results = getAddressInfo("www.digitalmars.com",
|
|
AddressInfoFlags.CANONNAME);
|
|
assert(results[0].canonicalName == "digitalmars.com");
|
|
|
|
// IPv6 resolution
|
|
//results = getAddressInfo("ipv6.google.com");
|
|
//assert(results[0].family == AddressFamily.INET6);
|
|
|
|
// Multihomed resolution
|
|
//results = getAddressInfo("google.com");
|
|
//assert(results.length > 1);
|
|
|
|
// Parsing IPv4
|
|
results = getAddressInfo("127.0.0.1", AddressInfoFlags.NUMERICHOST);
|
|
assert(results.length && results[0].family == AddressFamily.INET);
|
|
|
|
// Parsing IPv6
|
|
results = getAddressInfo("::1", AddressInfoFlags.NUMERICHOST);
|
|
assert(results.length && results[0].family == AddressFamily.INET6);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
private ushort serviceToPort(in char[] service)
|
|
{
|
|
if (service == "")
|
|
return InternetAddress.PORT_ANY;
|
|
else
|
|
if (isNumeric(service))
|
|
return to!ushort(service);
|
|
else
|
|
{
|
|
auto s = new Service();
|
|
s.getServiceByName(service);
|
|
return s.port;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Provides _protocol-independent translation from host names to socket
|
|
* addresses. Uses $(D getAddressInfo) if the current system supports it,
|
|
* and $(D InternetHost) otherwise.
|
|
*
|
|
* Returns: Array with one $(D Address) instance per socket address.
|
|
*
|
|
* Throws: $(D SocketOSException) on failure.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* writeln("Resolving www.digitalmars.com:");
|
|
* try
|
|
* {
|
|
* auto addresses = getAddress("www.digitalmars.com");
|
|
* foreach (address; addresses)
|
|
* writefln(" IP: %s", address.toAddrString());
|
|
* }
|
|
* catch (SocketException e)
|
|
* writefln(" Lookup failed: %s", e.msg);
|
|
* ---
|
|
*/
|
|
Address[] getAddress(in char[] hostname, in char[] service = null)
|
|
{
|
|
if (getaddrinfoPointer && freeaddrinfoPointer)
|
|
{
|
|
// use getAddressInfo
|
|
Address[] results;
|
|
auto infos = getAddressInfo(hostname, service);
|
|
foreach (ref info; infos)
|
|
results ~= info.address;
|
|
return results;
|
|
}
|
|
else
|
|
return getAddress(hostname, serviceToPort(service));
|
|
}
|
|
|
|
/// ditto
|
|
Address[] getAddress(in char[] hostname, ushort port)
|
|
{
|
|
if (getaddrinfoPointer && freeaddrinfoPointer)
|
|
return getAddress(hostname, to!string(port));
|
|
else
|
|
{
|
|
// use getHostByName
|
|
auto ih = new InternetHost;
|
|
if (!ih.getHostByName(hostname))
|
|
throw new AddressException(
|
|
text("Unable to resolve host '", hostname, "'"));
|
|
|
|
Address[] results;
|
|
foreach (uint addr; ih.addrList)
|
|
results ~= new InternetAddress(addr, port);
|
|
return results;
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
auto addresses = getAddress("63.105.9.61");
|
|
assert(addresses.length && addresses[0].toAddrString() == "63.105.9.61");
|
|
|
|
if (getaddrinfoPointer)
|
|
{
|
|
// test via gethostbyname
|
|
auto getaddrinfoPointerBackup = getaddrinfoPointer;
|
|
getaddrinfoPointer = null;
|
|
scope(exit) getaddrinfoPointer = getaddrinfoPointerBackup;
|
|
|
|
addresses = getAddress("63.105.9.61");
|
|
assert(addresses.length && addresses[0].toAddrString() == "63.105.9.61");
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Provides _protocol-independent parsing of network addresses. Does not
|
|
* attempt name resolution. Uses $(D getAddressInfo) with
|
|
* $(D AddressInfoFlags.NUMERICHOST) if the current system supports it, and
|
|
* $(D InternetAddress) otherwise.
|
|
*
|
|
* Returns: An $(D Address) instance representing specified address.
|
|
*
|
|
* Throws: $(D SocketException) on failure.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* writeln("Enter IP address:");
|
|
* string ip = readln().chomp();
|
|
* try
|
|
* {
|
|
* Address address = parseAddress(ip);
|
|
* writefln("Looking up reverse of %s:",
|
|
* address.toAddrString());
|
|
* try
|
|
* {
|
|
* string reverse = address.toHostNameString();
|
|
* if (reverse)
|
|
* writefln(" Reverse name: %s", reverse);
|
|
* else
|
|
* writeln(" Reverse hostname not found.");
|
|
* }
|
|
* catch (SocketException e)
|
|
* writefln(" Lookup error: %s", e.msg);
|
|
* }
|
|
* catch (SocketException e)
|
|
* {
|
|
* writefln(" %s is not a valid IP address: %s",
|
|
* ip, e.msg);
|
|
* }
|
|
* ---
|
|
*/
|
|
Address parseAddress(in char[] hostaddr, in char[] service = null)
|
|
{
|
|
if (getaddrinfoPointer && freeaddrinfoPointer)
|
|
return getAddressInfo(hostaddr, service, AddressInfoFlags.NUMERICHOST)[0].address;
|
|
else
|
|
return parseAddress(hostaddr, serviceToPort(service));
|
|
}
|
|
|
|
/// ditto
|
|
Address parseAddress(in char[] hostaddr, ushort port)
|
|
{
|
|
if (getaddrinfoPointer && freeaddrinfoPointer)
|
|
return parseAddress(hostaddr, to!string(port));
|
|
else
|
|
{
|
|
auto in4_addr = InternetAddress.parse(hostaddr);
|
|
enforce(in4_addr != InternetAddress.ADDR_NONE,
|
|
new SocketParameterException("Invalid IP address"));
|
|
return new InternetAddress(in4_addr, port);
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
auto address = parseAddress("63.105.9.61");
|
|
assert(address.toAddrString() == "63.105.9.61");
|
|
|
|
if (getaddrinfoPointer)
|
|
{
|
|
// test via inet_addr
|
|
auto getaddrinfoPointerBackup = getaddrinfoPointer;
|
|
getaddrinfoPointer = null;
|
|
scope(exit) getaddrinfoPointer = getaddrinfoPointerBackup;
|
|
|
|
address = parseAddress("63.105.9.61");
|
|
assert(address.toAddrString() == "63.105.9.61");
|
|
}
|
|
|
|
assert(collectException!SocketException(parseAddress("Invalid IP address")));
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* Class for exceptions thrown from an $(D Address).
|
|
*/
|
|
class AddressException: SocketOSException
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null, int err = _lasterr())
|
|
{
|
|
super(msg, file, line, next, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__, int err = _lasterr())
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, int err, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D Address) is an abstract class for representing a socket addresses.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* writeln("About www.google.com port 80:");
|
|
* try
|
|
* {
|
|
* Address[] addresses = getAddress("www.google.com", 80);
|
|
* writefln(" %d addresses found.", addresses.length);
|
|
* foreach (int i, Address a; addresses)
|
|
* {
|
|
* writefln(" Address %d:", i+1);
|
|
* writefln(" IP address: %s", a.toAddrString());
|
|
* writefln(" Hostname: %s", a.toHostNameString());
|
|
* writefln(" Port: %s", a.toPortString());
|
|
* writefln(" Service name: %s",
|
|
* a.toServiceNameString());
|
|
* }
|
|
* }
|
|
* catch (SocketException e)
|
|
* writefln(" Lookup error: %s", e.msg);
|
|
* ---
|
|
*/
|
|
abstract class Address
|
|
{
|
|
/// Returns pointer to underlying $(D sockaddr) structure.
|
|
abstract @property sockaddr* name();
|
|
abstract @property const(sockaddr)* name() const; /// ditto
|
|
|
|
/// Returns actual size of underlying $(D sockaddr) structure.
|
|
abstract @property socklen_t nameLen() const;
|
|
|
|
/// Family of this address.
|
|
@property AddressFamily addressFamily() const
|
|
{
|
|
return cast(AddressFamily) name.sa_family;
|
|
}
|
|
|
|
// Common code for toAddrString and toHostNameString
|
|
private final string toHostString(bool numeric) const
|
|
{
|
|
// getnameinfo() is the recommended way to perform a reverse (name)
|
|
// lookup on both Posix and Windows. However, it is only available
|
|
// on Windows XP and above, and not included with the WinSock import
|
|
// libraries shipped with DMD. Thus, we check for getnameinfo at
|
|
// runtime in the shared module constructor, and use it if it's
|
|
// available in the base class method. Classes for specific network
|
|
// families (e.g. InternetHost) override this method and use a
|
|
// deprecated, albeit commonly-available method when getnameinfo()
|
|
// is not available.
|
|
// http://technet.microsoft.com/en-us/library/aa450403.aspx
|
|
if (getnameinfoPointer)
|
|
{
|
|
auto buf = new char[NI_MAXHOST];
|
|
auto ret = getnameinfoPointer(
|
|
name, nameLen,
|
|
buf.ptr, cast(uint)buf.length,
|
|
null, 0,
|
|
numeric ? NI_NUMERICHOST : NI_NAMEREQD);
|
|
|
|
if (!numeric)
|
|
{
|
|
if (ret==EAI_NONAME)
|
|
return null;
|
|
version(Windows)
|
|
if (ret==WSANO_DATA)
|
|
return null;
|
|
}
|
|
|
|
enforce(ret == 0, new AddressException("Could not get " ~
|
|
(numeric ? "host address" : "host name")));
|
|
return assumeUnique(buf[0 .. strlen(buf.ptr)]);
|
|
}
|
|
|
|
throw new SocketFeatureException((numeric ? "Host address" : "Host name") ~
|
|
" lookup for this address family is not available on this system.");
|
|
}
|
|
|
|
// Common code for toPortString and toServiceNameString
|
|
private final string toServiceString(bool numeric) const
|
|
{
|
|
// See toHostNameString() for details about getnameinfo().
|
|
if (getnameinfoPointer)
|
|
{
|
|
auto buf = new char[NI_MAXSERV];
|
|
enforce(getnameinfoPointer(
|
|
name, nameLen,
|
|
null, 0,
|
|
buf.ptr, cast(uint)buf.length,
|
|
numeric ? NI_NUMERICSERV : NI_NAMEREQD
|
|
) == 0, new AddressException("Could not get " ~
|
|
(numeric ? "port number" : "service name")));
|
|
return assumeUnique(buf[0 .. strlen(buf.ptr)]);
|
|
}
|
|
|
|
throw new SocketFeatureException((numeric ? "Port number" : "Service name") ~
|
|
" lookup for this address family is not available on this system.");
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the host address as a human-readable string.
|
|
*
|
|
* Throws: $(D AddressException) on failure, or $(D SocketFeatureException)
|
|
* if address retrieval for this address family is not available on the
|
|
* current system.
|
|
*/
|
|
string toAddrString() const
|
|
{
|
|
return toHostString(true);
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the host name as a fully qualified domain name.
|
|
*
|
|
* Returns: The FQDN corresponding to this $(D Address), or $(D null) if
|
|
* the host name did not resolve.
|
|
*
|
|
* Throws: $(D AddressException) on error, or $(D SocketFeatureException)
|
|
* if host name lookup for this address family is not available on the
|
|
* current system.
|
|
*/
|
|
string toHostNameString() const
|
|
{
|
|
return toHostString(false);
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the numeric port number as a string.
|
|
*
|
|
* Throws: $(D AddressException) on failure, or $(D SocketFeatureException)
|
|
* if port number retrieval for this address family is not available on the
|
|
* current system.
|
|
*/
|
|
string toPortString() const
|
|
{
|
|
return toServiceString(true);
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the service name as a string.
|
|
*
|
|
* Throws: $(D AddressException) on failure, or $(D SocketFeatureException)
|
|
* if service name lookup for this address family is not available on the
|
|
* current system.
|
|
*/
|
|
string toServiceNameString() const
|
|
{
|
|
return toServiceString(false);
|
|
}
|
|
|
|
/// Human readable string representing this address.
|
|
override string toString() const
|
|
{
|
|
try
|
|
{
|
|
string host = toAddrString();
|
|
string port = toPortString();
|
|
if (host.indexOf(':') >= 0)
|
|
return "[" ~ host ~ "]:" ~ port;
|
|
else
|
|
return host ~ ":" ~ port;
|
|
}
|
|
catch (SocketException)
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* $(D UnknownAddress) encapsulates an unknown socket address.
|
|
*/
|
|
class UnknownAddress: Address
|
|
{
|
|
protected:
|
|
sockaddr sa;
|
|
|
|
|
|
public:
|
|
override @property sockaddr* name()
|
|
{
|
|
return &sa;
|
|
}
|
|
|
|
override @property const(sockaddr)* name() const
|
|
{
|
|
return &sa;
|
|
}
|
|
|
|
|
|
override @property socklen_t nameLen() const
|
|
{
|
|
return cast(socklen_t) sa.sizeof;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D UnknownAddressReference) encapsulates a reference to an arbitrary
|
|
* socket address.
|
|
*/
|
|
class UnknownAddressReference: Address
|
|
{
|
|
protected:
|
|
sockaddr* sa;
|
|
socklen_t len;
|
|
|
|
public:
|
|
/// Constructs an $(D Address) with a reference to the specified $(D sockaddr).
|
|
this(sockaddr* sa, socklen_t len)
|
|
{
|
|
this.sa = sa;
|
|
this.len = len;
|
|
}
|
|
|
|
/// Constructs an $(D Address) with a copy of the specified $(D sockaddr).
|
|
this(const(sockaddr)* sa, socklen_t len)
|
|
{
|
|
this.sa = cast(sockaddr*) (cast(ubyte*)sa)[0..len].dup.ptr;
|
|
this.len = len;
|
|
}
|
|
|
|
override @property sockaddr* name()
|
|
{
|
|
return sa;
|
|
}
|
|
|
|
override @property const(sockaddr)* name() const
|
|
{
|
|
return sa;
|
|
}
|
|
|
|
|
|
override @property socklen_t nameLen() const
|
|
{
|
|
return cast(socklen_t) len;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D InternetAddress) encapsulates an IPv4 (Internet Protocol version 4)
|
|
* socket address.
|
|
*
|
|
* Consider using $(D getAddress), $(D parseAddress) and $(D Address) methods
|
|
* instead of using this class directly.
|
|
*/
|
|
class InternetAddress: Address
|
|
{
|
|
protected:
|
|
sockaddr_in sin;
|
|
|
|
|
|
this()
|
|
{
|
|
}
|
|
|
|
|
|
public:
|
|
override @property sockaddr* name()
|
|
{
|
|
return cast(sockaddr*)&sin;
|
|
}
|
|
|
|
override @property const(sockaddr)* name() const
|
|
{
|
|
return cast(const(sockaddr)*)&sin;
|
|
}
|
|
|
|
|
|
override @property socklen_t nameLen() const
|
|
{
|
|
return cast(socklen_t) sin.sizeof;
|
|
}
|
|
|
|
|
|
enum uint ADDR_ANY = INADDR_ANY; /// Any IPv4 host address.
|
|
enum uint ADDR_NONE = INADDR_NONE; /// An invalid IPv4 host address.
|
|
enum ushort PORT_ANY = 0; /// Any IPv4 port number.
|
|
|
|
/// Returns the IPv4 _port number (in host byte order).
|
|
@property ushort port() const
|
|
{
|
|
return ntohs(sin.sin_port);
|
|
}
|
|
|
|
/// Returns the IPv4 address number (in host byte order).
|
|
@property uint addr() const
|
|
{
|
|
return ntohl(sin.sin_addr.s_addr);
|
|
}
|
|
|
|
/**
|
|
* Construct a new $(D InternetAddress).
|
|
* Params:
|
|
* addr = an IPv4 address string in the dotted-decimal form a.b.c.d,
|
|
* or a host name which will be resolved using an $(D InternetHost)
|
|
* object.
|
|
* port = port number, may be $(D PORT_ANY).
|
|
*/
|
|
this(in char[] addr, ushort port)
|
|
{
|
|
uint uiaddr = parse(addr);
|
|
if(ADDR_NONE == uiaddr)
|
|
{
|
|
InternetHost ih = new InternetHost;
|
|
if(!ih.getHostByName(addr))
|
|
//throw new AddressException("Invalid internet address");
|
|
throw new AddressException(
|
|
text("Unable to resolve host '", addr, "'"));
|
|
uiaddr = ih.addrList[0];
|
|
}
|
|
sin.sin_family = AddressFamily.INET;
|
|
sin.sin_addr.s_addr = htonl(uiaddr);
|
|
sin.sin_port = htons(port);
|
|
}
|
|
|
|
/**
|
|
* Construct a new $(D InternetAddress).
|
|
* Params:
|
|
* addr = (optional) an IPv4 address in host byte order, may be $(D ADDR_ANY).
|
|
* port = port number, may be $(D PORT_ANY).
|
|
*/
|
|
this(uint addr, ushort port)
|
|
{
|
|
sin.sin_family = AddressFamily.INET;
|
|
sin.sin_addr.s_addr = htonl(addr);
|
|
sin.sin_port = htons(port);
|
|
}
|
|
|
|
/// ditto
|
|
this(ushort port)
|
|
{
|
|
sin.sin_family = AddressFamily.INET;
|
|
sin.sin_addr.s_addr = ADDR_ANY;
|
|
sin.sin_port = htons(port);
|
|
}
|
|
|
|
/// Human readable string representing the IPv4 address in dotted-decimal form.
|
|
override string toAddrString() const
|
|
{
|
|
return to!string(inet_ntoa(sin.sin_addr));
|
|
}
|
|
|
|
/// Human readable string representing the IPv4 port.
|
|
override string toPortString() const
|
|
{
|
|
return std.conv.to!string(port);
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the host name as a fully qualified domain name.
|
|
*
|
|
* Returns: The FQDN corresponding to this $(D InternetAddress), or
|
|
* $(D null) if the host name did not resolve.
|
|
*
|
|
* Throws: $(D AddressException) on error.
|
|
*/
|
|
override string toHostNameString() const
|
|
{
|
|
// getnameinfo() is the recommended way to perform a reverse (name)
|
|
// lookup on both Posix and Windows. However, it is only available
|
|
// on Windows XP and above, and not included with the WinSock import
|
|
// libraries shipped with DMD. Thus, we check for getnameinfo at
|
|
// runtime in the shared module constructor, and fall back to the
|
|
// deprecated getHostByAddr() if it could not be found. See also:
|
|
// http://technet.microsoft.com/en-us/library/aa450403.aspx
|
|
|
|
if (getnameinfoPointer)
|
|
return super.toHostNameString();
|
|
else
|
|
{
|
|
auto host = new InternetHost();
|
|
if (!host.getHostByAddr(ntohl(sin.sin_addr.s_addr)))
|
|
return null;
|
|
return host.name;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse an IPv4 address string in the dotted-decimal form $(I a.b.c.d)
|
|
* and return the number.
|
|
* Returns: If the string is not a legitimate IPv4 address,
|
|
* $(D ADDR_NONE) is returned.
|
|
*/
|
|
static uint parse(in char[] addr)
|
|
{
|
|
return ntohl(inet_addr(std.string.toStringz(addr)));
|
|
}
|
|
|
|
/**
|
|
* Convert an IPv4 address number in host byte order to a human readable
|
|
* string representing the IPv4 address in dotted-decimal form.
|
|
*/
|
|
static string addrToString(uint addr)
|
|
{
|
|
in_addr sin_addr;
|
|
sin_addr.s_addr = htonl(addr);
|
|
return to!string(inet_ntoa(sin_addr));
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
const InternetAddress ia = new InternetAddress("63.105.9.61", 80);
|
|
assert(ia.toString() == "63.105.9.61:80");
|
|
});
|
|
|
|
softUnittest({
|
|
// test reverse lookup
|
|
auto ih = new InternetHost;
|
|
if (ih.getHostByName("digitalmars.com"))
|
|
{
|
|
const ia = new InternetAddress(ih.addrList[0], 80);
|
|
assert(ia.toHostNameString() == "digitalmars.com");
|
|
|
|
if (getnameinfoPointer)
|
|
{
|
|
// test reverse lookup, via gethostbyaddr
|
|
auto getnameinfoPointerBackup = getnameinfoPointer;
|
|
getnameinfoPointer = null;
|
|
scope(exit) getnameinfoPointer = getnameinfoPointerBackup;
|
|
|
|
assert(ia.toHostNameString() == "digitalmars.com");
|
|
}
|
|
}
|
|
});
|
|
|
|
version (SlowTests)
|
|
softUnittest({
|
|
// test failing reverse lookup
|
|
const InternetAddress ia = new InternetAddress("127.114.111.120", 80);
|
|
assert(ia.toHostNameString() is null);
|
|
|
|
if (getnameinfoPointer)
|
|
{
|
|
// test failing reverse lookup, via gethostbyaddr
|
|
auto getnameinfoPointerBackup = getnameinfoPointer;
|
|
getnameinfoPointer = null;
|
|
scope(exit) getnameinfoPointer = getnameinfoPointerBackup;
|
|
|
|
assert(ia.toHostNameString() is null);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D Internet6Address) encapsulates an IPv6 (Internet Protocol version 6)
|
|
* socket address.
|
|
*
|
|
* Consider using $(D getAddress), $(D parseAddress) and $(D Address) methods
|
|
* instead of using this class directly.
|
|
*/
|
|
class Internet6Address: Address
|
|
{
|
|
protected:
|
|
sockaddr_in6 sin6;
|
|
|
|
|
|
this()
|
|
{
|
|
}
|
|
|
|
|
|
public:
|
|
override @property sockaddr* name()
|
|
{
|
|
return cast(sockaddr*)&sin6;
|
|
}
|
|
|
|
override @property const(sockaddr)* name() const
|
|
{
|
|
return cast(const(sockaddr)*)&sin6;
|
|
}
|
|
|
|
|
|
override @property socklen_t nameLen() const
|
|
{
|
|
return cast(socklen_t) sin6.sizeof;
|
|
}
|
|
|
|
|
|
/// Any IPv6 host address.
|
|
static @property ref const(ubyte)[16] ADDR_ANY()
|
|
{
|
|
const(ubyte)[16]* addr;
|
|
static if (is(typeof(IN6ADDR_ANY)))
|
|
return addr = &IN6ADDR_ANY.s6_addr, *addr;
|
|
else
|
|
static if (is(typeof(in6addr_any)))
|
|
return addr = &in6addr_any.s6_addr, *addr;
|
|
else
|
|
static assert(0);
|
|
}
|
|
|
|
/// Any IPv6 port number.
|
|
enum ushort PORT_ANY = 0;
|
|
|
|
/// Returns the IPv6 port number.
|
|
@property ushort port() const
|
|
{
|
|
return ntohs(sin6.sin6_port);
|
|
}
|
|
|
|
/// Returns the IPv6 address.
|
|
@property ubyte[16] addr() const
|
|
{
|
|
return sin6.sin6_addr.s6_addr;
|
|
}
|
|
|
|
/**
|
|
* Construct a new $(D Internet6Address).
|
|
* Params:
|
|
* addr = an IPv6 host address string in the form described in RFC 2373,
|
|
* or a host name which will be resolved using $(D getAddressInfo).
|
|
* service = (optional) service name.
|
|
*/
|
|
this(in char[] addr, in char[] service = null)
|
|
{
|
|
auto results = getAddressInfo(addr, service, AddressFamily.INET6);
|
|
assert(results.length && results[0].family == AddressFamily.INET6);
|
|
sin6 = *cast(sockaddr_in6*)results[0].address.name;
|
|
}
|
|
|
|
/**
|
|
* Construct a new $(D Internet6Address).
|
|
* Params:
|
|
* addr = an IPv6 host address string in the form described in RFC 2373,
|
|
* or a host name which will be resolved using $(D getAddressInfo).
|
|
* port = port number, may be $(D PORT_ANY).
|
|
*/
|
|
this(in char[] addr, ushort port)
|
|
{
|
|
if (port == PORT_ANY)
|
|
this(addr);
|
|
else
|
|
this(addr, to!string(port));
|
|
}
|
|
|
|
/**
|
|
* Construct a new $(D Internet6Address).
|
|
* Params:
|
|
* addr = (optional) an IPv6 host address in host byte order, or
|
|
* $(D ADDR_ANY).
|
|
* port = port number, may be $(D PORT_ANY).
|
|
*/
|
|
this(ubyte[16] addr, ushort port)
|
|
{
|
|
sin6.sin6_family = AddressFamily.INET6;
|
|
sin6.sin6_addr.s6_addr = addr;
|
|
sin6.sin6_port = htons(port);
|
|
}
|
|
|
|
/// ditto
|
|
this(ushort port)
|
|
{
|
|
sin6.sin6_family = AddressFamily.INET6;
|
|
sin6.sin6_addr.s6_addr = ADDR_ANY;
|
|
sin6.sin6_port = htons(port);
|
|
}
|
|
|
|
/**
|
|
* Parse an IPv6 host address string as described in RFC 2373, and return the
|
|
* address.
|
|
* Throws: $(D SocketException) on error.
|
|
*/
|
|
static ubyte[16] parse(in char[] addr)
|
|
{
|
|
// Although we could use inet_pton here, it's only available on Windows
|
|
// versions starting with Vista, so use getAddressInfo with NUMERICHOST
|
|
// instead.
|
|
auto results = getAddressInfo(addr, AddressInfoFlags.NUMERICHOST);
|
|
if (results.length && results[0].family == AddressFamily.INET6)
|
|
return (cast(sockaddr_in6*)results[0].address.name).sin6_addr.s6_addr;
|
|
throw new AddressException("Not an IPv6 address", 0);
|
|
}
|
|
}
|
|
|
|
|
|
unittest
|
|
{
|
|
softUnittest({
|
|
const Internet6Address ia = new Internet6Address("::1", 80);
|
|
assert(ia.toString() == "[::1]:80");
|
|
});
|
|
}
|
|
|
|
|
|
version(StdDdoc)
|
|
{
|
|
/**
|
|
* $(D UnixAddress) encapsulates an address for a Unix domain socket
|
|
* ($(D AF_UNIX)). Available only on supported systems.
|
|
*/
|
|
class UnixAddress: Address
|
|
{
|
|
/// Construct a new $(D UnixAddress) from the specified path.
|
|
this(in char[] path);
|
|
|
|
/// Get the underlying _path.
|
|
@property string path() const;
|
|
|
|
/// ditto
|
|
override string toString() const;
|
|
}
|
|
}
|
|
else
|
|
static if (is(sockaddr_un))
|
|
{
|
|
class UnixAddress: Address
|
|
{
|
|
protected:
|
|
sockaddr_un* sun;
|
|
socklen_t len;
|
|
|
|
|
|
this()
|
|
{
|
|
}
|
|
|
|
|
|
public:
|
|
override @property sockaddr* name()
|
|
{
|
|
return cast(sockaddr*)sun;
|
|
}
|
|
|
|
override @property const(sockaddr)* name() const
|
|
{
|
|
return cast(const(sockaddr)*)sun;
|
|
}
|
|
|
|
|
|
override @property socklen_t nameLen() const
|
|
{
|
|
return len;
|
|
}
|
|
|
|
|
|
this(in char[] path)
|
|
{
|
|
len = cast(socklen_t)(sockaddr_un.init.sun_path.offsetof + path.length + 1);
|
|
sun = cast(sockaddr_un*) (new ubyte[len]).ptr;
|
|
sun.sun_family = AF_UNIX;
|
|
sun.sun_path.ptr[0..path.length] = (cast(byte[]) path)[];
|
|
sun.sun_path.ptr[path.length] = 0;
|
|
}
|
|
|
|
@property string path() const
|
|
{
|
|
return to!string(sun.sun_path.ptr);
|
|
}
|
|
|
|
override string toString() const
|
|
{
|
|
return path;
|
|
}
|
|
}
|
|
|
|
unittest
|
|
{
|
|
import core.stdc.stdio : remove;
|
|
|
|
immutable ubyte[] data = [1, 2, 3, 4];
|
|
Socket[2] pair;
|
|
|
|
auto name = "unix-address-family-unittest-socket-name";
|
|
auto address = new UnixAddress(name);
|
|
|
|
auto listener = new Socket(AddressFamily.UNIX, SocketType.STREAM);
|
|
scope(exit) listener.close();
|
|
|
|
listener.bind(address);
|
|
scope(exit) remove(toStringz(name));
|
|
|
|
listener.listen(1);
|
|
|
|
pair[0] = new Socket(AddressFamily.UNIX, SocketType.STREAM);
|
|
scope(exit) listener.close();
|
|
|
|
pair[0].connect(address);
|
|
scope(exit) pair[0].close();
|
|
|
|
pair[1] = listener.accept();
|
|
scope(exit) pair[1].close();
|
|
|
|
pair[0].send(data);
|
|
|
|
auto buf = new ubyte[data.length];
|
|
pair[1].receive(buf);
|
|
assert(buf == data);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Class for exceptions thrown by $(D Socket.accept).
|
|
*/
|
|
class SocketAcceptException: SocketOSException
|
|
{
|
|
///
|
|
this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null, int err = _lasterr())
|
|
{
|
|
super(msg, file, line, next, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__, int err = _lasterr())
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
|
|
///
|
|
this(string msg, int err, string file = __FILE__, size_t line = __LINE__, Throwable next = null)
|
|
{
|
|
super(msg, next, file, line, err);
|
|
}
|
|
}
|
|
|
|
/// How a socket is shutdown:
|
|
enum SocketShutdown: int
|
|
{
|
|
RECEIVE = SD_RECEIVE, /// socket receives are disallowed
|
|
SEND = SD_SEND, /// socket sends are disallowed
|
|
BOTH = SD_BOTH, /// both RECEIVE and SEND
|
|
}
|
|
|
|
|
|
/// Flags may be OR'ed together:
|
|
enum SocketFlags: int
|
|
{
|
|
NONE = 0, /// no flags specified
|
|
|
|
OOB = MSG_OOB, /// out-of-band stream data
|
|
PEEK = MSG_PEEK, /// peek at incoming data without removing it from the queue, only for receiving
|
|
DONTROUTE = MSG_DONTROUTE, /// data should not be subject to routing; this flag may be ignored. Only for sending
|
|
}
|
|
|
|
|
|
private mixin template FieldProxy(string target, string field)
|
|
{
|
|
mixin(`
|
|
@property typeof(`~target~`) `~field~`() const
|
|
{
|
|
return `~target~`;
|
|
}
|
|
|
|
/// ditto
|
|
@property typeof(`~target~`) `~field~`(typeof(`~target~`) value)
|
|
{
|
|
return `~target~` = value;
|
|
}
|
|
`);
|
|
}
|
|
|
|
|
|
/// Duration timeout value.
|
|
struct TimeVal
|
|
{
|
|
_ctimeval ctimeval;
|
|
alias typeof(ctimeval.tv_sec) tv_sec_t;
|
|
alias typeof(ctimeval.tv_usec) tv_usec_t;
|
|
|
|
version (StdDdoc) // no DDoc for string mixins, can't forward individual fields
|
|
{
|
|
tv_sec_t seconds; /// Number of _seconds.
|
|
tv_usec_t microseconds; /// Number of additional _microseconds.
|
|
}
|
|
else
|
|
{
|
|
// D interface
|
|
mixin FieldProxy!(`ctimeval.tv_sec`, `seconds`);
|
|
mixin FieldProxy!(`ctimeval.tv_usec`, `microseconds`);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* A collection of sockets for use with $(D Socket.select).
|
|
*
|
|
* $(D SocketSet) allows specifying the capacity of the underlying
|
|
* $(D fd_set), however users should be aware that the exact meaning of this
|
|
* value varies depending on the current platform:
|
|
* $(UL $(LI On POSIX, $(D fd_set) is a bit array of file descriptors. The
|
|
* $(D SocketSet) capacity specifies the highest file descriptor which can be
|
|
* stored in the set.)
|
|
* $(LI on Windows, $(D fd_set) is an array of socket handles. Capacity
|
|
* indicates the actual number of sockets that can be stored in the set.))
|
|
*/
|
|
class SocketSet
|
|
{
|
|
private:
|
|
version(Windows)
|
|
{
|
|
// the maximum number of sockets the allocated fd_set can hold
|
|
uint fdsetCapacity;
|
|
|
|
fd_set* set;
|
|
@property uint count() const { return set.fd_count; }
|
|
}
|
|
else version(Posix)
|
|
{
|
|
int fdsetMax;
|
|
|
|
fd_set setData;
|
|
final @property fd_set* set() { return &setData; }
|
|
final @property const(fd_set)* set() const { return &setData; }
|
|
int maxfd;
|
|
uint count;
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
* Set the capacity of this $(D SocketSet). The exact meaning of the
|
|
* $(D max) parameter varies from platform to platform.
|
|
* Throws: $(D SocketParameterException) if $(D max) exceeds this
|
|
* platform's maximum socket set size.
|
|
*/
|
|
this(uint max)
|
|
{
|
|
version(Windows)
|
|
{
|
|
fdsetCapacity = max;
|
|
set = FD_CREATE(max);
|
|
}
|
|
else version(Posix)
|
|
{
|
|
// TODO (needs druntime changes)
|
|
enforce(max <= FD_SETSIZE, new SocketParameterException(
|
|
"Maximum socket set size exceeded for this platform"));
|
|
fdsetMax = max;
|
|
}
|
|
reset();
|
|
}
|
|
|
|
/// Uses the default capacity for the system.
|
|
this()
|
|
{
|
|
this(FD_SETSIZE);
|
|
}
|
|
|
|
/// Reset the $(D SocketSet) so that there are 0 $(D Socket)s in the collection.
|
|
void reset()
|
|
{
|
|
FD_ZERO(set);
|
|
|
|
version(Posix)
|
|
{
|
|
maxfd = -1;
|
|
count = 0;
|
|
}
|
|
}
|
|
|
|
|
|
void add(socket_t s)
|
|
{
|
|
// Make sure too many sockets don't get added.
|
|
version(Windows)
|
|
{
|
|
enforce(count < fdsetCapacity, new SocketParameterException(
|
|
"SocketSet capacity exceeded"));
|
|
}
|
|
else version(Posix)
|
|
{
|
|
enforce(s < fdsetMax, new SocketParameterException(
|
|
"Socket descriptor index exceeds SocketSet capacity"));
|
|
}
|
|
|
|
FD_SET(s, set);
|
|
|
|
version(Posix)
|
|
{
|
|
++count;
|
|
if(s > maxfd)
|
|
maxfd = s;
|
|
}
|
|
}
|
|
|
|
/// Add a $(D Socket) to the collection.
|
|
/// Throws: $(D SocketParameterException) if the capacity of this
|
|
/// $(D SocketSet) has been exceeded.
|
|
void add(Socket s)
|
|
{
|
|
add(s.sock);
|
|
}
|
|
|
|
void remove(socket_t s)
|
|
{
|
|
version(Posix)
|
|
{
|
|
enforce(s < fdsetMax, new SocketParameterException(
|
|
"Socket descriptor index exceeds SocketSet capacity"));
|
|
}
|
|
|
|
FD_CLR(s, set);
|
|
version(Posix)
|
|
{
|
|
--count;
|
|
// note: adjusting maxfd would require scanning the set, not worth it
|
|
}
|
|
}
|
|
|
|
|
|
/// Remove this $(D Socket) from the collection.
|
|
void remove(Socket s)
|
|
{
|
|
remove(s.sock);
|
|
}
|
|
|
|
int isSet(socket_t s) const
|
|
{
|
|
version(Posix)
|
|
{
|
|
enforce(s < fdsetMax, new SocketParameterException(
|
|
"Socket descriptor index exceeds SocketSet capacity"));
|
|
}
|
|
|
|
return FD_ISSET(s, set);
|
|
}
|
|
|
|
|
|
/// Returns nonzero if this $(D Socket) is in the collection.
|
|
int isSet(Socket s) const
|
|
{
|
|
return isSet(s.sock);
|
|
}
|
|
|
|
|
|
/// Return the capacity of this $(D SocketSet). The exact meaning of the
|
|
/// return value varies from platform to platform.
|
|
@property uint max() const
|
|
{
|
|
version(Windows)
|
|
{
|
|
return fdsetCapacity;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
return fdsetMax;
|
|
}
|
|
}
|
|
|
|
|
|
fd_set* toFd_set()
|
|
{
|
|
return set;
|
|
}
|
|
|
|
|
|
int selectn() const
|
|
{
|
|
version(Windows)
|
|
{
|
|
return count;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
return maxfd + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// The level at which a socket option is defined:
|
|
enum SocketOptionLevel: int
|
|
{
|
|
SOCKET = SOL_SOCKET, /// Socket level
|
|
IP = ProtocolType.IP, /// Internet Protocol version 4 level
|
|
ICMP = ProtocolType.ICMP, /// Internet Control Message Protocol level
|
|
IGMP = ProtocolType.IGMP, /// Internet Group Management Protocol level
|
|
GGP = ProtocolType.GGP, /// Gateway to Gateway Protocol level
|
|
TCP = ProtocolType.TCP, /// Transmission Control Protocol level
|
|
PUP = ProtocolType.PUP, /// PARC Universal Packet Protocol level
|
|
UDP = ProtocolType.UDP, /// User Datagram Protocol level
|
|
IDP = ProtocolType.IDP, /// Xerox NS protocol level
|
|
RAW = ProtocolType.RAW, /// Raw IP packet level
|
|
IPV6 = ProtocolType.IPV6, /// Internet Protocol version 6 level
|
|
}
|
|
|
|
/// _Linger information for use with SocketOption.LINGER.
|
|
struct Linger
|
|
{
|
|
_clinger clinger;
|
|
|
|
version (StdDdoc) // no DDoc for string mixins, can't forward individual fields
|
|
{
|
|
private alias typeof(_clinger.init.l_onoff ) l_onoff_t;
|
|
private alias typeof(_clinger.init.l_linger) l_linger_t;
|
|
l_onoff_t on; /// Nonzero for _on.
|
|
l_linger_t time; /// Linger _time.
|
|
}
|
|
else
|
|
{
|
|
// D interface
|
|
mixin FieldProxy!(`clinger.l_onoff`, `on`);
|
|
mixin FieldProxy!(`clinger.l_linger`, `time`);
|
|
}
|
|
}
|
|
|
|
/// Specifies a socket option:
|
|
enum SocketOption: int
|
|
{
|
|
DEBUG = SO_DEBUG, /// Record debugging information
|
|
BROADCAST = SO_BROADCAST, /// Allow transmission of broadcast messages
|
|
REUSEADDR = SO_REUSEADDR, /// Allow local reuse of address
|
|
LINGER = SO_LINGER, /// Linger on close if unsent data is present
|
|
OOBINLINE = SO_OOBINLINE, /// Receive out-of-band data in band
|
|
SNDBUF = SO_SNDBUF, /// Send buffer size
|
|
RCVBUF = SO_RCVBUF, /// Receive buffer size
|
|
DONTROUTE = SO_DONTROUTE, /// Do not route
|
|
SNDTIMEO = SO_SNDTIMEO, /// Send timeout
|
|
RCVTIMEO = SO_RCVTIMEO, /// Receive timeout
|
|
ERROR = SO_ERROR, /// Retrieve and clear error status
|
|
KEEPALIVE = SO_KEEPALIVE, /// Enable keep-alive packets
|
|
ACCEPTCONN = SO_ACCEPTCONN, /// Listen
|
|
RCVLOWAT = SO_RCVLOWAT, /// Minimum number of input bytes to process
|
|
SNDLOWAT = SO_SNDLOWAT, /// Minimum number of output bytes to process
|
|
TYPE = SO_TYPE, /// Socket type
|
|
|
|
// SocketOptionLevel.TCP:
|
|
TCP_NODELAY = .TCP_NODELAY, /// Disable the Nagle algorithm for send coalescing
|
|
|
|
// SocketOptionLevel.IPV6:
|
|
IPV6_UNICAST_HOPS = .IPV6_UNICAST_HOPS, /// IP unicast hop limit
|
|
IPV6_MULTICAST_IF = .IPV6_MULTICAST_IF, /// IP multicast interface
|
|
IPV6_MULTICAST_LOOP = .IPV6_MULTICAST_LOOP, /// IP multicast loopback
|
|
IPV6_MULTICAST_HOPS = .IPV6_MULTICAST_HOPS, /// IP multicast hops
|
|
IPV6_JOIN_GROUP = .IPV6_JOIN_GROUP, /// Add an IP group membership
|
|
IPV6_LEAVE_GROUP = .IPV6_LEAVE_GROUP, /// Drop an IP group membership
|
|
IPV6_V6ONLY = .IPV6_V6ONLY, /// Treat wildcard bind as AF_INET6-only
|
|
}
|
|
|
|
|
|
/**
|
|
* $(D Socket) is a class that creates a network communication endpoint using
|
|
* the Berkeley sockets interface.
|
|
*/
|
|
class Socket
|
|
{
|
|
private:
|
|
socket_t sock;
|
|
AddressFamily _family;
|
|
|
|
version(Windows)
|
|
bool _blocking = false; /// Property to get or set whether the socket is blocking or nonblocking.
|
|
|
|
// The WinSock timeouts seem to be effectively skewed by a constant
|
|
// offset of about half a second (value in milliseconds). This has
|
|
// been confirmed on updated (as of Jun 2011) Windows XP, Windows 7
|
|
// and Windows Server 2008 R2 boxes. The unittest below tests this
|
|
// behavior.
|
|
enum WINSOCK_TIMEOUT_SKEW = 500;
|
|
|
|
unittest
|
|
{
|
|
version(SlowTests)
|
|
softUnittest({
|
|
import std.datetime;
|
|
|
|
enum msecs = 1000;
|
|
auto pair = socketPair();
|
|
auto sock = pair[0];
|
|
sock.setOption(SocketOptionLevel.SOCKET,
|
|
SocketOption.RCVTIMEO, dur!"msecs"(msecs));
|
|
|
|
auto sw = StopWatch(AutoStart.yes);
|
|
ubyte[1] buf;
|
|
sock.receive(buf);
|
|
sw.stop();
|
|
|
|
Duration readBack = void;
|
|
sock.getOption(SocketOptionLevel.SOCKET, SocketOption.RCVTIMEO, readBack);
|
|
|
|
assert(readBack.total!"msecs" == msecs);
|
|
assert(sw.peek().msecs > msecs-100 && sw.peek().msecs < msecs+100);
|
|
});
|
|
}
|
|
|
|
void setSock(socket_t handle)
|
|
{
|
|
assert(handle != socket_t.init);
|
|
sock = handle;
|
|
|
|
// Set the option to disable SIGPIPE on send() if the platform
|
|
// has it (e.g. on OS X).
|
|
static if (is(typeof(SO_NOSIGPIPE)))
|
|
{
|
|
setOption(SocketOptionLevel.SOCKET, cast(SocketOption)SO_NOSIGPIPE, true);
|
|
}
|
|
}
|
|
|
|
|
|
// For use with accepting().
|
|
protected this()
|
|
{
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
* Create a blocking socket. If a single protocol type exists to support
|
|
* this socket type within the address family, the $(D ProtocolType) may be
|
|
* omitted.
|
|
*/
|
|
this(AddressFamily af, SocketType type, ProtocolType protocol)
|
|
{
|
|
_family = af;
|
|
auto handle = cast(socket_t) socket(af, type, protocol);
|
|
if(handle == socket_t.init)
|
|
throw new SocketOSException("Unable to create socket");
|
|
setSock(handle);
|
|
}
|
|
|
|
|
|
// A single protocol exists to support this socket type within the
|
|
// protocol family, so the ProtocolType is assumed.
|
|
/// ditto
|
|
this(AddressFamily af, SocketType type)
|
|
{
|
|
this(af, type, cast(ProtocolType)0); // Pseudo protocol number.
|
|
}
|
|
|
|
|
|
/// ditto
|
|
this(AddressFamily af, SocketType type, in char[] protocolName)
|
|
{
|
|
protoent* proto;
|
|
proto = getprotobyname(toStringz(protocolName));
|
|
if(!proto)
|
|
throw new SocketOSException("Unable to find the protocol");
|
|
this(af, type, cast(ProtocolType)proto.p_proto);
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a blocking socket using the parameters from the specified
|
|
* $(D AddressInfo) structure.
|
|
*/
|
|
this(in AddressInfo info)
|
|
{
|
|
this(info.family, info.type, info.protocol);
|
|
}
|
|
|
|
/// Use an existing socket handle.
|
|
this(socket_t sock, AddressFamily af)
|
|
{
|
|
assert(sock != socket_t.init);
|
|
this.sock = sock;
|
|
this._family = af;
|
|
}
|
|
|
|
|
|
~this()
|
|
{
|
|
close();
|
|
}
|
|
|
|
|
|
/// Get underlying socket handle.
|
|
@property socket_t handle() const
|
|
{
|
|
return sock;
|
|
}
|
|
|
|
/**
|
|
* Get/set socket's blocking flag.
|
|
*
|
|
* When a socket is blocking, calls to receive(), accept(), and send()
|
|
* will block and wait for data/action.
|
|
* A non-blocking socket will immediately return instead of blocking.
|
|
*/
|
|
@property bool blocking() const
|
|
{
|
|
version(Windows)
|
|
{
|
|
return _blocking;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
return !(fcntl(handle, F_GETFL, 0) & O_NONBLOCK);
|
|
}
|
|
}
|
|
|
|
/// ditto
|
|
@property void blocking(bool byes)
|
|
{
|
|
version(Windows)
|
|
{
|
|
uint num = !byes;
|
|
if(_SOCKET_ERROR == ioctlsocket(sock, FIONBIO, &num))
|
|
goto err;
|
|
_blocking = byes;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
int x = fcntl(sock, F_GETFL, 0);
|
|
if(-1 == x)
|
|
goto err;
|
|
if(byes)
|
|
x &= ~O_NONBLOCK;
|
|
else
|
|
x |= O_NONBLOCK;
|
|
if(-1 == fcntl(sock, F_SETFL, x))
|
|
goto err;
|
|
}
|
|
return; // Success.
|
|
|
|
err:
|
|
throw new SocketOSException("Unable to set socket blocking");
|
|
}
|
|
|
|
|
|
/// Get the socket's address family.
|
|
@property AddressFamily addressFamily()
|
|
{
|
|
return _family;
|
|
}
|
|
|
|
/// Property that indicates if this is a valid, alive socket.
|
|
@property bool isAlive() const
|
|
{
|
|
int type;
|
|
socklen_t typesize = cast(socklen_t) type.sizeof;
|
|
return !getsockopt(sock, SOL_SOCKET, SO_TYPE, cast(char*)&type, &typesize);
|
|
}
|
|
|
|
/// Associate a local address with this socket.
|
|
void bind(Address addr)
|
|
{
|
|
if(_SOCKET_ERROR == .bind(sock, addr.name, addr.nameLen))
|
|
throw new SocketOSException("Unable to bind socket");
|
|
}
|
|
|
|
/**
|
|
* Establish a connection. If the socket is blocking, connect waits for
|
|
* the connection to be made. If the socket is nonblocking, connect
|
|
* returns immediately and the connection attempt is still in progress.
|
|
*/
|
|
void connect(Address to)
|
|
{
|
|
if(_SOCKET_ERROR == .connect(sock, to.name, to.nameLen))
|
|
{
|
|
int err;
|
|
err = _lasterr();
|
|
|
|
if(!blocking)
|
|
{
|
|
version(Windows)
|
|
{
|
|
if(WSAEWOULDBLOCK == err)
|
|
return;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
if(EINPROGRESS == err)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
static assert(0);
|
|
}
|
|
}
|
|
throw new SocketOSException("Unable to connect socket", err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Listen for an incoming connection. $(D bind) must be called before you
|
|
* can $(D listen). The $(D backlog) is a request of how many pending
|
|
* incoming connections are queued until $(D accept)ed.
|
|
*/
|
|
void listen(int backlog)
|
|
{
|
|
if(_SOCKET_ERROR == .listen(sock, backlog))
|
|
throw new SocketOSException("Unable to listen on socket");
|
|
}
|
|
|
|
/**
|
|
* Called by $(D accept) when a new $(D Socket) must be created for a new
|
|
* connection. To use a derived class, override this method and return an
|
|
* instance of your class. The returned $(D Socket)'s handle must not be
|
|
* set; $(D Socket) has a protected constructor $(D this()) to use in this
|
|
* situation.
|
|
*/
|
|
// Override to use a derived class.
|
|
// The returned socket's handle must not be set.
|
|
protected Socket accepting()
|
|
{
|
|
return new Socket;
|
|
}
|
|
|
|
/**
|
|
* Accept an incoming connection. If the socket is blocking, $(D accept)
|
|
* waits for a connection request. Throws $(D SocketAcceptException) if
|
|
* unable to _accept. See $(D accepting) for use with derived classes.
|
|
*/
|
|
Socket accept()
|
|
{
|
|
auto newsock = cast(socket_t).accept(sock, null, null);
|
|
if(socket_t.init == newsock)
|
|
throw new SocketAcceptException("Unable to accept socket connection");
|
|
|
|
Socket newSocket;
|
|
try
|
|
{
|
|
newSocket = accepting();
|
|
assert(newSocket.sock == socket_t.init);
|
|
|
|
newSocket.setSock(newsock);
|
|
version(Windows)
|
|
newSocket._blocking = _blocking; //inherits blocking mode
|
|
newSocket._family = _family; //same family
|
|
}
|
|
catch(Throwable o)
|
|
{
|
|
_close(newsock);
|
|
throw o;
|
|
}
|
|
|
|
return newSocket;
|
|
}
|
|
|
|
/// Disables sends and/or receives.
|
|
void shutdown(SocketShutdown how)
|
|
{
|
|
.shutdown(sock, cast(int)how);
|
|
}
|
|
|
|
|
|
private static void _close(socket_t sock)
|
|
{
|
|
version(Windows)
|
|
{
|
|
.closesocket(sock);
|
|
}
|
|
else version(Posix)
|
|
{
|
|
.close(sock);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Immediately drop any connections and release socket resources.
|
|
* Calling $(D shutdown) before $(D close) is recommended for
|
|
* connection-oriented sockets. The $(D Socket) object is no longer
|
|
* usable after $(D close).
|
|
*/
|
|
//calling shutdown() before this is recommended
|
|
//for connection-oriented sockets
|
|
void close()
|
|
{
|
|
_close(sock);
|
|
sock = socket_t.init;
|
|
}
|
|
|
|
|
|
/// Returns the local machine's host name.
|
|
// Idea from mango.
|
|
static @property string hostName() // getter
|
|
{
|
|
char[256] result; // Host names are limited to 255 chars.
|
|
if(_SOCKET_ERROR == .gethostname(result.ptr, result.length))
|
|
throw new SocketOSException("Unable to obtain host name");
|
|
return to!string(result.ptr);
|
|
}
|
|
|
|
/// Remote endpoint $(D Address).
|
|
@property Address remoteAddress()
|
|
{
|
|
Address addr = createAddress();
|
|
socklen_t nameLen = addr.nameLen;
|
|
if(_SOCKET_ERROR == .getpeername(sock, addr.name, &nameLen))
|
|
throw new SocketOSException("Unable to obtain remote socket address");
|
|
if(nameLen > addr.nameLen)
|
|
throw new SocketParameterException("Not enough socket address storage");
|
|
assert(addr.addressFamily == _family);
|
|
return addr;
|
|
}
|
|
|
|
/// Local endpoint $(D Address).
|
|
@property Address localAddress()
|
|
{
|
|
Address addr = createAddress();
|
|
socklen_t nameLen = addr.nameLen;
|
|
if(_SOCKET_ERROR == .getsockname(sock, addr.name, &nameLen))
|
|
throw new SocketOSException("Unable to obtain local socket address");
|
|
if(nameLen > addr.nameLen)
|
|
throw new SocketParameterException("Not enough socket address storage");
|
|
assert(addr.addressFamily == _family);
|
|
return addr;
|
|
}
|
|
|
|
/**
|
|
* Send or receive error code. See $(D wouldHaveBlocked),
|
|
* $(D lastSocketError) and $(D Socket.getErrorText) for obtaining more
|
|
* information about the error.
|
|
*/
|
|
enum int ERROR = _SOCKET_ERROR;
|
|
|
|
/**
|
|
* Send data on the connection. If the socket is blocking and there is no
|
|
* buffer space left, $(D send) waits.
|
|
* Returns: The number of bytes actually sent, or $(D Socket.ERROR) on
|
|
* failure.
|
|
*/
|
|
//returns number of bytes actually sent, or -1 on error
|
|
ptrdiff_t send(const(void)[] buf, SocketFlags flags)
|
|
{
|
|
static if (is(typeof(MSG_NOSIGNAL)))
|
|
{
|
|
flags = cast(SocketFlags)(flags | MSG_NOSIGNAL);
|
|
}
|
|
version( Windows )
|
|
auto sent = .send(sock, buf.ptr, to!int(buf.length), cast(int)flags);
|
|
else
|
|
auto sent = .send(sock, buf.ptr, buf.length, cast(int)flags);
|
|
return sent;
|
|
}
|
|
|
|
/// ditto
|
|
ptrdiff_t send(const(void)[] buf)
|
|
{
|
|
return send(buf, SocketFlags.NONE);
|
|
}
|
|
|
|
/**
|
|
* Send data to a specific destination Address. If the destination address is
|
|
* not specified, a connection must have been made and that address is used.
|
|
* If the socket is blocking and there is no buffer space left, $(D sendTo) waits.
|
|
* Returns: The number of bytes actually sent, or $(D Socket.ERROR) on
|
|
* failure.
|
|
*/
|
|
ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags, Address to)
|
|
{
|
|
static if (is(typeof(MSG_NOSIGNAL)))
|
|
{
|
|
flags = cast(SocketFlags)(flags | MSG_NOSIGNAL);
|
|
}
|
|
version( Windows )
|
|
return .sendto(
|
|
sock, buf.ptr, std.conv.to!int(buf.length),
|
|
cast(int)flags, to.name, to.nameLen
|
|
);
|
|
else
|
|
return .sendto(sock, buf.ptr, buf.length, cast(int)flags, to.name, to.nameLen);
|
|
}
|
|
|
|
/// ditto
|
|
ptrdiff_t sendTo(const(void)[] buf, Address to)
|
|
{
|
|
return sendTo(buf, SocketFlags.NONE, to);
|
|
}
|
|
|
|
|
|
//assumes you connect()ed
|
|
/// ditto
|
|
ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags)
|
|
{
|
|
static if (is(typeof(MSG_NOSIGNAL)))
|
|
{
|
|
flags = cast(SocketFlags)(flags | MSG_NOSIGNAL);
|
|
}
|
|
version(Windows)
|
|
return .sendto(sock, buf.ptr, to!int(buf.length), cast(int)flags, null, 0);
|
|
else
|
|
return .sendto(sock, buf.ptr, buf.length, cast(int)flags, null, 0);
|
|
}
|
|
|
|
|
|
//assumes you connect()ed
|
|
/// ditto
|
|
ptrdiff_t sendTo(const(void)[] buf)
|
|
{
|
|
return sendTo(buf, SocketFlags.NONE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Receive data on the connection. If the socket is blocking, $(D receive)
|
|
* waits until there is data to be received.
|
|
* Returns: The number of bytes actually received, $(D 0) if the remote side
|
|
* has closed the connection, or $(D Socket.ERROR) on failure.
|
|
*/
|
|
//returns number of bytes actually received, 0 on connection closure, or -1 on error
|
|
ptrdiff_t receive(void[] buf, SocketFlags flags)
|
|
{
|
|
version(Windows) // Does not use size_t
|
|
{
|
|
return buf.length
|
|
? .recv(sock, buf.ptr, to!int(buf.length), cast(int)flags)
|
|
: 0;
|
|
} else {
|
|
return buf.length
|
|
? .recv(sock, buf.ptr, buf.length, cast(int)flags)
|
|
: 0;
|
|
}
|
|
}
|
|
|
|
/// ditto
|
|
ptrdiff_t receive(void[] buf)
|
|
{
|
|
return receive(buf, SocketFlags.NONE);
|
|
}
|
|
|
|
/**
|
|
* Receive data and get the remote endpoint $(D Address).
|
|
* If the socket is blocking, $(D receiveFrom) waits until there is data to
|
|
* be received.
|
|
* Returns: The number of bytes actually received, $(D 0) if the remote side
|
|
* has closed the connection, or $(D Socket.ERROR) on failure.
|
|
*/
|
|
ptrdiff_t receiveFrom(void[] buf, SocketFlags flags, ref Address from)
|
|
{
|
|
if(!buf.length) //return 0 and don't think the connection closed
|
|
return 0;
|
|
if (from is null || from.addressFamily != _family)
|
|
from = createAddress();
|
|
socklen_t nameLen = from.nameLen;
|
|
version(Windows)
|
|
{
|
|
auto read = .recvfrom(sock, buf.ptr, to!int(buf.length), cast(int)flags, from.name, &nameLen);
|
|
assert(from.addressFamily == _family);
|
|
// if(!read) //connection closed
|
|
return read;
|
|
} else {
|
|
auto read = .recvfrom(sock, buf.ptr, buf.length, cast(int)flags, from.name, &nameLen);
|
|
assert(from.addressFamily == _family);
|
|
// if(!read) //connection closed
|
|
return read;
|
|
}
|
|
}
|
|
|
|
|
|
/// ditto
|
|
ptrdiff_t receiveFrom(void[] buf, ref Address from)
|
|
{
|
|
return receiveFrom(buf, SocketFlags.NONE, from);
|
|
}
|
|
|
|
|
|
//assumes you connect()ed
|
|
/// ditto
|
|
ptrdiff_t receiveFrom(void[] buf, SocketFlags flags)
|
|
{
|
|
if(!buf.length) //return 0 and don't think the connection closed
|
|
return 0;
|
|
version(Windows)
|
|
{
|
|
auto read = .recvfrom(sock, buf.ptr, to!int(buf.length), cast(int)flags, null, null);
|
|
// if(!read) //connection closed
|
|
return read;
|
|
} else {
|
|
auto read = .recvfrom(sock, buf.ptr, buf.length, cast(int)flags, null, null);
|
|
// if(!read) //connection closed
|
|
return read;
|
|
}
|
|
}
|
|
|
|
|
|
//assumes you connect()ed
|
|
/// ditto
|
|
ptrdiff_t receiveFrom(void[] buf)
|
|
{
|
|
return receiveFrom(buf, SocketFlags.NONE);
|
|
}
|
|
|
|
|
|
/// Get a socket option.
|
|
/// Returns: The number of bytes written to $(D result).
|
|
//returns the length, in bytes, of the actual result - very different from getsockopt()
|
|
int getOption(SocketOptionLevel level, SocketOption option, void[] result)
|
|
{
|
|
socklen_t len = cast(socklen_t) result.length;
|
|
if(_SOCKET_ERROR == .getsockopt(sock, cast(int)level, cast(int)option, result.ptr, &len))
|
|
throw new SocketOSException("Unable to get socket option");
|
|
return len;
|
|
}
|
|
|
|
|
|
/// Common case of getting integer and boolean options.
|
|
int getOption(SocketOptionLevel level, SocketOption option, out int32_t result)
|
|
{
|
|
return getOption(level, option, (&result)[0 .. 1]);
|
|
}
|
|
|
|
|
|
/// Get the linger option.
|
|
int getOption(SocketOptionLevel level, SocketOption option, out Linger result)
|
|
{
|
|
//return getOption(cast(SocketOptionLevel)SocketOptionLevel.SOCKET, SocketOption.LINGER, (&result)[0 .. 1]);
|
|
return getOption(level, option, (&result.clinger)[0 .. 1]);
|
|
}
|
|
|
|
/// Get a timeout (duration) option.
|
|
void getOption(SocketOptionLevel level, SocketOption option, out Duration result)
|
|
{
|
|
enforce(option == SocketOption.SNDTIMEO || option == SocketOption.RCVTIMEO,
|
|
new SocketParameterException("Not a valid timeout option: " ~ to!string(option)));
|
|
// WinSock returns the timeout values as a milliseconds DWORD,
|
|
// while Linux and BSD return a timeval struct.
|
|
version (Windows)
|
|
{
|
|
int msecs;
|
|
getOption(level, option, (&msecs)[0 .. 1]);
|
|
if (option == SocketOption.RCVTIMEO)
|
|
msecs += WINSOCK_TIMEOUT_SKEW;
|
|
result = dur!"msecs"(msecs);
|
|
}
|
|
else version (Posix)
|
|
{
|
|
TimeVal tv;
|
|
getOption(level, option, (&tv.ctimeval)[0..1]);
|
|
result = dur!"seconds"(tv.seconds) + dur!"usecs"(tv.microseconds);
|
|
}
|
|
else static assert(false);
|
|
}
|
|
|
|
// Set a socket option.
|
|
void setOption(SocketOptionLevel level, SocketOption option, void[] value)
|
|
{
|
|
if(_SOCKET_ERROR == .setsockopt(sock, cast(int)level,
|
|
cast(int)option, value.ptr, cast(uint) value.length))
|
|
throw new SocketOSException("Unable to set socket option");
|
|
}
|
|
|
|
|
|
/// Common case for setting integer and boolean options.
|
|
void setOption(SocketOptionLevel level, SocketOption option, int32_t value)
|
|
{
|
|
setOption(level, option, (&value)[0 .. 1]);
|
|
}
|
|
|
|
|
|
/// Set the linger option.
|
|
void setOption(SocketOptionLevel level, SocketOption option, Linger value)
|
|
{
|
|
//setOption(cast(SocketOptionLevel)SocketOptionLevel.SOCKET, SocketOption.LINGER, (&value)[0 .. 1]);
|
|
setOption(level, option, (&value.clinger)[0 .. 1]);
|
|
}
|
|
|
|
/**
|
|
* Sets a timeout (duration) option, i.e. $(D SocketOption.SNDTIMEO) or
|
|
* $(D RCVTIMEO). Zero indicates no timeout.
|
|
*
|
|
* In a typical application, you might also want to consider using
|
|
* a non-blocking socket instead of setting a timeout on a blocking one.
|
|
*
|
|
* Note: While the receive timeout setting is generally quite accurate
|
|
* on *nix systems even for smaller durations, there are two issues to
|
|
* be aware of on Windows: First, although undocumented, the effective
|
|
* timeout duration seems to be the one set on the socket plus half
|
|
* a second. $(D setOption()) tries to compensate for that, but still,
|
|
* timeouts under 500ms are not possible on Windows. Second, be aware
|
|
* that the actual amount of time spent until a blocking call returns
|
|
* randomly varies on the order of 10ms.
|
|
*
|
|
* Params:
|
|
* level = The level at which a socket option is defined.
|
|
* option = Either $(D SocketOption.SNDTIMEO) or $(D SocketOption.RCVTIMEO).
|
|
* value = The timeout duration to set. Must not be negative.
|
|
*
|
|
* Throws: $(D SocketException) if setting the options fails.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* import std.datetime;
|
|
* auto pair = socketPair();
|
|
* scope(exit) foreach (s; pair) s.close();
|
|
*
|
|
* // Set a receive timeout, and then wait at one end of
|
|
* // the socket pair, knowing that no data will arrive.
|
|
* pair[0].setOption(SocketOptionLevel.SOCKET,
|
|
* SocketOption.RCVTIMEO, dur!"seconds"(1));
|
|
*
|
|
* auto sw = StopWatch(AutoStart.yes);
|
|
* ubyte[1] buffer;
|
|
* pair[0].receive(buffer);
|
|
* writefln("Waited %s ms until the socket timed out.",
|
|
* sw.peek.msecs);
|
|
* ---
|
|
*/
|
|
void setOption(SocketOptionLevel level, SocketOption option, Duration value)
|
|
{
|
|
enforce(option == SocketOption.SNDTIMEO || option == SocketOption.RCVTIMEO,
|
|
new SocketParameterException("Not a valid timeout option: " ~ to!string(option)));
|
|
|
|
enforce(value >= dur!"hnsecs"(0), new SocketParameterException(
|
|
"Timeout duration must not be negative."));
|
|
|
|
version (Windows)
|
|
{
|
|
auto msecs = to!int(value.total!"msecs");
|
|
if (msecs != 0 && option == SocketOption.RCVTIMEO)
|
|
msecs = max(1, msecs - WINSOCK_TIMEOUT_SKEW);
|
|
setOption(level, option, msecs);
|
|
}
|
|
else version (Posix)
|
|
{
|
|
_ctimeval tv;
|
|
tv.tv_sec = to!(typeof(tv.tv_sec ))(value.total!"seconds");
|
|
tv.tv_usec = to!(typeof(tv.tv_usec))(value.fracSec.usecs);
|
|
setOption(level, option, (&tv)[0 .. 1]);
|
|
}
|
|
else static assert(false);
|
|
}
|
|
|
|
/// Get a text description of this socket's error status, and clear the
|
|
/// socket's error status.
|
|
string getErrorText()
|
|
{
|
|
int32_t error;
|
|
getOption(SocketOptionLevel.SOCKET, SocketOption.ERROR, error);
|
|
return formatSocketError(error);
|
|
}
|
|
|
|
/**
|
|
* Enables TCP keep-alive with the specified parameters.
|
|
*
|
|
* Params:
|
|
* time = Number of seconds with no activity until the first
|
|
* keep-alive packet is sent.
|
|
* interval = Number of seconds between when successive keep-alive
|
|
* packets are sent if no acknowledgement is received.
|
|
*
|
|
* Throws: $(D SocketOSException) if setting the options fails, or
|
|
* $(D SocketFeatureException) if setting keep-alive parameters is
|
|
* unsupported on the current platform.
|
|
*/
|
|
void setKeepAlive(int time, int interval)
|
|
{
|
|
version(Windows)
|
|
{
|
|
tcp_keepalive options;
|
|
options.onoff = 1;
|
|
options.keepalivetime = time * 1000;
|
|
options.keepaliveinterval = interval * 1000;
|
|
uint cbBytesReturned;
|
|
enforce(WSAIoctl(sock, SIO_KEEPALIVE_VALS,
|
|
&options, options.sizeof,
|
|
null, 0,
|
|
&cbBytesReturned, null, null) == 0,
|
|
new SocketOSException("Error setting keep-alive"));
|
|
}
|
|
else
|
|
static if (is(typeof(TCP_KEEPIDLE)) && is(typeof(TCP_KEEPINTVL)))
|
|
{
|
|
setOption(SocketOptionLevel.TCP, cast(SocketOption)TCP_KEEPIDLE, time);
|
|
setOption(SocketOptionLevel.TCP, cast(SocketOption)TCP_KEEPINTVL, interval);
|
|
setOption(SocketOptionLevel.SOCKET, SocketOption.KEEPALIVE, true);
|
|
}
|
|
else
|
|
throw new SocketFeatureException("Setting keep-alive options " ~
|
|
"is not supported on this platform");
|
|
}
|
|
|
|
/**
|
|
* Wait for a socket to change status. A wait timeout of $(Duration) or
|
|
* $(D TimeVal), may be specified; if a timeout is not specified or the
|
|
* $(D TimeVal) is $(D null), the maximum timeout is used. The $(D TimeVal)
|
|
* timeout has an unspecified value when $(D select) returns.
|
|
* Returns: The number of sockets with status changes, $(D 0) on timeout,
|
|
* or $(D -1) on interruption. If the return value is greater than $(D 0),
|
|
* the $(D SocketSets) are updated to only contain the sockets having status
|
|
* changes. For a connecting socket, a write status change means the
|
|
* connection is established and it's able to send. For a listening socket,
|
|
* a read status change means there is an incoming connection request and
|
|
* it's able to accept.
|
|
*/
|
|
//SocketSet's updated to include only those sockets which an event occured
|
|
//returns the number of events, 0 on timeout, or -1 on interruption
|
|
//for a connect()ing socket, writeability means connected
|
|
//for a listen()ing socket, readability means listening
|
|
//Winsock: possibly internally limited to 64 sockets per set
|
|
static int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError, Duration timeout)
|
|
{
|
|
TimeVal tv;
|
|
tv.seconds = to!(tv.tv_sec_t )(timeout.total!"seconds");
|
|
tv.microseconds = to!(tv.tv_usec_t)(timeout.fracSec.usecs);
|
|
return select(checkRead, checkWrite, checkError, &tv);
|
|
}
|
|
|
|
/// ditto
|
|
//maximum timeout
|
|
static int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError)
|
|
{
|
|
return select(checkRead, checkWrite, checkError, null);
|
|
}
|
|
|
|
/// Ditto
|
|
static int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError, TimeVal* timeout)
|
|
in
|
|
{
|
|
//make sure none of the SocketSet's are the same object
|
|
if(checkRead)
|
|
{
|
|
assert(checkRead !is checkWrite);
|
|
assert(checkRead !is checkError);
|
|
}
|
|
if(checkWrite)
|
|
{
|
|
assert(checkWrite !is checkError);
|
|
}
|
|
}
|
|
body
|
|
{
|
|
fd_set* fr, fw, fe;
|
|
int n = 0;
|
|
|
|
version(Windows)
|
|
{
|
|
// Windows has a problem with empty fd_set`s that aren't null.
|
|
fr = checkRead && checkRead.count ? checkRead.toFd_set() : null;
|
|
fw = checkWrite && checkWrite.count ? checkWrite.toFd_set() : null;
|
|
fe = checkError && checkError.count ? checkError.toFd_set() : null;
|
|
}
|
|
else
|
|
{
|
|
if(checkRead)
|
|
{
|
|
fr = checkRead.toFd_set();
|
|
n = checkRead.selectn();
|
|
}
|
|
else
|
|
{
|
|
fr = null;
|
|
}
|
|
|
|
if(checkWrite)
|
|
{
|
|
fw = checkWrite.toFd_set();
|
|
int _n;
|
|
_n = checkWrite.selectn();
|
|
if(_n > n)
|
|
n = _n;
|
|
}
|
|
else
|
|
{
|
|
fw = null;
|
|
}
|
|
|
|
if(checkError)
|
|
{
|
|
fe = checkError.toFd_set();
|
|
int _n;
|
|
_n = checkError.selectn();
|
|
if(_n > n)
|
|
n = _n;
|
|
}
|
|
else
|
|
{
|
|
fe = null;
|
|
}
|
|
}
|
|
|
|
int result = .select(n, fr, fw, fe, &timeout.ctimeval);
|
|
|
|
version(Windows)
|
|
{
|
|
if(_SOCKET_ERROR == result && WSAGetLastError() == WSAEINTR)
|
|
return -1;
|
|
}
|
|
else version(Posix)
|
|
{
|
|
if(_SOCKET_ERROR == result && errno == EINTR)
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
static assert(0);
|
|
}
|
|
|
|
if(_SOCKET_ERROR == result)
|
|
throw new SocketOSException("Socket select error");
|
|
|
|
return result;
|
|
}
|
|
|
|
// Explicitly undocumented. It will be removed in December 2014.
|
|
deprecated("Please use the overload of select which takes a Duration instead.")
|
|
static int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError, long microseconds)
|
|
{
|
|
TimeVal tv;
|
|
tv.seconds = to!(tv.tv_sec_t )(microseconds / 1_000_000);
|
|
tv.microseconds = to!(tv.tv_usec_t)(microseconds % 1_000_000);
|
|
return select(checkRead, checkWrite, checkError, &tv);
|
|
}
|
|
|
|
|
|
/// Returns a new Address object for the current address family.
|
|
/// Can be overridden to support other addresses.
|
|
protected Address createAddress()
|
|
{
|
|
Address result;
|
|
switch(_family)
|
|
{
|
|
case AddressFamily.INET:
|
|
result = new InternetAddress;
|
|
break;
|
|
|
|
case AddressFamily.INET6:
|
|
result = new Internet6Address;
|
|
break;
|
|
|
|
default:
|
|
result = new UnknownAddress;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// $(D TcpSocket) is a shortcut class for a TCP Socket.
|
|
class TcpSocket: Socket
|
|
{
|
|
/// Constructs a blocking TCP Socket.
|
|
this(AddressFamily family)
|
|
{
|
|
super(family, SocketType.STREAM, ProtocolType.TCP);
|
|
}
|
|
|
|
/// Constructs a blocking IPv4 TCP Socket.
|
|
this()
|
|
{
|
|
this(AddressFamily.INET);
|
|
}
|
|
|
|
|
|
//shortcut
|
|
/// Constructs a blocking TCP Socket and connects to an $(D Address).
|
|
this(Address connectTo)
|
|
{
|
|
this(connectTo.addressFamily);
|
|
connect(connectTo);
|
|
}
|
|
}
|
|
|
|
|
|
/// $(D UdpSocket) is a shortcut class for a UDP Socket.
|
|
class UdpSocket: Socket
|
|
{
|
|
/// Constructs a blocking UDP Socket.
|
|
this(AddressFamily family)
|
|
{
|
|
super(family, SocketType.DGRAM, ProtocolType.UDP);
|
|
}
|
|
|
|
|
|
/// Constructs a blocking IPv4 UDP Socket.
|
|
this()
|
|
{
|
|
this(AddressFamily.INET);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a pair of connected sockets.
|
|
*
|
|
* The two sockets are indistinguishable.
|
|
*
|
|
* Throws: $(D SocketException) if creation of the sockets fails.
|
|
*
|
|
* Example:
|
|
* ---
|
|
* immutable ubyte[] data = [1, 2, 3, 4];
|
|
* auto pair = socketPair();
|
|
* scope(exit) foreach (s; pair) s.close();
|
|
*
|
|
* pair[0].send(data);
|
|
*
|
|
* auto buf = new ubyte[data.length];
|
|
* pair[1].receive(buf);
|
|
* assert(buf == data);
|
|
* ---
|
|
*/
|
|
Socket[2] socketPair()
|
|
{
|
|
version(Posix)
|
|
{
|
|
int[2] socks;
|
|
if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1)
|
|
throw new SocketOSException("Unable to create socket pair");
|
|
|
|
Socket toSocket(size_t id)
|
|
{
|
|
auto s = new Socket;
|
|
s.setSock(cast(socket_t)socks[id]);
|
|
s._family = AddressFamily.UNIX;
|
|
return s;
|
|
}
|
|
|
|
return [toSocket(0), toSocket(1)];
|
|
}
|
|
else version(Windows)
|
|
{
|
|
// We do not have socketpair() on Windows, just manually create a
|
|
// pair of sockets connected over some localhost port.
|
|
Socket[2] result;
|
|
|
|
auto listener = new TcpSocket();
|
|
listener.setOption(SocketOptionLevel.SOCKET, SocketOption.REUSEADDR, true);
|
|
listener.bind(new InternetAddress(INADDR_LOOPBACK, InternetAddress.PORT_ANY));
|
|
auto addr = listener.localAddress;
|
|
listener.listen(1);
|
|
|
|
result[0] = new TcpSocket(addr);
|
|
result[1] = listener.accept();
|
|
|
|
listener.close();
|
|
return result;
|
|
}
|
|
else
|
|
static assert(false);
|
|
}
|
|
|
|
unittest
|
|
{
|
|
immutable ubyte[] data = [1, 2, 3, 4];
|
|
auto pair = socketPair();
|
|
scope(exit) foreach (s; pair) s.close();
|
|
|
|
pair[0].send(data);
|
|
|
|
auto buf = new ubyte[data.length];
|
|
pair[1].receive(buf);
|
|
assert(buf == data);
|
|
}
|