std.socket - D Programming Language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Feature Overview
  - DMD Manual
  - Articles
- Packages
- Community
  - Bug Tracker
  - Forums
  - IRC
  - D on GitHub
  - Wiki
  - Review Queue
  - Twitter
  - More Links
- Resources
  - NEW Library Reference Preview
  - D-Specific Tools
  - Visual D
  - Editors
  - IDEs
  - Tutorials
  - Books
  - The D Style
  - Glossary
  - Acknowledgments
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.socket

Socket primitives.

Example: See /dmd/samples/d/listener.d and /dmd/samples/d/htmlget.d

License:
Boost License 1.0.
Authors:
Christopher E. Miller, David Nadlinger, Vladimir Panteleev

Source: std/socket.d

$(DDOC_MODULE_MEMBERS
class SocketException: object.Exception;
  Base exception thrown by std.socket.
@property @safe string lastSocketError();
  Retrieve the error message for the most recently encountered network error.
class SocketOSException: std.socket.SocketException;
  Socket exceptions representing network errors reported by the operating
  system.
  int errorCode;
    Platform-specific error code.
  @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null, int err = _lasterr(), string function(int) @trusted errorFormatter = &formatSocketError);

  @safe this(string msg, Throwable next, string file = __FILE__, size_t line = __LINE__, int err = _lasterr(), string function(int) @trusted errorFormatter = &formatSocketError);

  @safe this(string msg, int err, string function(int) @trusted errorFormatter = &formatSocketError, string file = __FILE__, size_t line = __LINE__, Throwable next = null);

class SocketParameterException: std.socket.SocketException;
  Socket exceptions representing invalid parameters specified by user code.
class SocketFeatureException: std.socket.SocketException;
  Socket exceptions representing attempts to use network capabilities not
  available on the current system.
nothrow @nogc @safe bool wouldHaveBlocked();
  Return true if the last socket operation failed because the socket
  was in non-blocking mode and the operation would have blocked.
enum AddressFamily: int;
  The communication domain used to resolve an address.
  UNSPEC
    Unspecified address family
  UNIX
    Local communication
  INET
    Internet Protocol version 4
  IPX
    Novell IPX
  APPLETALK
    AppleTalk
  INET6
    Internet Protocol version 6
enum SocketType: int;
  Communication semantics
  STREAM
    Sequenced, reliable, two-way communication-based byte streams
  DGRAM
    Connectionless, unreliable datagrams with a fixed maximum length; data may be lost or arrive out of order
  RAW
    Raw protocol access
  RDM
    Reliably-delivered message datagrams
  SEQPACKET
    Sequenced, reliable, two-way connection-based datagrams with a fixed maximum length
enum ProtocolType: int;
  Protocol
  IP
    Internet Protocol version 4
  ICMP
    Internet Control Message Protocol
  IGMP
    Internet Group Management Protocol
  GGP
    Gateway to Gateway Protocol
  TCP
    Transmission Control Protocol
  PUP
    PARC Universal Packet Protocol
  UDP
    User Datagram Protocol
  IDP
    Xerox NS protocol
  RAW
    Raw IP packets
  IPV6
    Internet Protocol version 6
class Protocol;
  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");

  ProtocolType type;
  string name;
  string[] aliases;
    These members are populated when one of the following functions are called successfully:
  nothrow @trusted bool getProtocolByName(in char[] name);
    Returns:
    false on failure
  nothrow @trusted bool getProtocolByType(ProtocolType type);
    Returns:
    false on failure
class Service;
  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.");

  string name;
  string[] aliases;
  ushort port;
  string protocolName;
    These members are populated when one of the following functions are called successfully:
  nothrow @trusted bool getServiceByName(in char[] name, in char[] protocolName = null);
  nothrow @trusted bool getServiceByPort(ushort port, in char[] protocolName = null);
    If a protocol name is omitted, any protocol will be matched.
    Returns:
    false on failure.
class HostException: std.socket.SocketOSException;
  Class for exceptions thrown from an InternetHost.
