The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
 / 
IO-Socket-IP-0.07
River stage four • 46 direct dependents • 6681 total dependents
21 ++
/ IO::Socket::IP

NAME

IO::Socket::IP - A drop-in replacement for IO::Socket::INET supporting both IPv4 and IPv6

SYNOPSIS

 use IO::Socket::IP;

 my $sock = IO::Socket::IP->new(
    PeerHost => "www.google.com",
    PeerPort => "http",
    Type     => SOCK_STREAM,
 ) or die "Cannot construct socket - $@";

 my $familyname = ( $sock->sockdomain == AF_INET6 ) ? "IPv6" :
                  ( $sock->sockdomain == AF_INET  ) ? "IPv4" :
                                                      "unknown";

 printf "Connected to google via %s\n", $familyname;

DESCRIPTION

This module provides a protocol-independent way to use IPv4 and IPv6 sockets, as a drop-in replacement for IO::Socket::INET. Most constructor arguments and methods are provided in a backward-compatible way. For a list of known differences, see the IO::Socket::INET INCOMPATIBILITES section below.

It uses the getaddrinfo(3) function to convert hostnames and service names or port numbers into sets of possible addresses to connect to or listen on. This allows it to work for IPv6 where the system supports it, while still falling back to IPv4-only on systems which don't.

REPLACING IO::Socket DEFAULT BEHAVIOUR

By placing -register in the import list, IO::Socket uses IO::Socket::IP rather than IO::Socket::INET as the class that handles AF_INET. IO::Socket will also use IO::Socket::IP rather than IO::Socket::INET6 to handle AF_INET6, provided that the AF_INET6 constant is available.

Changing IO::Socket's default behaviour means that calling the IO::Socket constructor with either AF_INET or AF_INET6 as the Domain parameter will yield an IO::Socket::IP object.

 use IO::Socket::IP -register;

 my $sock = IO::Socket->new(
    Domain    => AF_INET6,
    LocalHost => "::1",
    Listen    => 1,
 ) or die "Cannot create socket - $@\n";

 print "Created a socket of type " . ref($sock) . "\n";

Note that -register is a global setting that applies to the entire program; it cannot be applied only for certain callers, removed, or limited by lexical scope.

CONSTRUCTORS

$sock = IO::Socket::IP->new( %args )

Creates a new IO::Socket::IP object, containing a newly created socket handle according to the named arguments passed. The recognised arguments are:

PeerHost => STRING
PeerService => STRING

Hostname and service name for the peer to connect() to. The service name may be given as a port number, as a decimal string.

PeerAddr => STRING
PeerPort => STRING

For symmetry with the accessor methods and compatibility with IO::Socket::INET, these are accepted as synonyms for PeerHost and PeerService respectively.

PeerAddrInfo => ARRAY

Alternate form of specifying the peer to connect() to. This should be an array of the form returned by Socket::GetAddrInfo::getaddrinfo.

This parameter takes precedence over the Peer*, Family, Type and Proto arguments.

LocalHost => STRING
LocalService => STRING

Hostname and service name for the local address to bind() to.

LocalAddr => STRING
LocalPort => STRING

For symmetry with the accessor methods and compatibility with IO::Socket::INET, these are accepted as synonyms for LocalHost and LocalService respectively.

LocalAddrInfo => ARRAY

Alternate form of specifying the local address to bind() to. This should be an array of the form returned by Socket::GetAddrInfo::getaddrinfo.

This parameter takes precedence over the Local*, Family, Type and Proto arguments.

Family => INT

The socket family to pass to getaddrinfo (e.g. AF_INET, AF_INET6). Normally this will be left undefined, and getaddrinfo will search using any family supported by the system.

Type => INT

The socket type to pass to getaddrinfo (e.g. SOCK_STREAM, SOCK_DGRAM). Normally defined by the caller; if left undefined getaddrinfo may attempt to infer the type from the service name.

Proto => STRING or INT

The IP protocol to use for the socket (e.g. 'tcp', IPPROTO_TCP, 'udp',IPPROTO_UDP). Normally this will be left undefined, and either getaddrinfo or the kernel will choose an appropriate value. May be given either in string name or numeric form.

Listen => INT

If defined, puts the socket into listening mode where new connections can be accepted using the accept method. The value given is used as the listen(2) queue size.

ReuseAddr => BOOL

If true, set the SO_REUSEADDR sockopt

ReusePort => BOOL

If true, set the SO_REUSEPORT sockopt (not all OSes implement this sockopt)

Broadcast => BOOL

If true, set the SO_BROADCAST sockopt

Timeout

This IO::Socket::INET-style argument is not currently supported. See the IO::Socket::INET INCOMPATIBILITES section below.

MultiHomed

This IO::Socket::INET-style argument is not currently supported. See the IO::Socket::INET INCOMPATIBILITES section below. However, the behaviour it enables is always performed by IO::Socket::IP.

Blocking => BOOL

If defined but false, the socket will be set to non-blocking mode. Otherwise it will default to blocking mode. See the NON-BLOCKING section below for more detail.

If neither Type nor Proto hints are provided, a default of SOCK_STREAM and IPPROTO_TCP respectively will be set, to maintain compatibilty with IO::Socket::INET.

If the constructor fails, it will set $@ to an appropriate error message; this may be from $! or it may be some other string; not every failure necessarily has an associated errno value.

$sock = IO::Socket::IP->new( $peeraddr )

As a special case, if the constructor is passed a single argument (as opposed to an even-sized list of key/value pairs), it is taken to be the value of the PeerAddr parameter. This is parsed in the same way, according to the behaviour given in the PeerHost AND LocalHost PARSING section below.

