manpagez: man pages & more
man IO::Socket::IP(3)
Home | html | info | man
IO::Socket::IP(3pm)    Perl Programmers Reference Guide    IO::Socket::IP(3pm)




NAME

       "IO::Socket::IP" - Family-neutral IP socket 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 == PF_INET6 ) ? "IPv6" :
                         ( $sock->sockdomain == PF_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, intended as a 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 "PF_INET".  "IO::Socket" will also use "IO::Socket::IP" rather
       than "IO::Socket::INET6" to handle "PF_INET6", provided that the
       "AF_INET6" constant is available.

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

        use IO::Socket::IP -register;

        my $sock = IO::Socket->new(
           Domain    => PF_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".

               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".

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

       Family => INT
               The address family to pass to "getaddrinfo" (e.g. "AF_INET",
               "AF_INET6").  Normally this will be left undefined, and
               "getaddrinfo" will search using any address 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.

       GetAddrInfoFlags => INT
               More flags to pass to the "getaddrinfo()" function. If not
               supplied, a default of "AI_ADDRCONFIG" will be used.

               These flags will be combined with "AI_PASSIVE" if the "Listen"
               argument is given. For more information see the documentation
               about "getaddrinfo()" in the Socket module.

       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

       Sockopts => ARRAY
               An optional array of other socket options to apply after the
               three listed above. The value is an ARRAY containing 2- or
               3-element ARRAYrefs. Each inner array relates to a single
               option, giving the level and option name, and an optional
               value. If the value element is missing, it will be given the
               value of a platform-sized integer 1 constant (i.e. suitable to
               enable most of the common boolean options).

               For example, both options given below are equivalent to setting
               "ReuseAddr".

                Sockopts => [
                   [ SOL_SOCKET, SO_REUSEADDR ],
                   [ SOL_SOCKET, SO_REUSEADDR, pack( "i", 1 ) ],
                ]

       V6Only => BOOL
               If defined, set the "IPV6_V6ONLY" sockopt when creating
               "PF_INET6" sockets to the given value. If true, a listening-
               mode socket will only listen on the "AF_INET6" addresses; if
               false it will also accept connections from "AF_INET" addresses.

               If not defined, the socket option will not be changed, and
               default value set by the operating system will apply. For
               repeatable behaviour across platforms it is recommended this
               value always be defined for listening-mode sockets.

               Note that not all platforms support disabling this option.
               Some, at least OpenBSD and MirBSD, will fail with "EINVAL" if
               you attempt to disable it.  To determine whether it is possible
               to disable, you may use the class method

                if( IO::Socket::IP->CAN_DISABLE_V6ONLY ) {
                   ...
                }
                else {
                   ...
                }

               If your platform does not support disabling this option but you
               still want to listen for both "AF_INET" and "AF_INET6"
               connections you will have to create two listening sockets, one
               bound to each protocol.

       MultiHomed
               This "IO::Socket::INET"-style argument is ignored, except if it
               is defined but false. 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.

       Timeout => NUM
               If defined, gives a maximum time in seconds to block per
               "connect()" call when in blocking mode. If missing, no timeout
               is applied other than that provided by the underlying operating
               system. When in non-blocking mode this parameter is ignored.

               Note that if the hostname resolves to multiple address
               candidates, the same timeout will apply to each connection
               attempt individually, rather than to the operation as a whole.
               Further note that the timeout does not apply to the initial
               hostname resolve operation, if connecting by hostname.

               This behviour is copied inspired by "IO::Socket::INET"; for
               more fine grained control over connection timeouts, consider
               performing a nonblocking connect directly.

       If neither "Type" nor "Proto" hints are provided, a default of
       "SOCK_STREAM" and "IPPROTO_TCP" respectively will be set, to maintain
       compatibility with "IO::Socket::INET". Other named arguments that are
       not recognised are ignored.

       If neither "Family" nor any hosts or addresses are passed, nor any
       *AddrInfo, then the constructor has no information on which to decide a
       socket family to create. In this case, it performs a "getaddinfo" call
       with the "AI_ADDRCONFIG" flag, no host name, and a service name of "0",
       and uses the family of the first returned result.

       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 preferable to the following wrappers, because
       it will call getnameinfo(3) only once.

   $addr = $sock->sockhost
       Return the numeric form of the local address as a textual
       representation

   $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

   $addr = $sock->sockaddr
       Return the local address as a binary octet string

   ( $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 preferable to the following wrappers, because
       it will call getnameinfo(3) only once.

   $addr = $sock->peerhost
       Return the numeric form of the peer address as a textual representation

   $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

   $addr = $peer->peeraddr
       Return the peer address as a binary octet string

   $inet = $sock->as_inet
       Returns a new IO::Socket::INET instance wrapping the same filehandle.
       This may be useful in cases where it is required, for backward-
       compatibility, to have a real object of "IO::Socket::INET" type instead
       of "IO::Socket::IP".  The new object will wrap the same underlying
       socket filehandle as the original, so care should be taken not to
       continue to use both objects concurrently. Ideally the original $sock
       should be discarded after this method is called.

       This method checks that the socket domain is "PF_INET" and will throw
       an exception if it isn't.


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. Note that some operating
       systems, most notably "MSWin32" do not report a "connect()" failure
       using write-ready; so you must also "select()" for exceptional status.

       While "connect" returns false, the value of $! indicates whether it
       should be tried again (by being set to the value "EINPROGRESS", or
       "EWOULDBLOCK" on MSWin32), or whether a permanent error has occurred
       (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 EWOULDBLOCK );

        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 || $! == EWOULDBLOCK ) ) {
           my $wvec = '';
           vec( $wvec, fileno $socket, 1 ) = 1;
           my $evec = '';
           vec( $evec, fileno $socket, 1 ) = 1;

           select( undef, $wvec, $evec, 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 then 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
        192.0.2.1:80                 # IPv4 address
        [2001:db8::1]:80             # 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.

       If the "...Host" argument is in this special form and the corresponding
       "...Service" or "...Port" argument is also defined, the one parsed from
       the "...Host" argument will take precedence and the other will be
       ignored.

   ( $host, $port ) = IO::Socket::IP->split_addr( $addr )
       Utility method that provides the parsing functionality described above.
       Returns a 2-element list, containing either the split hostname and port
       description if it could be parsed, or the given address and "undef" if
       it was not recognised.

        IO::Socket::IP->split_addr( "hostname:http" )
                                     # ( "hostname",  "http" )

        IO::Socket::IP->split_addr( "192.0.2.1:80" )
                                     # ( "192.0.2.1", "80"   )

        IO::Socket::IP->split_addr( "[2001:db8::1]:80" )
                                     # ( "2001:db8::1", "80" )

        IO::Socket::IP->split_addr( "something.else" )
                                     # ( "something.else", undef )

   $addr = IO::Socket::IP->join_addr( $host, $port )
       Utility method that performs the reverse of "split_addr", returning a
       string formed by joining the specified host address and port number.
       The host address will be wrapped in "[]" brackets if required (because
       it is a raw IPv6 numeric address).

       This can be especially useful when combined with the "sockhost_service"
       or "peerhost_service" methods.

        say "Connected to ", IO::Socket::IP->join_addr( $sock->peerhost_service );


"IO::Socket::INET" INCOMPATIBILITES

       o   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.
           The constructor will ignore the value of this argument, except if
           it is defined but false. An exception is thrown in this case,
           because that would request it disable the getaddrinfo(3) search
           behaviour in the first place.

       o   "IO::Socket::IP" implements both the "Blocking" and "Timeout"
           parameters, but it implements the interaction of both in a
           different way.

           In "::INET", supplying a timeout overrides the non-blocking
           behaviour, meaning that the "connect()" operation will still block
           despite that the caller asked for a non-blocking socket. This is
           not explicitly specified in its documentation, nor does this author
           believe that is a useful behaviour - it appears to come from a
           quirk of implementation.

           In "::IP" therefore, the "Blocking" parameter takes precedence - if
           a non-blocking socket is requested, no operation will block. The
           "Timeout" parameter here simply defines the maximum time that a
           blocking "connect()" call will wait, if it blocks at all.

           In order to specifically obtain the "blocking connect then non-
           blocking send and receive" behaviour of specifying this combination
           of options to "::INET" when using "::IP", perform first a blocking
           connect, then afterwards turn the socket into nonblocking mode.

            my $sock = IO::Socket::IP->new(
               PeerHost => $peer,
               Timeout => 20,
            ) or die "Cannot connect - $@";

            $sock->blocking( 0 );

           This code will behave identically under both "IO::Socket::INET" and
           "IO::Socket::IP".


TODO

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


AUTHOR

       Paul Evans <leonerd@leonerd.org.uk>



perl v5.26.1                      2017-07-18               IO::Socket::IP(3pm)

perl 5.26.1 - Generated Sun Nov 5 14:16:55 CST 2017
© manpagez.com 2000-2017
Individual documents may contain additional copyright information.