xXx

Hexid M1n1 5h3ll MobiLe

proc/self/root/usr/share/doc/perl-IO-Socket-IP/_[ Not.Writable ]

File://proc/self/root/usr/share/doc/perl-IO-Socket-IP/README

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 to IO::Socket::IP, it will
    register itself with IO::Socket as the class that handles PF_INET. It
    will also ask to handle PF_INET6 as well, provided that 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

 new

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

 new (one arg)

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

 sockhost_service

       ( $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.

 sockhost

       $addr = $sock->sockhost

    Return the numeric form of the local address as a textual
    representation

 sockport

       $port = $sock->sockport

    Return the numeric form of the local port number

 sockhostname

       $host = $sock->sockhostname

    Return the resolved name of the local address

 sockservice

       $service = $sock->sockservice

    Return the resolved name of the local port number

 sockaddr

       $addr = $sock->sockaddr

    Return the local address as a binary octet string

 peerhost_service

       ( $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.

 peerhost

       $addr = $sock->peerhost

    Return the numeric form of the peer address as a textual representation

 peerport

       $port = $sock->peerport

    Return the numeric form of the peer port number

 peerhostname

       $host = $sock->peerhostname

    Return the resolved name of the peer address

 peerservice

       $service = $sock->peerservice

    Return the resolved name of the peer port number

 peeraddr

       $addr = $peer->peeraddr

    Return the peer address as a binary octet string

 as_inet

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

 split_addr

       ( $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 )

 join_addr

       $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

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

      * 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

      * 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>

Your Access Expired	Date. in : 19-09-2025
Regist : 09-12-2024	Expired : 01-12-2027