class InternetHost;
  InternetHost is a class for resolving IPv4 addresses.
  Consider using getAddress, parseAddress and 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");
      )

  string name;
  string[] aliases;
  uint[] addrList;
    These members are populated when one of the following functions are called successfully:
  @trusted bool getHostByName(in char[] name);
    Resolve host name.
    Returns:
    false if unable to resolve.
  @trusted bool getHostByAddr(uint addr);
    Resolve IPv4 address number.
    Parameters:

    uint addr | The IPv4 address to resolve, in host byte order.

    Returns:
    false if unable to resolve.
  @trusted bool getHostByAddr(in char[] addr);
    Same as previous, but addr is an IPv4 address string in the dotted-decimal form a.b.c.d.
    Returns:
    false if unable to resolve.
struct AddressInfo;
  Holds information about a socket address retrieved by getAddressInfo.
  AddressFamily family;
    Address family
  SocketType type;
    Socket type
  ProtocolType protocol;
    Protocol
  Address address;
    Socket address
  string canonicalName;
    Canonical name, when AddressInfoFlags.CANONNAME is used.
enum AddressInfoFlags: int;
  Specifies option flags for getAddressInfo.
  PASSIVE
    The resulting addresses will be used in a call to Socket.bind.
  CANONNAME
    The canonical name is returned in canonicalName member in the first AddressInfo.
  NUMERICHOST
    The node parameter passed to getAddressInfo must be a numeric string.
    This will suppress any potentially lengthy network host address lookups.
@trusted AddressInfo[] getAddressInfo(T...)(in char[] node, T options);
  Provides protocol-independent translation from host names to socket addresses. If advanced functionality is not required, consider using getAddress for compatibility with older systems.
  Returns:
  Array with one AddressInfo per socket address.
  Throws:
  SocketOSException on failure, or SocketFeatureException if this functionality is not available on the current system.
  Parameters:

  char[] node | string containing host name or numeric address

  T options

  optional additional parameters, identified by type:
  - string - service name or port number
  - AddressInfoFlags - option flags
  - AddressFamily - address family to filter by
  - SocketType - socket type to filter by
  - 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);

@safe Address[] getAddress(in char[] hostname, in char[] service = null);
@safe Address[] getAddress(in char[] hostname, ushort port);
  Provides protocol-independent translation from host names to socket addresses. Uses getAddressInfo if the current system supports it, and InternetHost otherwise.
  Returns:
  Array with one Address instance per socket address.
  Throws:
  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);

@safe Address parseAddress(in char[] hostaddr, in char[] service = null);
@safe Address parseAddress(in char[] hostaddr, ushort port);
  Provides protocol-independent parsing of network addresses. Does not attempt name resolution. Uses getAddressInfo with AddressInfoFlags.NUMERICHOST if the current system supports it, and InternetAddress otherwise.
  Returns:
  An Address instance representing specified address.
  Throws:
  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);
      }

class AddressException: std.socket.SocketOSException;
  Class for exceptions thrown from an Address.
abstract class Address;
  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 pure nothrow @nogc @property @safe sockaddr* name();
  abstract const pure nothrow @nogc @property @safe const(sockaddr)* name();
    Returns pointer to underlying sockaddr structure.
  abstract const pure nothrow @nogc @property @safe socklen_t nameLen();
    Returns actual size of underlying sockaddr structure.
  const pure nothrow @nogc @property @safe AddressFamily addressFamily();
    Family of this address.
  const @safe string toAddrString();
    Attempts to retrieve the host address as a human-readable string.
    Throws:
    AddressException on failure, or SocketFeatureException if address retrieval for this address family is not available on the current system.
  const @safe string toHostNameString();
    Attempts to retrieve the host name as a fully qualified domain name.
    Returns:
    The FQDN corresponding to this Address, or null if the host name did not resolve.
    Throws:
    AddressException on error, or SocketFeatureException if host name lookup for this address family is not available on the current system.
  const @safe string toPortString();
    Attempts to retrieve the numeric port number as a string.
    Throws:
    AddressException on failure, or SocketFeatureException if port number retrieval for this address family is not available on the current system.
  const @safe string toServiceNameString();
    Attempts to retrieve the service name as a string.
    Throws:
    AddressException on failure, or SocketFeatureException if service name lookup for this address family is not available on the current system.
  const @safe string toString();
    Human readable string representing this address.