METHODS

As well as the following methods, this class inherits all the methods in IO::Socket and IO::Handle.

( $host, $service ) = $sock->sockhost_service( $numeric )

Returns the hostname and service name of the local address (that is, the socket address given by the sockname method).

If $numeric is true, these will be given in numeric form rather than being resolved into names.

The following four convenience wrappers may be used to obtain one of the two values returned here. If both host and service names are required, this method is preferrable to the following wrappers, because it will call getnameinfo(3) only once.

$addr = $sock->sockhost

Return the numeric form of the local address

$port = $sock->sockport

Return the numeric form of the local port number

$host = $sock->sockhostname

Return the resolved name of the local address

$service = $sock->sockservice

Return the resolved name of the local port number

( $host, $service ) = $sock->peerhost_service( $numeric )

Returns the hostname and service name of the peer address (that is, the socket address given by the peername method), similar to the sockhost_service method.

The following four convenience wrappers may be used to obtain one of the two values returned here. If both host and service names are required, this method is preferrable to the following wrappers, because it will call getnameinfo(3) only once.

$addr = $sock->peerhost

Return the numeric form of the peer address

$port = $sock->peerport

Return the numeric form of the peer port number

$host = $sock->peerhostname

Return the resolved name of the peer address

$service = $sock->peerservice

Return the resolved name of the peer port number

NON-BLOCKING

If the constructor is passed a defined but false value for the Blocking argument then the socket is put into non-blocking mode. When in non-blocking mode, the socket will not be set up by the time the constructor returns, because the underlying connect(2) syscall would otherwise have to block.

The non-blocking behaviour is an extension of the IO::Socket::INET API, unique to IO::Socket::IP, because the former does not support multi-homed non-blocking connect.

When using non-blocking mode, the caller must repeatedly check for writeability on the filehandle (for instance using select or IO::Poll). Each time the filehandle is ready to write, the connect method must be called, with no arguments.

While connect returns false, the value of $! indicates whether it should be tried again (by being set to the value EINPROGRESS), or whether a permanent error has occured (e.g. ECONNREFUSED).

Once the socket has been connected to the peer, connect will return true and the socket will now be ready to use.

Note that calls to the platform's underlying getaddrinfo(3) function may block. If IO::Socket::IP has to perform this lookup, the constructor will block even when in non-blocking mode.

To avoid this blocking behaviour, the caller should pass in the result of such a lookup using the PeerAddrInfo or LocalAddrInfo arguments. This can be achieved by using Net::LibAsyncNS, or the getaddrinfo(3) function can be called in a child process.

 use IO::Socket::IP;
 use Errno qw( EINPROGRESS );

 my @peeraddrinfo = ... # Caller must obtain the getaddinfo result here

 my $socket = IO::Socket::IP->new(
    PeerAddrInfo => \@peeraddrinfo,
    Blocking     => 0,
 ) or die "Cannot construct socket - $@";

 while( !$socket->connect and $! == EINPROGRESS ) {
    my $wvec = '';
    vec( $wvec, fileno $socket, 1 ) = 1;

    select( undef, $wvec, undef, undef ) or die "Cannot select - $!";
 }

 die "Cannot connect - $!" if $!;

 ...

The example above uses select(), but any similar mechanism should work analogously. IO::Socket::IP takes care when creating new socket filehandles to preserve the actual file descriptor number, so such techniques as poll or epoll should be transparent to its reallocation of a different socket underneath, perhaps in order to switch protocol family between PF_INET and PF_INET6.

For another example using IO::Poll and Net::LibAsyncNS, see the examples/nonblocking_libasyncns.pl file in the module distribution.

PeerHost AND LocalHost PARSING

To support the IO::Socket::INET API, the host and port information may be passed in a single string rather than as two separate arguments.

If either LocalHost or PeerHost (or their ...Addr synonyms) have any of the following special forms, and LocalService or PeerService (or their ...Port synonyms) are absent, special parsing is applied.

The value of the ...Host argument will be split to give both the hostname and port (or service name):

 hostname.example.org:http    # Host name
 10.0.0.1:80                  # IPv4 address
 [fe80::123]:443              # IPv6 address

In each case, the port or service name (e.g. 80) is passed as the LocalService or PeerService argument.

Either of LocalService or PeerService (or their ...Port synonyms) can be either a service name, a decimal number, or a string containing both a service name and number, in a form such as

 http(80)

In this case, the name (http) will be tried first, but if the resolver does not understand it then the port number (80) will be used instead.

IO::Socket::INET INCOMPATIBILITES

  • The Timeout and MultiHomed constructor arguments are currently not recognised.

    The behaviour enabled by MultiHomed is in fact implemented by IO::Socket::IP as it is required to correctly support searching for a useable address from the results of the getaddrinfo(3) call.

TODO

  • Cache the returns from sockhost_service and peerhost_service to avoid double-lookup overhead in such code as

      printf "Peer is %s:%d\n", $sock->peerhost, $sock->peerport;

  • Investigate whether POSIX::dup2 upsets BSD's kqueue watchers, and if so, consider what possible workarounds might be applied.

BUGS

  • Nonblocking connect fails unit tests on MSWin32 smoke-testing machines. The specifics of the failure are that connect() seems to block anyway despite being asked not to, and that failure to connect is not detected properly. I am as yet unsure why this is.

    Blocking connect on MSWin32, and both blocking and nonblocking connect on other platforms, all test OK on smoke testing.

AUTHOR

Paul Evans <leonerd@leonerd.org.uk>