class UnknownAddress: std.socket.Address;
  UnknownAddress encapsulates an unknown socket address.
class UnknownAddressReference: std.socket.Address;
  UnknownAddressReference encapsulates a reference to an arbitrary socket address.
  pure nothrow @nogc @safe this(sockaddr* sa, socklen_t len);
    Constructs an Address with a reference to the specified sockaddr.
  pure nothrow @system this(const(sockaddr)* sa, socklen_t len);
    Constructs an Address with a copy of the specified sockaddr.
class InternetAddress: std.socket.Address;
  InternetAddress encapsulates an IPv4 (Internet Protocol version 4) socket address.
  Consider using getAddress, parseAddress and Address methods instead of using this class directly.
  enum uint ADDR_ANY;
    Any IPv4 host address.
  enum uint ADDR_NONE;
    An invalid IPv4 host address.
  enum ushort PORT_ANY;
    Any IPv4 port number.
  const pure nothrow @nogc @property @safe ushort port();
    Returns the IPv4 port number (in host byte order).
  const pure nothrow @nogc @property @safe uint addr();
    Returns the IPv4 address number (in host byte order).
  @safe this(in char[] addr, ushort port);
    Construct a new InternetAddress.
    Parameters:

    char[] addr | an IPv4 address string in the dotted-decimal form a.b.c.d, or a host name which will be resolved using an InternetHost object.
    ushort port | port number, may be PORT_ANY.

  pure nothrow @nogc @safe this(uint addr, ushort port);
  pure nothrow @nogc @safe this(ushort port);
    Construct a new InternetAddress.
    Parameters:

    uint addr | (optional) an IPv4 address in host byte order, may be ADDR_ANY.
    ushort port | port number, may be PORT_ANY.

  pure nothrow @nogc @safe this(sockaddr_in addr);
    Construct a new InternetAddress.
    Parameters:

    sockaddr_in addr | A sockaddr_in as obtained from lower-level API calls such as getifaddrs.

  const @trusted string toAddrString();
    Human readable string representing the IPv4 address in dotted-decimal form.
  const @safe string toPortString();
    Human readable string representing the IPv4 port.
  const @safe string toHostNameString();
    Attempts to retrieve the host name as a fully qualified domain name.
    Returns:
    The FQDN corresponding to this InternetAddress, or null if the host name did not resolve.
    Throws:
    AddressException on error.
  const @safe bool opEquals(Object o);
    Compares with another InternetAddress of same type for equality
    Returns:
    true if the InternetAddresses share the same address and port number.
    Examples:

        auto addr1 = new InternetAddress("127.0.0.1", 80);
        auto addr2 = new InternetAddress("127.0.0.2", 80);

        assert(addr1 == addr1);
        assert(addr1 != addr2);

  static nothrow @trusted uint parse(in char[] addr);
    Parse an IPv4 address string in the dotted-decimal form a.b.c.d and return the number.
    Returns:
    If the string is not a legitimate IPv4 address, ADDR_NONE is returned.
  static nothrow @trusted string addrToString(uint addr);
    Convert an IPv4 address number in host byte order to a human readable string representing the IPv4 address in dotted-decimal form.
class Internet6Address: std.socket.Address;
  Internet6Address encapsulates an IPv6 (Internet Protocol version 6) socket address.
  Consider using getAddress, parseAddress and Address methods instead of using this class directly.
  static pure nothrow @nogc @property ref @safe const(ubyte)[16] ADDR_ANY();
    Any IPv6 host address.
  enum ushort PORT_ANY;
    Any IPv6 port number.
  const pure nothrow @nogc @property @safe ushort port();
    Returns the IPv6 port number.
  const pure nothrow @nogc @property @safe ubyte[16] addr();
    Returns the IPv6 address.
  @trusted this(in char[] addr, in char[] service = null);
    Construct a new Internet6Address.
    Parameters:

    char[] addr | an IPv6 host address string in the form described in RFC 2373, or a host name which will be resolved using getAddressInfo.
    char[] service | (optional) service name.

  @safe this(in char[] addr, ushort port);
    Construct a new Internet6Address.
    Parameters:

    char[] addr | an IPv6 host address string in the form described in RFC 2373, or a host name which will be resolved using getAddressInfo.
    ushort port | port number, may be PORT_ANY.

  pure nothrow @nogc @safe this(ubyte[16] addr, ushort port);
  pure nothrow @nogc @safe this(ushort port);
    Construct a new Internet6Address.
    Parameters:

    ubyte[16] addr | (optional) an IPv6 host address in host byte order, or ADDR_ANY.
    ushort port | port number, may be PORT_ANY.

  pure nothrow @nogc @safe this(sockaddr_in6 addr);
    Construct a new Internet6Address.
    Parameters:

    sockaddr_in6 addr | A sockaddr_in6 as obtained from lower-level API calls such as getifaddrs.

  static @trusted ubyte[16] parse(in char[] addr);
    Parse an IPv6 host address string as described in RFC 2373, and return the address.
    Throws:
    SocketException on error.
class UnixAddress: std.socket.Address;
  UnixAddress encapsulates an address for a Unix domain socket (AF_UNIX). Available only on supported systems.
  @safe this(in char[] path);
    Construct a new UnixAddress from the specified path.
  pure nothrow @nogc @safe this(sockaddr_un addr);
    Construct a new UnixAddress.
    Parameters:

    sockaddr_un addr | A sockaddr_un as obtained from lower-level API calls.

  const @property @safe string path();
  const @safe string toString();
    Get the underlying path.
class SocketAcceptException: std.socket.SocketOSException;
  Class for exceptions thrown by Socket.accept.
enum SocketShutdown: int;
  How a socket is shutdown:
  RECEIVE
    socket receives are disallowed
  SEND
    socket sends are disallowed
  BOTH
    both RECEIVE and SEND
enum SocketFlags: int;
  Flags may be OR'ed together:
  NONE
    no flags specified
  OOB
    out-of-band stream data
  PEEK
    peek at incoming data without removing it from the queue, only for receiving
  DONTROUTE
    data should not be subject to routing; this flag may be ignored. Only for sending
struct TimeVal;
  Duration timeout value.
  tv_sec_t seconds;
    Number of seconds.
  tv_usec_t microseconds;
    Number of additional microseconds.
class SocketSet;
  A collection of sockets for use with Socket.select.
  SocketSet wraps the platform fd_set type. However, unlike fd_set, SocketSet is not statically limited to FD_SETSIZE or any other limit, and grows as needed.
  pure nothrow @safe this(size_t size = FD_SETSIZE);
    Create a SocketSet with a specific initial capacity (defaults to FD_SETSIZE, the system's default capacity).
  pure nothrow @nogc @safe void reset();
    Reset the SocketSet so that there are 0 Sockets in the collection.
  pure nothrow @safe void add(Socket s);
    Add a Socket to the collection.
    The socket must not already be in the collection.
  pure nothrow @safe void remove(Socket s);
    Remove this Socket from the collection.
    Does nothing if the socket is not in the collection already.
  const pure nothrow @nogc @safe int isSet(Socket s);
    Return nonzero if this Socket is in the collection.
  const pure nothrow @nogc @property @safe uint max();
    Return the current capacity of this SocketSet. The exact
    meaning of the return value varies from platform to platform.

    Note that since D 2.065, this value does not indicate a

    restriction, and SocketSet will grow its capacity as

    needed automatically.
enum SocketOptionLevel: int;
  The level at which a socket option is defined:
  SOCKET
    Socket level
  IP
    Internet Protocol version 4 level
  ICMP
    Internet Control Message Protocol level
  IGMP
    Internet Group Management Protocol level
  GGP
    Gateway to Gateway Protocol level
  TCP
    Transmission Control Protocol level
  PUP
    PARC Universal Packet Protocol level
  UDP
    User Datagram Protocol level
  IDP
    Xerox NS protocol level
  RAW
    Raw IP packet level
  IPV6
    Internet Protocol version 6 level
struct Linger;
  Linger information for use with SocketOption.LINGER.
  l_onoff_t on;
    Nonzero for on.
  l_linger_t time;
    Linger time.
enum SocketOption: int;
  Specifies a socket option:
  DEBUG
    Record debugging information
  BROADCAST
    Allow transmission of broadcast messages
  REUSEADDR
    Allow local reuse of address
  LINGER
    Linger on close if unsent data is present
  OOBINLINE
    Receive out-of-band data in band
  SNDBUF
    Send buffer size
  RCVBUF
    Receive buffer size
  DONTROUTE
    Do not route
  SNDTIMEO
    Send timeout
  RCVTIMEO
    Receive timeout
  ERROR
    Retrieve and clear error status
  KEEPALIVE
    Enable keep-alive packets
  ACCEPTCONN
    Listen
  RCVLOWAT
    Minimum number of input bytes to process
  SNDLOWAT
    Minimum number of output bytes to process
  TYPE
    Socket type
  TCP_NODELAY
    Disable the Nagle algorithm for send coalescing
  IPV6_UNICAST_HOPS
    IP unicast hop limit
  IPV6_MULTICAST_IF
    IP multicast interface
  IPV6_MULTICAST_LOOP
    IP multicast loopback
  IPV6_MULTICAST_HOPS
    IP multicast hops
  IPV6_JOIN_GROUP
    Add an IP group membership
  IPV6_LEAVE_GROUP
    Drop an IP group membership
  IPV6_V6ONLY
    Treat wildcard bind as AF_INET6-only
class Socket;
  Socket is a class that creates a network communication endpoint using the Berkeley sockets interface.
  @trusted this(AddressFamily af, SocketType type, ProtocolType protocol);
  @safe this(AddressFamily af, SocketType type);
  @trusted this(AddressFamily af, SocketType type, in char[] protocolName);
    Create a blocking socket. If a single protocol type exists to support this socket type within the address family, the ProtocolType may be omitted.
  @safe this(in AddressInfo info);
    Create a blocking socket using the parameters from the specified AddressInfo structure.
  pure nothrow @nogc @safe this(socket_t sock, AddressFamily af);
    Use an existing socket handle.
  const pure nothrow @nogc @property @safe socket_t handle();
    Get underlying socket handle.
  const nothrow @nogc @property @trusted bool blocking();
  @property @trusted void blocking(bool byes);
    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 @safe AddressFamily addressFamily();
    Get the socket's address family.
  const @property @trusted bool isAlive();
    Property that indicates if this is a valid, alive socket.
  @trusted void bind(Address addr);
    Associate a local address with this socket.
  @trusted void connect(Address to);
    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.
  @trusted void listen(int backlog);
    Listen for an incoming connection. bind must be called before you can listen. The backlog is a request of how many pending incoming connections are queued until accepted.
  protected pure nothrow @safe Socket accepting();
    Called by accept when a new 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 Socket's handle must not be set; Socket has a protected constructor this() to use in this situation.
  @trusted Socket accept();
    Accept an incoming connection. If the socket is blocking, accept waits for a connection request. Throws SocketAcceptException if unable to accept. See accepting for use with derived classes.
  nothrow @nogc @trusted void shutdown(SocketShutdown how);
    Disables sends and/or receives.
  nothrow @nogc @trusted void close();
    Immediately drop any connections and release socket resources. Calling shutdown before close is recommended for connection-oriented sockets. The Socket object is no longer usable after close.
  static @property @trusted string hostName();
    Returns the local machine's host name.
  @property @trusted Address remoteAddress();
    Remote endpoint Address.
  @property @trusted Address localAddress();
    Local endpoint Address.
  enum int ERROR;
    Send or receive error code. See wouldHaveBlocked, lastSocketError and Socket.getErrorText for obtaining more information about the error.
  @trusted ptrdiff_t send(const(void)[] buf, SocketFlags flags);
  @safe ptrdiff_t send(const(void)[] buf);
    Send data on the connection. If the socket is blocking and there is no buffer space left, send waits.
    Returns:
    The number of bytes actually sent, or Socket.ERROR on failure.
  @trusted ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags, Address to);
  @safe ptrdiff_t sendTo(const(void)[] buf, Address to);
  @trusted ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags);
  @safe ptrdiff_t sendTo(const(void)[] buf);
    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, sendTo waits.
    Returns:
    The number of bytes actually sent, or Socket.ERROR on failure.
  @trusted ptrdiff_t receive(void[] buf, SocketFlags flags);
  @safe ptrdiff_t receive(void[] buf);
    Receive data on the connection. If the socket is blocking, receive waits until there is data to be received.
    Returns:
    The number of bytes actually received, 0 if the remote side has closed the connection, or Socket.ERROR on failure.
  @trusted ptrdiff_t receiveFrom(void[] buf, SocketFlags flags, ref Address from);
  @safe ptrdiff_t receiveFrom(void[] buf, ref Address from);
  @trusted ptrdiff_t receiveFrom(void[] buf, SocketFlags flags);
  @safe ptrdiff_t receiveFrom(void[] buf);
    Receive data and get the remote endpoint Address. If the socket is blocking, receiveFrom waits until there is data to be received.
    Returns:
    The number of bytes actually received, 0 if the remote side has closed the connection, or Socket.ERROR on failure.
  @trusted int getOption(SocketOptionLevel level, SocketOption option, void[] result);
    Get a socket option.
    Returns:
    The number of bytes written to result.
  @trusted int getOption(SocketOptionLevel level, SocketOption option, out int32_t result);
    Common case of getting integer and boolean options.
  @trusted int getOption(SocketOptionLevel level, SocketOption option, out Linger result);
    Get the linger option.
  @trusted void getOption(SocketOptionLevel level, SocketOption option, out Duration result);
    Get a timeout (duration) option.
  @trusted void setOption(SocketOptionLevel level, SocketOption option, void[] value);
    Set a socket option.
  @trusted void setOption(SocketOptionLevel level, SocketOption option, int32_t value);
    Common case for setting integer and boolean options.
  @trusted void setOption(SocketOptionLevel level, SocketOption option, Linger value);
    Set the linger option.
  @trusted void setOption(SocketOptionLevel level, SocketOption option, Duration value);
    Sets a timeout (duration) option, i.e. SocketOption.SNDTIMEO or 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. 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.

    Parameters:

    SocketOptionLevel level | The level at which a socket option is defined.
    SocketOption option | Either SocketOption.SNDTIMEO or SocketOption.RCVTIMEO.
    Duration value | The timeout duration to set. Must not be negative.

    Throws:
    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);

  @safe string getErrorText();
    Get a text description of this socket's error status, and clear the
    socket's error status.
  @trusted void setKeepAlive(int time, int interval);
    Enables TCP keep-alive with the specified parameters.
    Parameters:

    int time | Number of seconds with no activity until the first keep-alive packet is sent.
    int interval | Number of seconds between when successive keep-alive packets are sent if no acknowledgement is received.

    Throws:
    SocketOSException if setting the options fails, or SocketFeatureException if setting keep-alive parameters is unsupported on the current platform.
  static @trusted int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError, Duration timeout);
  static @safe int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError);
  static @trusted int select(SocketSet checkRead, SocketSet checkWrite, SocketSet checkError, TimeVal* timeout);
    Wait for a socket to change status. A wait timeout of or TimeVal, may be specified; if a timeout is not specified or the TimeVal is null, the maximum timeout is used. The TimeVal timeout has an unspecified value when select returns.
    Returns:
    The number of sockets with status changes, 0 on timeout, or -1 on interruption. If the return value is greater than 0, the 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.
  protected pure nothrow @safe Address createAddress();
    Returns a new Address object for the current address family.
    Can be overridden to support other addresses.
class TcpSocket: std.socket.Socket;
  TcpSocket is a shortcut class for a TCP Socket.
  @safe this(AddressFamily family);
    Constructs a blocking TCP Socket.
  @safe this();
    Constructs a blocking IPv4 TCP Socket.
  @safe this(Address connectTo);
    Constructs a blocking TCP Socket and connects to an Address.
class UdpSocket: std.socket.Socket;
  UdpSocket is a shortcut class for a UDP Socket.
  @safe this(AddressFamily family);
    Constructs a blocking UDP Socket.
  @safe this();
    Constructs a blocking IPv4 UDP Socket.
@trusted Socket[2] socketPair();
  Creates a pair of connected sockets.
  The two sockets are indistinguishable.
  Throws:
  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);

Copyright © 1999-2016 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc on Fri Sep 16 23:06:57 2016