summaryrefslogtreecommitdiff
path: root/cpan/Socket
diff options
context:
space:
mode:
Diffstat (limited to 'cpan/Socket')
-rw-r--r--cpan/Socket/.gitignore1
-rw-r--r--cpan/Socket/Makefile.PL93
-rw-r--r--cpan/Socket/Socket.pm832
-rw-r--r--cpan/Socket/Socket.xs851
-rw-r--r--cpan/Socket/t/Socket.t184
-rw-r--r--cpan/Socket/t/getaddrinfo.t125
-rw-r--r--cpan/Socket/t/getnameinfo.t37
-rw-r--r--cpan/Socket/t/ipv6_mreq.t26
-rw-r--r--cpan/Socket/t/socketpair.t245
9 files changed, 2394 insertions, 0 deletions
diff --git a/cpan/Socket/.gitignore b/cpan/Socket/.gitignore
new file mode 100644
index 0000000000..2a06e93b55
--- /dev/null
+++ b/cpan/Socket/.gitignore
@@ -0,0 +1 @@
+*.inc
diff --git a/cpan/Socket/Makefile.PL b/cpan/Socket/Makefile.PL
new file mode 100644
index 0000000000..e5daf93a98
--- /dev/null
+++ b/cpan/Socket/Makefile.PL
@@ -0,0 +1,93 @@
+use ExtUtils::MakeMaker;
+use ExtUtils::Constant 0.23 'WriteConstants';
+use Config;
+WriteMakefile(
+ NAME => 'Socket',
+ VERSION_FROM => 'Socket.pm',
+ ($Config{libs} =~ /(-lsocks\S*)/ ? (LIBS => [ "$1" ] ) : ()),
+ XSPROTOARG => '-noprototypes', # XXX remove later?
+ realclean => {FILES=> 'const-c.inc const-xs.inc'},
+);
+my @names = (qw(AF_802 AF_AAL AF_APPLETALK AF_CCITT AF_CHAOS AF_CTF
+ AF_DATAKIT AF_DECnet AF_DLI AF_ECMA AF_GOSIP AF_HYLINK
+ AF_IMPLINK AF_INET AF_INET6 AF_ISO AF_KEY
+ AF_LAST AF_LAT AF_LINK AF_MAX AF_NBS AF_NIT AF_NS
+ AF_OSI AF_OSINET AF_PUP AF_ROUTE AF_SNA
+ AF_UNIX AF_UNSPEC AF_USER AF_WAN AF_X25
+ AI_CANONNAME AI_NUMERICHOST AI_NUMERICSERV AI_PASSIVE
+ EAI_ADDRFAMILY EAI_AGAIN EAI_BADFLAGS EAI_FAIL EAI_FAMILY
+ EAI_NODATA EAI_NONAME EAI_SERVICE EAI_SOCKTYPE
+ IOV_MAX IP_OPTIONS IP_HDRINCL IP_TOS IP_TTL IP_RECVOPTS
+ IP_RECVRETOPTS IP_RETOPTS
+ IPV6_ADD_MEMBERSHIP IPV6_DROP_MEMBERSHIP IPV6_MTU
+ IPV6_MTU_DISCOVER IPV6_MULTICAST_HOPS IPV6_MULTICAST_IF
+ IPV6_MULTICAST_LOOP IPV6_UNICAST_HOPS IPV6_V6ONLY
+ MSG_BCAST MSG_BTAG MSG_CTLFLAGS MSG_CTLIGNORE MSG_DONTWAIT
+ MSG_EOF MSG_EOR MSG_ERRQUEUE MSG_ETAG MSG_FIN
+ MSG_MAXIOVLEN MSG_MCAST MSG_NOSIGNAL MSG_RST MSG_SYN
+ MSG_TRUNC MSG_URG MSG_WAITALL MSG_WIRE
+ NI_DGRAM NI_NAMEREQD NI_NUMERICHOST NI_NUMERICSERV
+ PF_802 PF_AAL PF_APPLETALK PF_CCITT PF_CHAOS PF_CTF
+ PF_DATAKIT PF_DECnet PF_DLI PF_ECMA PF_GOSIP PF_HYLINK
+ PF_IMPLINK PF_INET PF_INET6 PF_ISO PF_KEY
+ PF_LAST PF_LAT PF_LINK PF_MAX PF_NBS PF_NIT PF_NS
+ PF_OSI PF_OSINET PF_PUP PF_ROUTE PF_SNA
+ PF_UNIX PF_UNSPEC PF_USER PF_WAN PF_X25
+ SCM_CONNECT SCM_CREDENTIALS SCM_CREDS SCM_TIMESTAMP
+ SOCK_DGRAM SOCK_RAW SOCK_RDM SOCK_SEQPACKET SOCK_STREAM
+ SOL_SOCKET SOMAXCONN
+ SO_ACCEPTCONN SO_ATTACH_FILTER SO_BACKLOG SO_BROADCAST
+ SO_CHAMELEON SO_DEBUG SO_DETACH_FILTER SO_DGRAM_ERRIND
+ SO_DONTLINGER SO_DONTROUTE SO_ERROR SO_FAMILY
+ SO_KEEPALIVE SO_LINGER SO_OOBINLINE
+ SO_PASSCRED SO_PASSIFNAME SO_PEERCRED
+ SO_PROTOCOL SO_PROTOTYPE
+ SO_RCVBUF SO_RCVLOWAT SO_RCVTIMEO
+ SO_REUSEADDR SO_REUSEPORT
+ SO_SECURITY_AUTHENTICATION
+ SO_SECURITY_ENCRYPTION_NETWORK
+ SO_SECURITY_ENCRYPTION_TRANSPORT
+ SO_SNDBUF SO_SNDLOWAT SO_SNDTIMEO
+ SO_STATE SO_TYPE SO_USELOOPBACK SO_XOPEN SO_XSE
+ TCP_KEEPALIVE TCP_MAXRT TCP_MAXSEG TCP_NODELAY TCP_STDURG
+ TCP_CORK TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT
+ TCP_SYNCNT TCP_LINGER2 TCP_DEFER_ACCEPT TCP_WINDOW_CLAMP
+ TCP_INFO TCP_QUICKACK TCP_CONGESTION TCP_MD5SIG
+ UIO_MAXIOV
+ ),
+ {name=>"IPPROTO_IP", type=>"IV", default=>["IV", 0]},
+ {name=>"IPPROTO_IPV6", type=>"IV", default=>["IV", 41]},
+ {name=>"IPPROTO_RAW", type=>"IV", default=>["IV", 255]},
+ {name=>"IPPROTO_ICMP", type=>"IV", default=>["IV", 1]},
+ {name=>"IPPROTO_TCP", type=>"IV", default=>["IV", 6]},
+ {name=>"IPPROTO_UDP", type=>"IV", default=>["IV", 17]},
+ {name=>"SHUT_RD", type=>"IV", default=>["IV", "0"]},
+ {name=>"SHUT_WR", type=>"IV", default=>["IV", "1"]},
+ {name=>"SHUT_RDWR", type=>"IV", default=>["IV", "2"]},
+);
+
+push @names,
+ {name=>$_, type=>"IV",
+ macro=>["#if defined($_) || defined(HAS_$_) /* might be an enum */\n",
+ "#endif\n"]}
+foreach qw (MSG_CTRUNC MSG_DONTROUTE MSG_OOB MSG_PEEK MSG_PROXY SCM_RIGHTS);
+
+push @names,
+{name => $_, type => "SV",
+ pre=>"struct in_addr ip_address; ip_address.s_addr = htonl($_);",
+ value => "newSVpvn_flags((char *)&ip_address,sizeof(ip_address), SVs_TEMP)",}
+ foreach qw(INADDR_ANY INADDR_LOOPBACK INADDR_NONE INADDR_BROADCAST);
+
+push @names,
+{name => $_, type => "SV",
+ macro=>["#ifdef ${_}_INIT\n",
+ "#endif\n"],
+ pre=>"struct in6_addr ip6_address = ${_}_INIT;",
+ value => "newSVpvn_flags((char *)&ip6_address,sizeof(ip6_address), SVs_TEMP)",}
+ foreach qw(IN6ADDR_ANY IN6ADDR_LOOPBACK);
+
+WriteConstants(
+ PROXYSUBS => {autoload => 1},
+ NAME => 'Socket',
+ NAMES => \@names,
+);
diff --git a/cpan/Socket/Socket.pm b/cpan/Socket/Socket.pm
new file mode 100644
index 0000000000..5fff0d0150
--- /dev/null
+++ b/cpan/Socket/Socket.pm
@@ -0,0 +1,832 @@
+package Socket;
+
+use strict;
+
+our($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
+$VERSION = "1.94_03";
+
+=head1 NAME
+
+Socket, sockaddr_in, sockaddr_un, inet_aton, inet_ntoa, inet_pton, inet_ntop - load the C socket.h defines and structure manipulators
+
+=head1 SYNOPSIS
+
+ use Socket;
+
+ $proto = getprotobyname('udp');
+ socket(Socket_Handle, PF_INET, SOCK_DGRAM, $proto);
+ $iaddr = gethostbyname('hishost.com');
+ $port = getservbyname('time', 'udp');
+ $sin = sockaddr_in($port, $iaddr);
+ send(Socket_Handle, 0, 0, $sin);
+
+ $proto = getprotobyname('tcp');
+ socket(Socket_Handle, PF_INET, SOCK_STREAM, $proto);
+ $port = getservbyname('smtp', 'tcp');
+ $sin = sockaddr_in($port,inet_aton("127.1"));
+ $sin = sockaddr_in(7,inet_aton("localhost"));
+ $sin = sockaddr_in(7,INADDR_LOOPBACK);
+ connect(Socket_Handle,$sin);
+
+ ($port, $iaddr) = sockaddr_in(getpeername(Socket_Handle));
+ $peer_host = gethostbyaddr($iaddr, AF_INET);
+ $peer_addr = inet_ntoa($iaddr);
+
+ $proto = getprotobyname('tcp');
+ socket(Socket_Handle, PF_UNIX, SOCK_STREAM, $proto);
+ unlink('/var/run/usock');
+ $sun = sockaddr_un('/var/run/usock');
+ connect(Socket_Handle,$sun);
+
+=head1 DESCRIPTION
+
+This module is just a translation of the C F<socket.h> file.
+Unlike the old mechanism of requiring a translated F<socket.ph>
+file, this uses the B<h2xs> program (see the Perl source distribution)
+and your native C compiler. This means that it has a
+far more likely chance of getting the numbers right. This includes
+all of the commonly used pound-defines like AF_INET, SOCK_STREAM, etc.
+
+Also, some common socket "newline" constants are provided: the
+constants C<CR>, C<LF>, and C<CRLF>, as well as C<$CR>, C<$LF>, and
+C<$CRLF>, which map to C<\015>, C<\012>, and C<\015\012>. If you do
+not want to use the literal characters in your programs, then use
+the constants provided here. They are not exported by default, but can
+be imported individually, and with the C<:crlf> export tag:
+
+ use Socket qw(:DEFAULT :crlf);
+
+In addition, some structure manipulation functions are available:
+
+=over 4
+
+=item inet_aton HOSTNAME
+
+Takes a string giving the name of a host, and translates that to an
+opaque string (if programming in C, struct in_addr). Takes arguments
+of both the 'rtfm.mit.edu' type and '18.181.0.24'. If the host name
+cannot be resolved, returns undef. For multi-homed hosts (hosts with
+more than one address), the first address found is returned.
+
+For portability do not assume that the result of inet_aton() is 32
+bits wide, in other words, that it would contain only the IPv4 address
+in network order.
+
+=item inet_ntoa IP_ADDRESS
+
+Takes a string (an opaque string as returned by inet_aton(),
+or a v-string representing the four octets of the IPv4 address in
+network order) and translates it into a string of the form 'd.d.d.d'
+where the 'd's are numbers less than 256 (the normal human-readable
+four dotted number notation for Internet addresses).
+
+=item INADDR_ANY
+
+Note: does not return a number, but a packed string.
+
+Returns the 4-byte wildcard ip address which specifies any
+of the hosts ip addresses. (A particular machine can have
+more than one ip address, each address corresponding to
+a particular network interface. This wildcard address
+allows you to bind to all of them simultaneously.)
+Normally equivalent to inet_aton('0.0.0.0').
+
+=item INADDR_BROADCAST
+
+Note: does not return a number, but a packed string.
+
+Returns the 4-byte 'this-lan' ip broadcast address.
+This can be useful for some protocols to solicit information
+from all servers on the same LAN cable.
+Normally equivalent to inet_aton('255.255.255.255').
+
+=item INADDR_LOOPBACK
+
+Note - does not return a number.
+
+Returns the 4-byte loopback address. Normally equivalent
+to inet_aton('localhost').
+
+=item INADDR_NONE
+
+Note - does not return a number.
+
+Returns the 4-byte 'invalid' ip address. Normally equivalent
+to inet_aton('255.255.255.255').
+
+=item IN6ADDR_ANY
+
+Returns the 16-byte wildcard IPv6 address. Normally equivalent
+to inet_pton(AF_INET6, "::")
+
+=item IN6ADDR_LOOPBACK
+
+Returns the 16-byte loopback IPv6 address. Normally equivalent
+to inet_pton(AF_INET6, "::1")
+
+=item sockaddr_family SOCKADDR
+
+Takes a sockaddr structure (as returned by pack_sockaddr_in(),
+pack_sockaddr_un() or the perl builtin functions getsockname() and
+getpeername()) and returns the address family tag. It will match the
+constant AF_INET for a sockaddr_in and AF_UNIX for a sockaddr_un. It
+can be used to figure out what unpacker to use for a sockaddr of
+unknown type.
+
+=item sockaddr_in PORT, ADDRESS
+
+=item sockaddr_in SOCKADDR_IN
+
+In a list context, unpacks its SOCKADDR_IN argument and returns an array
+consisting of (PORT, ADDRESS). In a scalar context, packs its (PORT,
+ADDRESS) arguments as a SOCKADDR_IN and returns it. If this is confusing,
+use pack_sockaddr_in() and unpack_sockaddr_in() explicitly.
+
+=item pack_sockaddr_in PORT, IP_ADDRESS
+
+Takes two arguments, a port number and an opaque string, IP_ADDRESS
+(as returned by inet_aton(), or a v-string). Returns the sockaddr_in
+structure with those arguments packed in with AF_INET filled in. For
+Internet domain sockets, this structure is normally what you need for
+the arguments in bind(), connect(), and send(), and is also returned
+by getpeername(), getsockname() and recv().
+
+=item unpack_sockaddr_in SOCKADDR_IN
+
+Takes a sockaddr_in structure (as returned by pack_sockaddr_in()) and
+returns an array of two elements: the port and an opaque string
+representing the IP address (you can use inet_ntoa() to convert the
+address to the four-dotted numeric format). Will croak if the
+structure does not have AF_INET in the right place.
+
+=item sockaddr_in6 PORT, IP6_ADDRESS, [ SCOPE_ID, [ FLOWINFO ] ]
+
+=item sockaddr_in6 SOCKADDR_IN6
+
+In list context, unpacks its SOCKADDR_IN6 argument according to
+unpack_sockaddr_in6(). In scalar context, packs its arguments according to
+pack_sockaddr_in6().
+
+=item pack_sockaddr_in6 PORT, IP6_ADDRESS, [ SCOPE_ID, [ FLOWINFO ] ]
+
+Takes two to four arguments, a port number, an opaque string (as returned by
+inet_pton()), optionally a scope ID number, and optionally a flow label
+number. Returns the sockaddr_in6 structure with those arguments packed in
+with AF_INET6 filled in. IPv6 equivalent of pack_sockaddr_in().
+
+=item unpack_sockaddr_in6 SOCKADDR_IN6
+
+Takes a sockaddr_in6 structure (as returned by pack_sockaddr_in6()) and
+returns an array of four elements: the port number, an opaque string
+representing the IPv6 address, the scope ID, and the flow label. (You can
+use inet_ntop() to convert the address to the usual string format). Will
+croak if the structure does not have AF_INET6 in the right place.
+
+=item sockaddr_un PATHNAME
+
+=item sockaddr_un SOCKADDR_UN
+
+In a list context, unpacks its SOCKADDR_UN argument and returns an array
+consisting of (PATHNAME). In a scalar context, packs its PATHNAME
+arguments as a SOCKADDR_UN and returns it. If this is confusing, use
+pack_sockaddr_un() and unpack_sockaddr_un() explicitly.
+These are only supported if your system has E<lt>F<sys/un.h>E<gt>.
+
+=item pack_sockaddr_un PATH
+
+Takes one argument, a pathname. Returns the sockaddr_un structure with
+that path packed in with AF_UNIX filled in. For unix domain sockets, this
+structure is normally what you need for the arguments in bind(),
+connect(), and send(), and is also returned by getpeername(),
+getsockname() and recv().
+
+=item unpack_sockaddr_un SOCKADDR_UN
+
+Takes a sockaddr_un structure (as returned by pack_sockaddr_un())
+and returns the pathname. Will croak if the structure does not
+have AF_UNIX in the right place.
+
+=item inet_pton ADDRESS_FAMILY, HOSTNAME
+
+Takes an address family, either AF_INET or AF_INET6, and a string giving
+the name of a host, and translates that to an opaque string
+(if programming in C, struct in_addr or struct in6_addr depending on the
+address family passed in). The host string may be a string hostname, such
+as 'www.perl.org', or an IP address. If using an IP address, the type of
+IP address must be consistent with the address family passed into the function.
+
+This function is not exported by default.
+
+=item inet_ntop ADDRESS_FAMILY, IP_ADDRESS
+
+Takes an address family, either AF_INET or AF_INET6, and a string
+(an opaque string as returned by inet_aton() or inet_pton()) and
+translates it to an IPv4 or IPv6 address string.
+
+This function is not exported by default.
+
+=item getaddrinfo HOST, SERVICE, [ HINTS ]
+
+Given at least one of a hostname and a service name, returns a list of address
+structures to listen on or connect to. HOST and SERVICE should be plain
+strings (or a numerical port number for SERVICE). If present, HINTS should be
+a reference to a HASH, where the following keys are recognised:
+
+=over 8
+
+=item flags => INT
+
+A bitfield containing C<AI_*> constants
+
+=item family => INT
+
+Restrict to only generating addresses in this address family
+
+=item socktype => INT
+
+Restrict to only generating addresses of this socket type
+
+=item protocol => INT
+
+Restrict to only generating addresses for this protocol
+
+=back
+
+The return value will be a list; the first value being an error indication,
+followed by a list of address structures (if no error occured).
+
+ my ( $err, @results ) = getaddrinfo( ... );
+
+The error value will be a dualvar; comparable to the C<EI_*> error constants,
+or printable as a human-readable error message string. Each value in the
+results list will be a HASH reference containing the following fields:
+
+=over 8
+
+=item family => INT
+
+The address family (e.g. AF_INET)
+
+=item socktype => INT
+
+The socket type (e.g. SOCK_STREAM)
+
+=item protocol => INT
+
+The protocol (e.g. IPPROTO_TCP)
+
+=item addr => STRING
+
+The address in a packed string (such as would be returned by pack_sockaddr_in)
+
+=item canonname => STRING
+
+The canonical name for the host if the C<AI_CANONNAME> flag was provided, or
+C<undef> otherwise. This field will only be present on the first returned
+address.
+
+=back
+
+=item getnameinfo ADDR, FLAGS
+
+Given a packed socket address (such as from C<getsockname>, C<getpeername>, or
+returned by C<getaddrinfo> in a C<addr> field), returns the hostname and
+symbolic service name it represents. FLAGS may be a bitmask of C<NI_*>
+constants, or defaults to 0 if unspecified.
+
+The return value will be a list; the first value being an error condition,
+followed by the hostname and service name.
+
+ my ( $err, $host, $service ) = getnameinfo( ... );
+
+The error value will be a dualvar; comparable to the C<EI_*> error constants,
+or printable as a human-readable error message string. The host and service
+names will be plain strings.
+
+=back
+
+=over 8
+
+=item pack_ipv6_mreq IP6_MULTIADDR, INTERFACE
+
+Takes an IPv6 address and an interface number. Returns the ipv6_mreq structure
+with those arguments packed in. Suitable for use with the
+C<IPV6_ADD_MEMBERSHIP> and C<IPV6_DROP_MEMBERSHIP> sockopts.
+
+=item unpack_ipv6_mreq IPV6_MREQ
+
+Takes an ipv6_mreq structure and returns a list of two elements; the IPv6
+address and an interface number.
+
+=back
+
+=cut
+
+use Carp;
+use warnings::register;
+
+require Exporter;
+require XSLoader;
+@ISA = qw(Exporter);
+
+# <@Nicholas> you can't change @EXPORT without breaking the implicit API
+# Please put any new constants in @EXPORT_OK!
+@EXPORT = qw(
+ inet_aton inet_ntoa
+ sockaddr_family
+ pack_sockaddr_in unpack_sockaddr_in
+ pack_sockaddr_un unpack_sockaddr_un
+ pack_sockaddr_in6 unpack_sockaddr_in6
+ sockaddr_in sockaddr_in6 sockaddr_un
+ INADDR_ANY INADDR_BROADCAST INADDR_LOOPBACK INADDR_NONE
+ AF_802
+ AF_AAL
+ AF_APPLETALK
+ AF_CCITT
+ AF_CHAOS
+ AF_CTF
+ AF_DATAKIT
+ AF_DECnet
+ AF_DLI
+ AF_ECMA
+ AF_GOSIP
+ AF_HYLINK
+ AF_IMPLINK
+ AF_INET
+ AF_INET6
+ AF_ISO
+ AF_KEY
+ AF_LAST
+ AF_LAT
+ AF_LINK
+ AF_MAX
+ AF_NBS
+ AF_NIT
+ AF_NS
+ AF_OSI
+ AF_OSINET
+ AF_PUP
+ AF_ROUTE
+ AF_SNA
+ AF_UNIX
+ AF_UNSPEC
+ AF_USER
+ AF_WAN
+ AF_X25
+ IOV_MAX
+ IP_OPTIONS
+ IP_HDRINCL
+ IP_TOS
+ IP_TTL
+ IP_RECVOPTS
+ IP_RECVRETOPTS
+ IP_RETOPTS
+ MSG_BCAST
+ MSG_BTAG
+ MSG_CTLFLAGS
+ MSG_CTLIGNORE
+ MSG_CTRUNC
+ MSG_DONTROUTE
+ MSG_DONTWAIT
+ MSG_EOF
+ MSG_EOR
+ MSG_ERRQUEUE
+ MSG_ETAG
+ MSG_FIN
+ MSG_MAXIOVLEN
+ MSG_MCAST
+ MSG_NOSIGNAL
+ MSG_OOB
+ MSG_PEEK
+ MSG_PROXY
+ MSG_RST
+ MSG_SYN
+ MSG_TRUNC
+ MSG_URG
+ MSG_WAITALL
+ MSG_WIRE
+ PF_802
+ PF_AAL
+ PF_APPLETALK
+ PF_CCITT
+ PF_CHAOS
+ PF_CTF
+ PF_DATAKIT
+ PF_DECnet
+ PF_DLI
+ PF_ECMA
+ PF_GOSIP
+ PF_HYLINK
+ PF_IMPLINK
+ PF_INET
+ PF_INET6
+ PF_ISO
+ PF_KEY
+ PF_LAST
+ PF_LAT
+ PF_LINK
+ PF_MAX
+ PF_NBS
+ PF_NIT
+ PF_NS
+ PF_OSI
+ PF_OSINET
+ PF_PUP
+ PF_ROUTE
+ PF_SNA
+ PF_UNIX
+ PF_UNSPEC
+ PF_USER
+ PF_WAN
+ PF_X25
+ SCM_CONNECT
+ SCM_CREDENTIALS
+ SCM_CREDS
+ SCM_RIGHTS
+ SCM_TIMESTAMP
+ SHUT_RD
+ SHUT_RDWR
+ SHUT_WR
+ SOCK_DGRAM
+ SOCK_RAW
+ SOCK_RDM
+ SOCK_SEQPACKET
+ SOCK_STREAM
+ SOL_SOCKET
+ SOMAXCONN
+ SO_ACCEPTCONN
+ SO_ATTACH_FILTER
+ SO_BACKLOG
+ SO_BROADCAST
+ SO_CHAMELEON
+ SO_DEBUG
+ SO_DETACH_FILTER
+ SO_DGRAM_ERRIND
+ SO_DONTLINGER
+ SO_DONTROUTE
+ SO_ERROR
+ SO_FAMILY
+ SO_KEEPALIVE
+ SO_LINGER
+ SO_OOBINLINE
+ SO_PASSCRED
+ SO_PASSIFNAME
+ SO_PEERCRED
+ SO_PROTOCOL
+ SO_PROTOTYPE
+ SO_RCVBUF
+ SO_RCVLOWAT
+ SO_RCVTIMEO
+ SO_REUSEADDR
+ SO_REUSEPORT
+ SO_SECURITY_AUTHENTICATION
+ SO_SECURITY_ENCRYPTION_NETWORK
+ SO_SECURITY_ENCRYPTION_TRANSPORT
+ SO_SNDBUF
+ SO_SNDLOWAT
+ SO_SNDTIMEO
+ SO_STATE
+ SO_TYPE
+ SO_USELOOPBACK
+ SO_XOPEN
+ SO_XSE
+ UIO_MAXIOV
+);
+
+@EXPORT_OK = qw(CR LF CRLF $CR $LF $CRLF
+
+ inet_pton
+ inet_ntop
+
+ getaddrinfo
+ getnameinfo
+
+ pack_ipv6_mreq
+ unpack_ipv6_mreq
+
+ IN6ADDR_ANY IN6ADDR_LOOPBACK
+
+ AI_CANONNAME
+ AI_NUMERICHOST
+ AI_NUMERICSERV
+ AI_PASSIVE
+
+ EAI_ADDRFAMILY
+ EAI_AGAIN
+ EAI_BADFLAGS
+ EAI_FAIL
+ EAI_FAMILY
+ EAI_NODATA
+ EAI_NONAME
+ EAI_SERVICE
+ EAI_SOCKTYPE
+
+ IPPROTO_IP
+ IPPROTO_IPV6
+ IPPROTO_RAW
+ IPPROTO_ICMP
+ IPPROTO_TCP
+ IPPROTO_UDP
+
+ IPV6_ADD_MEMBERSHIP
+ IPV6_DROP_MEMBERSHIP
+ IPV6_MTU
+ IPV6_MTU_DISCOVER
+ IPV6_MULTICAST_HOPS
+ IPV6_MULTICAST_IF
+ IPV6_MULTICAST_LOOP
+ IPV6_UNICAST_HOPS
+ IPV6_V6ONLY
+
+ NI_DGRAM
+ NI_NAMEREQD
+ NI_NUMERICHOST
+ NI_NUMERICSERV
+
+ TCP_KEEPALIVE
+ TCP_MAXRT
+ TCP_MAXSEG
+ TCP_NODELAY
+ TCP_STDURG
+ TCP_CORK
+ TCP_KEEPIDLE
+ TCP_KEEPINTVL
+ TCP_KEEPCNT
+ TCP_SYNCNT
+ TCP_LINGER2
+ TCP_DEFER_ACCEPT
+ TCP_WINDOW_CLAMP
+ TCP_INFO
+ TCP_QUICKACK
+ TCP_CONGESTION
+ TCP_MD5SIG);
+
+%EXPORT_TAGS = (
+ crlf => [qw(CR LF CRLF $CR $LF $CRLF)],
+ all => [@EXPORT, @EXPORT_OK],
+);
+
+BEGIN {
+ sub CR () {"\015"}
+ sub LF () {"\012"}
+ sub CRLF () {"\015\012"}
+}
+
+*CR = \CR();
+*LF = \LF();
+*CRLF = \CRLF();
+
+sub sockaddr_in {
+ if (@_ == 6 && !wantarray) { # perl5.001m compat; use this && die
+ my($af, $port, @quad) = @_;
+ warnings::warn "6-ARG sockaddr_in call is deprecated"
+ if warnings::enabled();
+ pack_sockaddr_in($port, inet_aton(join('.', @quad)));
+ } elsif (wantarray) {
+ croak "usage: (port,iaddr) = sockaddr_in(sin_sv)" unless @_ == 1;
+ unpack_sockaddr_in(@_);
+ } else {
+ croak "usage: sin_sv = sockaddr_in(port,iaddr))" unless @_ == 2;
+ pack_sockaddr_in(@_);
+ }
+}
+
+sub sockaddr_in6 {
+ if (wantarray) {
+ croak "usage: (port,in6addr,scope_id,flowinfo) = sockaddr_in6(sin6_sv)" unless @_ == 1;
+ unpack_sockaddr_in6(@_);
+ }
+ else {
+ croak "usage: sin6_sv = sockaddr_in6(port,in6addr,[scope_id,[flowinfo]])" unless @_ >= 2 and @_ <= 4;
+ pack_sockaddr_in6(@_);
+ }
+}
+
+sub sockaddr_un {
+ if (wantarray) {
+ croak "usage: (filename) = sockaddr_un(sun_sv)" unless @_ == 1;
+ unpack_sockaddr_un(@_);
+ } else {
+ croak "usage: sun_sv = sockaddr_un(filename)" unless @_ == 1;
+ pack_sockaddr_un(@_);
+ }
+}
+
+XSLoader::load(__PACKAGE__, $VERSION);
+
+my %errstr;
+
+if( defined &getaddrinfo ) {
+ # These are not part of the API, nothing uses them, and deleting them
+ # reduces the size of %Socket:: by about 12K
+ delete $Socket::{fake_getaddrinfo};
+ delete $Socket::{fake_getnameinfo};
+} else {
+ require Scalar::Util;
+
+ *getaddrinfo = \&fake_getaddrinfo;
+ *getnameinfo = \&fake_getnameinfo;
+
+ # These numbers borrowed from GNU libc's implementation, but since
+ # they're only used by our emulation, it doesn't matter if the real
+ # platform's values differ
+ my %constants = (
+ AI_PASSIVE => 1,
+ AI_CANONNAME => 2,
+ AI_NUMERICHOST => 4,
+ # RFC 2553 doesn't define this but Linux does - lets be nice and
+ # provide it since we can
+ AI_NUMERICSERV => 1024,
+
+ EAI_BADFLAGS => -1,
+ EAI_NONAME => -2,
+ EAI_NODATA => -5,
+ EAI_FAMILY => -6,
+ EAI_SERVICE => -8,
+
+ NI_NUMERICHOST => 1,
+ NI_NUMERICSERV => 2,
+ NI_NAMEREQD => 8,
+ NI_DGRAM => 16,
+ );
+
+ foreach my $name ( keys %constants ) {
+ my $value = $constants{$name};
+
+ no strict 'refs';
+ defined &$name or *$name = sub () { $value };
+ }
+
+ %errstr = (
+ # These strings from RFC 2553
+ EAI_BADFLAGS() => "invalid value for ai_flags",
+ EAI_NONAME() => "nodename nor servname provided, or not known",
+ EAI_NODATA() => "no address associated with nodename",
+ EAI_FAMILY() => "ai_family not supported",
+ EAI_SERVICE() => "servname not supported for ai_socktype",
+ );
+}
+
+# The following functions are used if the system does not have a
+# getaddrinfo(3) function in libc; and are used to emulate it for the AF_INET
+# family
+
+# Borrowed from Regexp::Common::net
+my $REGEXP_IPv4_DECIMAL = qr/25[0-5]|2[0-4][0-9]|1?[0-9][0-9]{1,2}/;
+my $REGEXP_IPv4_DOTTEDQUAD = qr/$REGEXP_IPv4_DECIMAL\.$REGEXP_IPv4_DECIMAL\.$REGEXP_IPv4_DECIMAL\.$REGEXP_IPv4_DECIMAL/;
+
+sub fake_makeerr
+{
+ my ( $errno ) = @_;
+ my $errstr = $errno == 0 ? "" : ( $errstr{$errno} || $errno );
+ return Scalar::Util::dualvar( $errno, $errstr );
+}
+
+sub fake_getaddrinfo
+{
+ my ( $node, $service, $hints ) = @_;
+
+ $node = "" unless defined $node;
+
+ $service = "" unless defined $service;
+
+ my ( $family, $socktype, $protocol, $flags ) = @$hints{qw( family socktype protocol flags )};
+
+ $family ||= Socket::AF_INET(); # 0 == AF_UNSPEC, which we want too
+ $family == Socket::AF_INET() or return fake_makeerr( EAI_FAMILY() );
+
+ $socktype ||= 0;
+
+ $protocol ||= 0;
+
+ $flags ||= 0;
+
+ my $flag_passive = $flags & AI_PASSIVE(); $flags &= ~AI_PASSIVE();
+ my $flag_canonname = $flags & AI_CANONNAME(); $flags &= ~AI_CANONNAME();
+ my $flag_numerichost = $flags & AI_NUMERICHOST(); $flags &= ~AI_NUMERICHOST();
+ my $flag_numericserv = $flags & AI_NUMERICSERV(); $flags &= ~AI_NUMERICSERV();
+
+ $flags == 0 or return fake_makeerr( EAI_BADFLAGS() );
+
+ $node eq "" and $service eq "" and return fake_makeerr( EAI_NONAME() );
+
+ my $canonname;
+ my @addrs;
+ if( $node ne "" ) {
+ return fake_makeerr( EAI_NONAME() ) if( $flag_numerichost and $node !~ m/^$REGEXP_IPv4_DOTTEDQUAD$/ );
+ ( $canonname, undef, undef, undef, @addrs ) = gethostbyname( $node );
+ defined $canonname or return fake_makeerr( EAI_NONAME() );
+
+ undef $canonname unless $flag_canonname;
+ }
+ else {
+ $addrs[0] = $flag_passive ? Socket::inet_aton( "0.0.0.0" )
+ : Socket::inet_aton( "127.0.0.1" );
+ }
+
+ my @ports; # Actually ARRAYrefs of [ socktype, protocol, port ]
+ my $protname = "";
+ if( $protocol ) {
+ $protname = getprotobynumber( $protocol );
+ }
+
+ if( $service ne "" and $service !~ m/^\d+$/ ) {
+ return fake_makeerr( EAI_NONAME() ) if( $flag_numericserv );
+ getservbyname( $service, $protname ) or return fake_makeerr( EAI_SERVICE() );
+ }
+
+ foreach my $this_socktype ( Socket::SOCK_STREAM(), Socket::SOCK_DGRAM(), Socket::SOCK_RAW() ) {
+ next if $socktype and $this_socktype != $socktype;
+
+ my $this_protname = "raw";
+ $this_socktype == Socket::SOCK_STREAM() and $this_protname = "tcp";
+ $this_socktype == Socket::SOCK_DGRAM() and $this_protname = "udp";
+
+ next if $protname and $this_protname ne $protname;
+
+ my $port;
+ if( $service ne "" ) {
+ if( $service =~ m/^\d+$/ ) {
+ $port = "$service";
+ }
+ else {
+ ( undef, undef, $port, $this_protname ) = getservbyname( $service, $this_protname );
+ next unless defined $port;
+ }
+ }
+ else {
+ $port = 0;
+ }
+
+ push @ports, [ $this_socktype, scalar getprotobyname( $this_protname ) || 0, $port ];
+ }
+
+ my @ret;
+ foreach my $addr ( @addrs ) {
+ foreach my $portspec ( @ports ) {
+ my ( $socktype, $protocol, $port ) = @$portspec;
+ push @ret, {
+ family => $family,
+ socktype => $socktype,
+ protocol => $protocol,
+ addr => Socket::pack_sockaddr_in( $port, $addr ),
+ canonname => undef,
+ };
+ }
+ }
+
+ # Only supply canonname for the first result
+ if( defined $canonname ) {
+ $ret[0]->{canonname} = $canonname;
+ }
+
+ return ( fake_makeerr( 0 ), @ret );
+}
+
+sub fake_getnameinfo
+{
+ my ( $addr, $flags ) = @_;
+
+ my ( $port, $inetaddr );
+ eval { ( $port, $inetaddr ) = Socket::unpack_sockaddr_in( $addr ) }
+ or return fake_makeerr( EAI_FAMILY() );
+
+ my $family = Socket::AF_INET();
+
+ $flags ||= 0;
+
+ my $flag_numerichost = $flags & NI_NUMERICHOST(); $flags &= ~NI_NUMERICHOST();
+ my $flag_numericserv = $flags & NI_NUMERICSERV(); $flags &= ~NI_NUMERICSERV();
+ my $flag_namereqd = $flags & NI_NAMEREQD(); $flags &= ~NI_NAMEREQD();
+ my $flag_dgram = $flags & NI_DGRAM() ; $flags &= ~NI_DGRAM();
+
+ $flags == 0 or return fake_makeerr( EAI_BADFLAGS() );
+
+ my $node;
+ if( $flag_numerichost ) {
+ $node = Socket::inet_ntoa( $inetaddr );
+ }
+ else {
+ $node = gethostbyaddr( $inetaddr, $family );
+ if( !defined $node ) {
+ return fake_makeerr( EAI_NONAME() ) if $flag_namereqd;
+ $node = Socket::inet_ntoa( $inetaddr );
+ }
+ }
+
+ my $service;
+ if( $flag_numericserv ) {
+ $service = "$port";
+ }
+ else {
+ my $protname = $flag_dgram ? "udp" : "";
+ $service = getservbyport( $port, $protname );
+ if( !defined $service ) {
+ $service = "$port";
+ }
+ }
+
+ return ( fake_makeerr( 0 ), $node, $service );
+}
+
+1;
diff --git a/cpan/Socket/Socket.xs b/cpan/Socket/Socket.xs
new file mode 100644
index 0000000000..f571ac7e71
--- /dev/null
+++ b/cpan/Socket/Socket.xs
@@ -0,0 +1,851 @@
+#define PERL_NO_GET_CONTEXT
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include <stddef.h>
+
+#ifdef I_SYS_TYPES
+# include <sys/types.h>
+#endif
+#if !defined(ultrix) /* Avoid double definition. */
+# include <sys/socket.h>
+#endif
+#if defined(USE_SOCKS) && defined(I_SOCKS)
+# include <socks.h>
+#endif
+#ifdef MPE
+# define PF_INET AF_INET
+# define PF_UNIX AF_UNIX
+# define SOCK_RAW 3
+#endif
+#ifdef I_SYS_UN
+# include <sys/un.h>
+#endif
+/* XXX Configure test for <netinet/in_systm.h needed XXX */
+#if defined(NeXT) || defined(__NeXT__)
+# include <netinet/in_systm.h>
+#endif
+#if defined(__sgi) && !defined(AF_LINK) && defined(PF_LINK) && PF_LINK == AF_LNK
+# undef PF_LINK
+#endif
+#if defined(I_NETINET_IN) || defined(__ultrix__)
+# include <netinet/in.h>
+#endif
+#ifdef I_NETDB
+# if !defined(ultrix) /* Avoid double definition. */
+# include <netdb.h>
+# endif
+#endif
+#ifdef I_ARPA_INET
+# include <arpa/inet.h>
+#endif
+#ifdef I_NETINET_TCP
+# include <netinet/tcp.h>
+#endif
+
+#ifdef NETWARE
+NETDB_DEFINE_CONTEXT
+NETINET_DEFINE_CONTEXT
+#endif
+
+#ifdef I_SYSUIO
+# include <sys/uio.h>
+#endif
+
+#ifndef AF_NBS
+# undef PF_NBS
+#endif
+
+#ifndef AF_X25
+# undef PF_X25
+#endif
+
+#ifndef INADDR_NONE
+# define INADDR_NONE 0xffffffff
+#endif /* INADDR_NONE */
+#ifndef INADDR_BROADCAST
+# define INADDR_BROADCAST 0xffffffff
+#endif /* INADDR_BROADCAST */
+#ifndef INADDR_LOOPBACK
+# define INADDR_LOOPBACK 0x7F000001
+#endif /* INADDR_LOOPBACK */
+
+#ifndef croak_sv
+# define croak_sv(sv) croak(SvPV_nolen(sv))
+#endif
+
+#ifndef HAS_INET_ATON
+
+/*
+ * Check whether "cp" is a valid ascii representation
+ * of an Internet address and convert to a binary address.
+ * Returns 1 if the address is valid, 0 if not.
+ * This replaces inet_addr, the return value from which
+ * cannot distinguish between failure and a local broadcast address.
+ */
+static int
+my_inet_aton(register const char *cp, struct in_addr *addr)
+{
+ dTHX;
+ register U32 val;
+ register int base;
+ register char c;
+ int nparts;
+ const char *s;
+ unsigned int parts[4];
+ register unsigned int *pp = parts;
+
+ if (!cp || !*cp)
+ return 0;
+ for (;;) {
+ /*
+ * Collect number up to ".".
+ * Values are specified as for C:
+ * 0x=hex, 0=octal, other=decimal.
+ */
+ val = 0; base = 10;
+ if (*cp == '0') {
+ if (*++cp == 'x' || *cp == 'X')
+ base = 16, cp++;
+ else
+ base = 8;
+ }
+ while ((c = *cp) != '\0') {
+ if (isDIGIT(c)) {
+ val = (val * base) + (c - '0');
+ cp++;
+ continue;
+ }
+ if (base == 16 && (s=strchr(PL_hexdigit,c))) {
+ val = (val << 4) +
+ ((s - PL_hexdigit) & 15);
+ cp++;
+ continue;
+ }
+ break;
+ }
+ if (*cp == '.') {
+ /*
+ * Internet format:
+ * a.b.c.d
+ * a.b.c (with c treated as 16-bits)
+ * a.b (with b treated as 24 bits)
+ */
+ if (pp >= parts + 3 || val > 0xff)
+ return 0;
+ *pp++ = val, cp++;
+ } else
+ break;
+ }
+ /*
+ * Check for trailing characters.
+ */
+ if (*cp && !isSPACE(*cp))
+ return 0;
+ /*
+ * Concoct the address according to
+ * the number of parts specified.
+ */
+ nparts = pp - parts + 1; /* force to an int for switch() */
+ switch (nparts) {
+
+ case 1: /* a -- 32 bits */
+ break;
+
+ case 2: /* a.b -- 8.24 bits */
+ if (val > 0xffffff)
+ return 0;
+ val |= parts[0] << 24;
+ break;
+
+ case 3: /* a.b.c -- 8.8.16 bits */
+ if (val > 0xffff)
+ return 0;
+ val |= (parts[0] << 24) | (parts[1] << 16);
+ break;
+
+ case 4: /* a.b.c.d -- 8.8.8.8 bits */
+ if (val > 0xff)
+ return 0;
+ val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+ break;
+ }
+ addr->s_addr = htonl(val);
+ return 1;
+}
+
+#undef inet_aton
+#define inet_aton my_inet_aton
+
+#endif /* ! HAS_INET_ATON */
+
+
+static int
+not_here(const char *s)
+{
+ croak("Socket::%s not implemented on this architecture", s);
+ return -1;
+}
+
+#define PERL_IN_ADDR_S_ADDR_SIZE 4
+
+/*
+* Bad assumptions possible here.
+*
+* Bad Assumption 1: struct in_addr has no other fields
+* than the s_addr (which is the field we care about
+* in here, really). However, we can be fed either 4-byte
+* addresses (from pack("N", ...), or va.b.c.d, or ...),
+* or full struct in_addrs (from e.g. pack_sockaddr_in()),
+* which may or may not be 4 bytes in size.
+*
+* Bad Assumption 2: the s_addr field is a simple type
+* (such as an int, u_int32_t). It can be a bit field,
+* in which case using & (address-of) on it or taking sizeof()
+* wouldn't go over too well. (Those are not attempted
+* now but in case someone thinks to change the below code
+* to use addr.s_addr instead of addr, you have been warned.)
+*
+* Bad Assumption 3: the s_addr is the first field in
+* an in_addr, or that its bytes are the first bytes in
+* an in_addr.
+*
+* These bad assumptions are wrong in UNICOS which has
+* struct in_addr { struct { u_long st_addr:32; } s_da };
+* #define s_addr s_da.st_addr
+* and u_long is 64 bits.
+*
+* --jhi */
+
+#include "const-c.inc"
+
+#ifdef HAS_GETADDRINFO
+static SV *err_to_SV(pTHX_ int err)
+{
+ SV *ret = sv_newmortal();
+ SvUPGRADE(ret, SVt_PVNV);
+
+ if(err) {
+ const char *error = gai_strerror(err);
+ sv_setpv(ret, error);
+ }
+ else {
+ sv_setpv(ret, "");
+ }
+
+ SvIV_set(ret, err); SvIOK_on(ret);
+
+ return ret;
+}
+
+static void xs_getaddrinfo(pTHX_ CV *cv)
+{
+ dVAR;
+ dXSARGS;
+
+ SV *host;
+ SV *service;
+ SV *hints;
+
+ char *hostname = NULL;
+ char *servicename = NULL;
+ STRLEN len;
+ struct addrinfo hints_s;
+ struct addrinfo *res;
+ struct addrinfo *res_iter;
+ int err;
+ int n_res;
+
+ if(items > 3)
+ croak_xs_usage(cv, "host, service, hints");
+
+ SP -= items;
+
+ if(items < 1)
+ host = &PL_sv_undef;
+ else
+ host = ST(0);
+
+ if(items < 2)
+ service = &PL_sv_undef;
+ else
+ service = ST(1);
+
+ if(items < 3)
+ hints = NULL;
+ else
+ hints = ST(2);
+
+ SvGETMAGIC(host);
+ if(SvOK(host)) {
+ hostname = SvPV_nomg(host, len);
+ if (!len)
+ hostname = NULL;
+ }
+
+ SvGETMAGIC(service);
+ if(SvOK(service)) {
+ servicename = SvPV_nomg(service, len);
+ if (!len)
+ servicename = NULL;
+ }
+
+ Zero(&hints_s, sizeof hints_s, char);
+ hints_s.ai_family = PF_UNSPEC;
+
+ if(hints && SvOK(hints)) {
+ HV *hintshash;
+ SV **valp;
+
+ if(!SvROK(hints) || SvTYPE(SvRV(hints)) != SVt_PVHV)
+ croak("hints is not a HASH reference");
+
+ hintshash = (HV*)SvRV(hints);
+
+ if((valp = hv_fetch(hintshash, "flags", 5, 0)) != NULL)
+ hints_s.ai_flags = SvIV(*valp);
+ if((valp = hv_fetch(hintshash, "family", 6, 0)) != NULL)
+ hints_s.ai_family = SvIV(*valp);
+ if((valp = hv_fetch(hintshash, "socktype", 8, 0)) != NULL)
+ hints_s.ai_socktype = SvIV(*valp);
+ if((valp = hv_fetch(hintshash, "protocol", 8, 0)) != NULL)
+ hints_s.ai_protocol = SvIV(*valp);
+ }
+
+ err = getaddrinfo(hostname, servicename, &hints_s, &res);
+
+ XPUSHs(err_to_SV(aTHX_ err));
+
+ if(err)
+ XSRETURN(1);
+
+ n_res = 0;
+ for(res_iter = res; res_iter; res_iter = res_iter->ai_next) {
+ HV *res_hv = newHV();
+
+ (void)hv_stores(res_hv, "family", newSViv(res_iter->ai_family));
+ (void)hv_stores(res_hv, "socktype", newSViv(res_iter->ai_socktype));
+ (void)hv_stores(res_hv, "protocol", newSViv(res_iter->ai_protocol));
+
+ (void)hv_stores(res_hv, "addr", newSVpvn((char*)res_iter->ai_addr, res_iter->ai_addrlen));
+
+ if(res_iter->ai_canonname)
+ (void)hv_stores(res_hv, "canonname", newSVpv(res_iter->ai_canonname, 0));
+ else
+ (void)hv_stores(res_hv, "canonname", newSV(0));
+
+ XPUSHs(sv_2mortal(newRV_noinc((SV*)res_hv)));
+ n_res++;
+ }
+
+ freeaddrinfo(res);
+
+ XSRETURN(1 + n_res);
+}
+#endif
+
+#ifdef HAS_GETNAMEINFO
+static void xs_getnameinfo(pTHX_ CV *cv)
+{
+ dVAR;
+ dXSARGS;
+
+ SV *addr;
+ int flags;
+
+ char host[1024];
+ char serv[256];
+ char *sa; /* we'll cast to struct sockaddr * when necessary */
+ STRLEN addr_len;
+ int err;
+
+ if(items < 1 || items > 2)
+ croak_xs_usage(cv, "addr, flags=0");
+
+ SP -= items;
+
+ addr = ST(0);
+
+ if(items < 2)
+ flags = 0;
+ else
+ flags = SvIV(ST(1));
+
+ if(!SvPOK(addr))
+ croak("addr is not a string");
+
+ addr_len = SvCUR(addr);
+
+ /* We need to ensure the sockaddr is aligned, because a random SvPV might
+ * not be due to SvOOK */
+ Newx(sa, addr_len, char);
+ Copy(SvPV_nolen(addr), sa, addr_len, char);
+#ifdef HAS_SOCKADDR_SA_LEN
+ ((struct sockaddr *)sa)->sa_len = addr_len;
+#endif
+
+ err = getnameinfo((struct sockaddr *)sa, addr_len,
+ host, sizeof(host),
+ serv, sizeof(serv),
+ flags);
+
+ Safefree(sa);
+
+ XPUSHs(err_to_SV(aTHX_ err));
+
+ if(err)
+ XSRETURN(1);
+
+ XPUSHs(sv_2mortal(newSVpv(host, 0)));
+ XPUSHs(sv_2mortal(newSVpv(serv, 0)));
+
+ XSRETURN(3);
+}
+#endif
+
+MODULE = Socket PACKAGE = Socket
+
+INCLUDE: const-xs.inc
+
+BOOT:
+#ifdef HAS_GETADDRINFO
+ newXS("Socket::getaddrinfo", xs_getaddrinfo, __FILE__);
+#endif
+#ifdef HAS_GETNAMEINFO
+ newXS("Socket::getnameinfo", xs_getnameinfo, __FILE__);
+#endif
+
+void
+inet_aton(host)
+ char * host
+ CODE:
+ {
+ struct in_addr ip_address;
+ struct hostent * phe;
+
+ if ((*host != '\0') && inet_aton(host, &ip_address)) {
+ ST(0) = newSVpvn_flags((char *)&ip_address, sizeof ip_address, SVs_TEMP);
+ XSRETURN(1);
+ }
+
+ phe = gethostbyname(host);
+ if (phe && phe->h_addrtype == AF_INET && phe->h_length == 4) {
+ ST(0) = newSVpvn_flags((char *)phe->h_addr, phe->h_length, SVs_TEMP);
+ XSRETURN(1);
+ }
+
+ XSRETURN_UNDEF;
+ }
+
+void
+inet_ntoa(ip_address_sv)
+ SV * ip_address_sv
+ CODE:
+ {
+ STRLEN addrlen;
+ struct in_addr addr;
+ char * ip_address;
+ if (DO_UTF8(ip_address_sv) && !sv_utf8_downgrade(ip_address_sv, 1))
+ croak("Wide character in %s", "Socket::inet_ntoa");
+ ip_address = SvPVbyte(ip_address_sv, addrlen);
+ if (addrlen == sizeof(addr) || addrlen == 4)
+ addr.s_addr =
+ (ip_address[0] & 0xFF) << 24 |
+ (ip_address[1] & 0xFF) << 16 |
+ (ip_address[2] & 0xFF) << 8 |
+ (ip_address[3] & 0xFF);
+ else
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::inet_ntoa",
+ addrlen, sizeof(addr));
+ /* We could use inet_ntoa() but that is broken
+ * in HP-UX + GCC + 64bitint (returns "0.0.0.0"),
+ * so let's use this sprintf() workaround everywhere.
+ * This is also more threadsafe than using inet_ntoa(). */
+ ST(0) = sv_2mortal(Perl_newSVpvf(aTHX_ "%d.%d.%d.%d", /* IPv6? */
+ ((addr.s_addr >> 24) & 0xFF),
+ ((addr.s_addr >> 16) & 0xFF),
+ ((addr.s_addr >> 8) & 0xFF),
+ ( addr.s_addr & 0xFF)));
+ }
+
+void
+sockaddr_family(sockaddr)
+ SV * sockaddr
+ PREINIT:
+ STRLEN sockaddr_len;
+ char *sockaddr_pv = SvPVbyte(sockaddr, sockaddr_len);
+ CODE:
+ if (sockaddr_len < offsetof(struct sockaddr, sa_data)) {
+ croak("Bad arg length for %s, length is %d, should be at least %d",
+ "Socket::sockaddr_family", sockaddr_len,
+ offsetof(struct sockaddr, sa_data));
+ }
+ ST(0) = sv_2mortal(newSViv(((struct sockaddr*)sockaddr_pv)->sa_family));
+
+void
+pack_sockaddr_un(pathname)
+ SV * pathname
+ CODE:
+ {
+#ifdef I_SYS_UN
+ struct sockaddr_un sun_ad; /* fear using sun */
+ STRLEN len;
+ char * pathname_pv;
+ int addr_len;
+
+ Zero( &sun_ad, sizeof sun_ad, char );
+ sun_ad.sun_family = AF_UNIX;
+ pathname_pv = SvPV(pathname,len);
+ if (len > sizeof(sun_ad.sun_path))
+ len = sizeof(sun_ad.sun_path);
+# ifdef OS2 /* Name should start with \socket\ and contain backslashes! */
+ {
+ int off;
+ char *s, *e;
+
+ if (pathname_pv[0] != '/' && pathname_pv[0] != '\\')
+ croak("Relative UNIX domain socket name '%s' unsupported",
+ pathname_pv);
+ else if (len < 8
+ || pathname_pv[7] != '/' && pathname_pv[7] != '\\'
+ || !strnicmp(pathname_pv + 1, "socket", 6))
+ off = 7;
+ else
+ off = 0; /* Preserve names starting with \socket\ */
+ Copy( "\\socket", sun_ad.sun_path, off, char);
+ Copy( pathname_pv, sun_ad.sun_path + off, len, char );
+
+ s = sun_ad.sun_path + off - 1;
+ e = s + len + 1;
+ while (++s < e)
+ if (*s = '/')
+ *s = '\\';
+ }
+# else /* !( defined OS2 ) */
+ Copy( pathname_pv, sun_ad.sun_path, len, char );
+# endif
+ if (0) not_here("dummy");
+ if (len > 1 && sun_ad.sun_path[0] == '\0') {
+ /* Linux-style abstract-namespace socket.
+ * The name is not a file name, but an array of arbitrary
+ * character, starting with \0 and possibly including \0s,
+ * therefore the length of the structure must denote the
+ * end of that character array */
+ addr_len = (char *)&(sun_ad.sun_path) - (char *)&sun_ad + len;
+ } else {
+ addr_len = sizeof sun_ad;
+ }
+# ifdef HAS_SOCKADDR_SA_LEN
+ sun_ad.sun_len = addr_len;
+# endif
+ ST(0) = newSVpvn_flags((char *)&sun_ad, addr_len, SVs_TEMP);
+#else
+ ST(0) = (SV *) not_here("pack_sockaddr_un");
+#endif
+
+ }
+
+void
+unpack_sockaddr_un(sun_sv)
+ SV * sun_sv
+ CODE:
+ {
+#ifdef I_SYS_UN
+ struct sockaddr_un addr;
+ STRLEN sockaddrlen;
+ char * sun_ad = SvPVbyte(sun_sv,sockaddrlen);
+ int addr_len;
+# ifndef __linux__
+ /* On Linux sockaddrlen on sockets returned by accept, recvfrom,
+ getpeername and getsockname is not equal to sizeof(addr). */
+ if (sockaddrlen != sizeof(addr)) {
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::unpack_sockaddr_un",
+ sockaddrlen, sizeof(addr));
+ }
+# endif
+
+ Copy( sun_ad, &addr, sizeof addr, char );
+
+ if ( addr.sun_family != AF_UNIX ) {
+ croak("Bad address family for %s, got %d, should be %d",
+ "Socket::unpack_sockaddr_un",
+ addr.sun_family,
+ AF_UNIX);
+ }
+
+ if (addr.sun_path[0] == '\0') {
+ /* Linux-style abstract socket address begins with a nul
+ * and can contain nuls. */
+ addr_len = (char *)&addr - (char *)&(addr.sun_path) + sockaddrlen;
+ } else {
+ for (addr_len = 0; addr.sun_path[addr_len]
+ && addr_len < (int)sizeof(addr.sun_path); addr_len++);
+ }
+
+ ST(0) = newSVpvn_flags(addr.sun_path, addr_len, SVs_TEMP);
+#else
+ ST(0) = (SV *) not_here("unpack_sockaddr_un");
+#endif
+ }
+
+void
+pack_sockaddr_in(port, ip_address_sv)
+ unsigned short port
+ SV * ip_address_sv
+ CODE:
+ {
+ struct sockaddr_in sin;
+ struct in_addr addr;
+ STRLEN addrlen;
+ char * ip_address;
+ if (DO_UTF8(ip_address_sv) && !sv_utf8_downgrade(ip_address_sv, 1))
+ croak("Wide character in %s", "Socket::pack_sockaddr_in");
+ ip_address = SvPVbyte(ip_address_sv, addrlen);
+ if (addrlen == sizeof(addr) || addrlen == 4)
+ addr.s_addr =
+ (ip_address[0] & 0xFF) << 24 |
+ (ip_address[1] & 0xFF) << 16 |
+ (ip_address[2] & 0xFF) << 8 |
+ (ip_address[3] & 0xFF);
+ else
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::pack_sockaddr_in",
+ addrlen, sizeof(addr));
+ Zero( &sin, sizeof sin, char );
+ sin.sin_family = AF_INET;
+ sin.sin_port = htons(port);
+ sin.sin_addr.s_addr = htonl(addr.s_addr);
+# ifdef HAS_SOCKADDR_SA_LEN
+ sin.sin_len = sizeof (sin);
+# endif
+ ST(0) = newSVpvn_flags((char *)&sin, sizeof (sin), SVs_TEMP);
+ }
+
+void
+unpack_sockaddr_in(sin_sv)
+ SV * sin_sv
+ PPCODE:
+ {
+ STRLEN sockaddrlen;
+ struct sockaddr_in addr;
+ unsigned short port;
+ struct in_addr ip_address;
+ char * sin = SvPVbyte(sin_sv,sockaddrlen);
+ if (sockaddrlen != sizeof(addr)) {
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::unpack_sockaddr_in",
+ sockaddrlen, sizeof(addr));
+ }
+ Copy( sin, &addr,sizeof addr, char );
+ if ( addr.sin_family != AF_INET ) {
+ croak("Bad address family for %s, got %d, should be %d",
+ "Socket::unpack_sockaddr_in",
+ addr.sin_family,
+ AF_INET);
+ }
+ port = ntohs(addr.sin_port);
+ ip_address = addr.sin_addr;
+
+ EXTEND(SP, 2);
+ PUSHs(sv_2mortal(newSViv((IV) port)));
+ PUSHs(newSVpvn_flags((char *)&ip_address, sizeof(ip_address), SVs_TEMP));
+ }
+
+void
+pack_sockaddr_in6(port, sin6_addr, scope_id=0, flowinfo=0)
+ unsigned short port
+ SV * sin6_addr
+ unsigned long scope_id
+ unsigned long flowinfo
+ CODE:
+ {
+#ifdef AF_INET6
+ struct sockaddr_in6 sin6;
+ char * addrbytes;
+ STRLEN addrlen;
+ if (DO_UTF8(sin6_addr) && !sv_utf8_downgrade(sin6_addr, 1))
+ croak("Wide character in %s", "Socket::pack_sockaddr_in6");
+ addrbytes = SvPVbyte(sin6_addr, addrlen);
+ if(addrlen != sizeof(sin6.sin6_addr))
+ croak("Bad arg length %s, length is %d, should be %d",
+ "Socket::pack_sockaddr_in6", addrlen, sizeof(sin6.sin6_addr));
+ Zero(&sin6, sizeof(sin6), char);
+ sin6.sin6_family = AF_INET6;
+ sin6.sin6_port = htons(port);
+ sin6.sin6_flowinfo = htonl(flowinfo);
+ Copy(addrbytes, &sin6.sin6_addr, sizeof(sin6.sin6_addr), char);
+# ifdef HAS_SIN6_SCOPE_ID
+ sin6.sin6_scope_id = scope_id;
+# else
+ if(scope_id != 0)
+ warn("%s cannot represent non-zero scope_id %d",
+ "Socket::pack_sockaddr_in6", scope_id);
+# endif
+# ifdef HAS_SOCKADDR_SA_LEN
+ sin6.sin6_len = sizeof(sin6);
+# endif
+ ST(0) = newSVpvn_flags((char *)&sin6, sizeof(sin6), SVs_TEMP);
+#else
+ ST(0) = (SV*)not_here("pack_sockaddr_in6");
+#endif
+ }
+
+void
+unpack_sockaddr_in6(sin6_sv)
+ SV * sin6_sv
+ PPCODE:
+ {
+#ifdef AF_INET6
+ STRLEN addrlen;
+ struct sockaddr_in6 sin6;
+ char * addrbytes = SvPVbyte(sin6_sv, addrlen);
+ if (addrlen != sizeof(sin6))
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::unpack_sockaddr_in6",
+ addrlen, sizeof(sin6));
+ Copy(addrbytes, &sin6, sizeof(sin6), char);
+ if(sin6.sin6_family != AF_INET6)
+ croak("Bad address family for %s, got %d, should be %d",
+ "Socket::unpack_sockaddr_in6",
+ sin6.sin6_family, AF_INET6);
+ EXTEND(SP, 4);
+ mPUSHi(ntohs(sin6.sin6_port));
+ mPUSHp((char *)&sin6.sin6_addr, sizeof(sin6.sin6_addr));
+# ifdef HAS_SIN6_SCOPE_ID
+ mPUSHi(sin6.sin6_scope_id);
+# else
+ mPUSHi(0);
+# endif
+ mPUSHi(ntohl(sin6.sin6_flowinfo));
+#else
+ ST(0) = (SV*)not_here("pack_sockaddr_in6");
+#endif
+ }
+
+void
+inet_ntop(af, ip_address_sv)
+ int af
+ SV * ip_address_sv
+ CODE:
+#ifdef HAS_INETNTOP
+ STRLEN addrlen, struct_size;
+#ifdef AF_INET6
+ struct in6_addr addr;
+ char str[INET6_ADDRSTRLEN];
+#else
+ struct in_addr addr;
+ char str[INET_ADDRSTRLEN];
+#endif
+ char *ip_address = SvPV(ip_address_sv, addrlen);
+
+ struct_size = sizeof(addr);
+
+ if(af != AF_INET
+#ifdef AF_INET6
+ && af != AF_INET6
+#endif
+ ) {
+ croak("Bad address family for %s, got %d, should be"
+#ifdef AF_INET6
+ " either AF_INET or AF_INET6",
+#else
+ " AF_INET",
+#endif
+ "Socket::inet_ntop",
+ af);
+ }
+
+ Copy( ip_address, &addr, sizeof addr, char );
+ inet_ntop(af, &addr, str, sizeof str);
+
+ ST(0) = newSVpvn_flags(str, strlen(str), SVs_TEMP);
+#else
+ ST(0) = (SV *)not_here("inet_ntop");
+#endif
+
+void
+inet_pton(af, host)
+ int af
+ const char * host
+ CODE:
+#ifdef HAS_INETPTON
+ int ok;
+#ifdef AF_INET6
+ struct in6_addr ip_address;
+#else
+ struct in_addr ip_address;
+#endif
+
+ if(af != AF_INET
+#ifdef AF_INET6
+ && af != AF_INET6
+#endif
+ ) {
+ croak("Bad address family for %s, got %d, should be"
+#ifdef AF_INET6
+ " either AF_INET or AF_INET6",
+#else
+ " AF_INET",
+#endif
+ "Socket::inet_pton",
+ af);
+ }
+ ok = (*host != '\0') && inet_pton(af, host, &ip_address);
+
+ ST(0) = sv_newmortal();
+ if (ok) {
+ sv_setpvn( ST(0), (char *)&ip_address, sizeof(ip_address) );
+ }
+#else
+ ST(0) = (SV *)not_here("inet_pton");
+#endif
+
+void
+pack_ipv6_mreq(addr, interface)
+ SV * addr
+ unsigned int interface
+ CODE:
+ {
+#ifdef AF_INET6
+ struct ipv6_mreq mreq;
+ char * addrbytes;
+ STRLEN addrlen;
+ if (DO_UTF8(addr) && !sv_utf8_downgrade(addr, 1))
+ croak("Wide character in %s", "Socket::pack_ipv6_mreq");
+ addrbytes = SvPVbyte(addr, addrlen);
+ if(addrlen != sizeof(mreq.ipv6mr_multiaddr))
+ croak("Bad arg length %s, length is %d, should be %d",
+ "Socket::pack_ipv6_mreq", addrlen, sizeof(mreq.ipv6mr_multiaddr));
+ Zero(&mreq, sizeof(mreq), char);
+ Copy(addrbytes, &mreq.ipv6mr_multiaddr, sizeof(mreq.ipv6mr_multiaddr), char);
+ mreq.ipv6mr_interface = interface;
+ ST(0) = newSVpvn_flags((char *)&mreq, sizeof(mreq), SVs_TEMP);
+#else
+ ST(0) = (SV*)not_here("pack_ipv6_mreq");
+#endif
+ }
+
+void
+unpack_ipv6_mreq(mreq_sv)
+ SV * mreq_sv
+ PPCODE:
+ {
+#ifdef AF_INET6
+ struct ipv6_mreq mreq;
+ STRLEN mreqlen;
+ char * mreqbytes = SvPVbyte(mreq_sv, mreqlen);
+ if (mreqlen != sizeof(mreq))
+ croak("Bad arg length for %s, length is %d, should be %d",
+ "Socket::unpack_ipv6_mreq",
+ mreqlen, sizeof(mreq));
+ Copy(mreqbytes, &mreq, sizeof(mreq), char);
+ EXTEND(SP, 2);
+ mPUSHp((char *)&mreq.ipv6mr_multiaddr, sizeof(mreq.ipv6mr_multiaddr));
+ mPUSHi(mreq.ipv6mr_interface);
+#else
+ not_here("unpack_ipv6_mreq");
+#endif
+ }
diff --git a/cpan/Socket/t/Socket.t b/cpan/Socket/t/Socket.t
new file mode 100644
index 0000000000..f59c265c4c
--- /dev/null
+++ b/cpan/Socket/t/Socket.t
@@ -0,0 +1,184 @@
+#!./perl
+
+BEGIN {
+ require Config; import Config;
+ if ($Config{'extensions'} !~ /\bSocket\b/ &&
+ !(($^O eq 'VMS') && $Config{d_socket})) {
+ print "1..0\n";
+ exit 0;
+ }
+ $has_alarm = $Config{d_alarm};
+}
+
+use Socket qw(:all);
+use Test::More tests => 26;
+
+$has_echo = $^O ne 'MSWin32';
+$alarmed = 0;
+sub arm { $alarmed = 0; alarm(shift) if $has_alarm }
+sub alarmed { $alarmed = 1 }
+$SIG{ALRM} = 'alarmed' if $has_alarm;
+
+SKIP: {
+ unless(socket(T, PF_INET, SOCK_STREAM, IPPROTO_TCP)) {
+ skip "No PF_INET", 3;
+ }
+
+ pass "socket(PF_INET)";
+
+ arm(5);
+ my $host = $^O eq 'MacOS' || ($^O eq 'irix' && $Config{osvers} == 5) ?
+ '127.0.0.1' : 'localhost';
+ my $localhost = inet_aton($host);
+
+ SKIP: {
+ unless($has_echo && defined $localhost && connect(T,pack_sockaddr_in(7,$localhost))) {
+ skip "Unable to connect to localhost:7", 2;
+ }
+
+ arm(0);
+
+ pass "PF_INET echo localhost connected";
+
+ diag "Connected to " .
+ inet_ntoa((unpack_sockaddr_in(getpeername(T)))[1])."\n";
+
+ arm(5);
+ syswrite(T,"hello",5);
+ arm(0);
+
+ arm(5);
+ $read = sysread(T,$buff,10); # Connection may be granted, then closed!
+ arm(0);
+
+ while ($read > 0 && length($buff) < 5) {
+ # adjust for fact that TCP doesn't guarantee size of reads/writes
+ arm(5);
+ $read = sysread(T,$buff,10,length($buff));
+ arm(0);
+ }
+
+ is(($read == 0 || $buff eq "hello"), "PF_INET echo localhost reply");
+ }
+}
+
+SKIP: {
+ unless(socket(S, PF_INET, SOCK_STREAM, IPPROTO_TCP)) {
+ skip "No PF_INET", 3;
+ }
+
+ pass "socket(PF_INET)";
+
+ SKIP: {
+ arm(5);
+ unless($has_echo && connect(S,pack_sockaddr_in(7,INADDR_LOOPBACK))) {
+ skip "Unable to connect to localhost:7", 2;
+ }
+
+ arm(0);
+
+ pass "PF_INET echo INADDR_LOOPBACK connected";
+
+ diag "Connected to " .
+ inet_ntoa((unpack_sockaddr_in(getpeername(S)))[1])."\n";
+
+ arm(5);
+ syswrite(S,"olleh",5);
+ arm(0);
+
+ arm(5);
+ $read = sysread(S,$buff,10); # Connection may be granted, then closed!
+ arm(0);
+
+ while ($read > 0 && length($buff) < 5) {
+ # adjust for fact that TCP doesn't guarantee size of reads/writes
+ arm(5);
+ $read = sysread(S,$buff,10,length($buff));
+ arm(0);
+ }
+
+ is(($read == 0 || $buff eq "olleh"), "PF_INET echo INADDR_LOOPBACK reply");
+ }
+}
+
+# warnings
+{
+ my $w = 0;
+ local $SIG{__WARN__} = sub {
+ ++ $w if $_[0] =~ /^6-ARG sockaddr_in call is deprecated/ ;
+ };
+
+ no warnings 'Socket';
+ sockaddr_in(1,2,3,4,5,6) ;
+ is($w, 0, "sockaddr_in deprecated form doesn't warn without lexical warnings");
+
+ use warnings 'Socket';
+ sockaddr_in(1,2,3,4,5,6) ;
+ is($w, 1, "sockaddr_in deprecated form warns with lexical warnings");
+}
+
+# Test that whatever we give into pack/unpack_sockaddr retains
+# the value thru the entire chain.
+is(inet_ntoa((unpack_sockaddr_in(pack_sockaddr_in(100,inet_aton("10.250.230.10"))))[1]), '10.250.230.10',
+ 'inet_aton->pack_sockaddr_in->unpack_sockaddr_in->inet_ntoa roundtrip');
+
+is(inet_ntoa(inet_aton("10.20.30.40")), "10.20.30.40", 'inet_aton->inet_ntoa roundtrip');
+is(inet_ntoa(v10.20.30.40), "10.20.30.40", 'inet_ntoa from v-string');
+
+{
+ my ($port,$addr) = unpack_sockaddr_in(pack_sockaddr_in(100,v10.10.10.10));
+ is($port, 100, 'pack_sockaddr_in->unpack_sockaddr_in port');
+ is(inet_ntoa($addr), "10.10.10.10", 'pack_sockaddr_in->unpack_sockaddr_in addr');
+}
+
+{
+ local $@;
+ eval { inet_ntoa(v10.20.30.400) };
+ like($@, qr/^Wide character in Socket::inet_ntoa at/, 'inet_ntoa warns about wide characters');
+}
+
+is(sockaddr_family(pack_sockaddr_in(100,inet_aton("10.250.230.10"))), AF_INET, 'pack_sockaddr_in->sockaddr_family');
+
+{
+ local $@;
+ eval { sockaddr_family("") };
+ like($@, qr/^Bad arg length for Socket::sockaddr_family, length is 0, should be at least \d+/, 'sockaddr_family warns about argument length');
+}
+
+SKIP: {
+ # see if we can handle abstract sockets
+ skip "Abstract AF_UNIX paths unsupported", 2 unless $^O eq "linux";
+
+ my $test_abstract_socket = chr(0) . '/org/perl/hello'. chr(0) . 'world';
+ my $addr = sockaddr_un ($test_abstract_socket);
+ my ($path) = sockaddr_un ($addr);
+ is($path, $test_abstract_socket, 'sockaddr_un can handle abstract AF_UNIX paths');
+
+ # see if we calculate the address structure length correctly
+ is(length ($test_abstract_socket) + 2, length $addr, 'sockaddr_un abstract address length');
+}
+
+SKIP: {
+ skip "No inet_ntop", 3 unless $Config{d_inetntop} && $Config{d_inetaton};
+
+ is(inet_ntop(AF_INET, inet_pton(AF_INET, "10.20.30.40")), "10.20.30.40", 'inet_pton->inet_ntop AF_INET roundtrip');
+ is(inet_ntop(AF_INET, inet_aton("10.20.30.40")), "10.20.30.40", 'inet_aton->inet_ntop AF_INET roundtrip');
+
+ SKIP: {
+ skip "No AF_INET6", 1 unless defined eval { AF_INET6() };
+ is(lc inet_ntop(AF_INET6, inet_pton(AF_INET6, "2001:503:BA3E::2:30")), "2001:503:ba3e::2:30", 'inet_pton->inet_ntop AF_INET6 roundtrip');
+ }
+}
+
+SKIP: {
+ skip "No AF_INET6", 5 unless defined eval { AF_INET6() };
+
+ my $sin6 = pack_sockaddr_in6(0x1234, "0123456789abcdef", 0, 89);
+
+ is(sockaddr_family($sin6), AF_INET6, 'sockaddr_family of pack_sockaddr_in6');
+
+ is((unpack_sockaddr_in6($sin6))[0], 0x1234, 'pack_sockaddr_in6->unpack_sockaddr_in6 port');
+ is((unpack_sockaddr_in6($sin6))[1], "0123456789abcdef", 'pack_sockaddr_in6->unpack_sockaddr_in6 addr');
+ is((unpack_sockaddr_in6($sin6))[2], 0, 'pack_sockaddr_in6->unpack_sockaddr_in6 scope_id');
+ is((unpack_sockaddr_in6($sin6))[3], 89, 'pack_sockaddr_in6->unpack_sockaddr_in6 flowinfo');
+}
diff --git a/cpan/Socket/t/getaddrinfo.t b/cpan/Socket/t/getaddrinfo.t
new file mode 100644
index 0000000000..b85af38254
--- /dev/null
+++ b/cpan/Socket/t/getaddrinfo.t
@@ -0,0 +1,125 @@
+use strict;
+use warnings;
+use Test::More tests => 30;
+
+use Socket qw(
+ AI_NUMERICHOST AF_INET SOCK_STREAM IPPROTO_TCP
+ unpack_sockaddr_in inet_aton getaddrinfo
+);
+
+my ( $err, @res );
+
+( $err, @res ) = getaddrinfo( "127.0.0.1", "80", { socktype => SOCK_STREAM } );
+cmp_ok( $err, "==", 0, '$err == 0 for host=127.0.0.1/service=80/socktype=STREAM' );
+cmp_ok( $err, "eq", "", '$err eq "" for host=127.0.0.1/service=80/socktype=STREAM' );
+is( scalar @res, 1,
+ '@res has 1 result' );
+
+is( $res[0]->{family}, AF_INET,
+ '$res[0] family is AF_INET' );
+is( $res[0]->{socktype}, SOCK_STREAM,
+ '$res[0] socktype is SOCK_STREAM' );
+ok( $res[0]->{protocol} == 0 || $res[0]->{protocol} == IPPROTO_TCP,
+ '$res[0] protocol is 0 or IPPROTO_TCP' );
+ok( defined $res[0]->{addr},
+ '$res[0] addr is defined' );
+if (length $res[0]->{addr}) {
+ is_deeply( [ unpack_sockaddr_in $res[0]->{addr} ],
+ [ 80, inet_aton( "127.0.0.1" ) ],
+ '$res[0] addr is {"127.0.0.1", 80}' );
+} else {
+ fail( '$res[0] addr is empty: check $socksizetype' );
+}
+
+# Check actual IV integers work just as well as PV strings
+( $err, @res ) = getaddrinfo( "127.0.0.1", 80, { socktype => SOCK_STREAM } );
+cmp_ok( $err, "==", 0, '$err == 0 for host=127.0.0.1/service=80/socktype=STREAM' );
+is_deeply( [ unpack_sockaddr_in $res[0]->{addr} ],
+ [ 80, inet_aton( "127.0.0.1" ) ],
+ '$res[0] addr is {"127.0.0.1", 80}' );
+
+( $err, @res ) = getaddrinfo( "127.0.0.1", "" );
+cmp_ok( $err, "==", 0, '$err == 0 for host=127.0.0.1' );
+# Might get more than one; e.g. different socktypes
+ok( scalar @res > 0, '@res has results' );
+
+( $err, @res ) = getaddrinfo( "127.0.0.1", undef );
+cmp_ok( $err, "==", 0, '$err == 0 for host=127.0.0.1/service=undef' );
+
+# Test GETMAGIC
+{
+ "127.0.0.1" =~ /(.+)/;
+ ( $err, @res ) = getaddrinfo($1, undef);
+ cmp_ok( $err, "==", 0, '$err == 0 for host=$1' );
+ ok( scalar @res > 0, '@res has results' );
+ is( (unpack_sockaddr_in $res[0]->{addr})[1],
+ inet_aton( "127.0.0.1" ),
+ '$res[0] addr is {"127.0.0.1", ??}' );
+}
+
+( $err, @res ) = getaddrinfo( "", "80", { family => AF_INET, socktype => SOCK_STREAM } );
+cmp_ok( $err, "==", 0, '$err == 0 for service=80/family=AF_INET/socktype=STREAM' );
+is( scalar @res, 1, '@res has 1 result' );
+
+# Just pick the first one
+is( $res[0]->{family}, AF_INET,
+ '$res[0] family is AF_INET' );
+is( $res[0]->{socktype}, SOCK_STREAM,
+ '$res[0] socktype is SOCK_STREAM' );
+ok( $res[0]->{protocol} == 0 || $res[0]->{protocol} == IPPROTO_TCP,
+ '$res[0] protocol is 0 or IPPROTO_TCP' );
+
+# Now some tests of a few well-known internet hosts
+my $goodhost = "cpan.perl.org";
+
+SKIP: {
+ skip "Resolver has no answer for $goodhost", 2 unless gethostbyname( $goodhost );
+
+ ( $err, @res ) = getaddrinfo( "cpan.perl.org", "ftp", { socktype => SOCK_STREAM } );
+ cmp_ok( $err, "==", 0, '$err == 0 for host=cpan.perl.org/service=ftp/socktype=STREAM' );
+ # Might get more than one; e.g. different families
+ ok( scalar @res > 0, '@res has results' );
+}
+
+# Now something I hope doesn't exist - we put it in a known-missing TLD
+my $missinghost = "TbK4jM2M0OS.lm57DWIyu4i";
+
+# Some CPAN testing machines seem to have wildcard DNS servers that reply to
+# any request. We'd better check for them
+
+SKIP: {
+ skip "Resolver has an answer for $missinghost", 1 if gethostbyname( $missinghost );
+
+ # Some OSes return $err == 0 but no results
+ ( $err, @res ) = getaddrinfo( $missinghost, "ftp", { socktype => SOCK_STREAM } );
+ ok( $err != 0 || ( $err == 0 && @res == 0 ),
+ '$err != 0 or @res == 0 for host=TbK4jM2M0OS.lm57DWIyu4i/service=ftp/socktype=SOCK_STREAM' );
+ if( @res ) {
+ # Diagnostic that might help
+ while( my $r = shift @res ) {
+ diag( "family=$r->{family} socktype=$r->{socktype} protocol=$r->{protocol} addr=[" . length( $r->{addr} ) . " bytes]" );
+ diag( " addr=" . join( ", ", map { sprintf '0x%02x', ord $_ } split m//, $r->{addr} ) );
+ }
+ }
+}
+
+# Now check that names with AI_NUMERICHOST fail
+
+( $err, @res ) = getaddrinfo( "localhost", "ftp", { flags => AI_NUMERICHOST, socktype => SOCK_STREAM } );
+ok( $err != 0, '$err != 0 for host=localhost/service=ftp/flags=AI_NUMERICHOST/socktype=SOCK_STREAM' );
+
+# Some sanity checking on the hints hash
+ok( defined eval { getaddrinfo( "127.0.0.1", "80", undef ); 1 },
+ 'getaddrinfo() with undef hints works' );
+ok( !defined eval { getaddrinfo( "127.0.0.1", "80", "hints" ); 1 },
+ 'getaddrinfo() with string hints dies' );
+ok( !defined eval { getaddrinfo( "127.0.0.1", "80", [] ); 1 },
+ 'getaddrinfo() with ARRAY hints dies' );
+
+# Ensure it doesn't segfault if args are missing
+
+( $err, @res ) = getaddrinfo();
+ok( defined $err, '$err defined for getaddrinfo()' );
+
+( $err, @res ) = getaddrinfo( "127.0.0.1" );
+ok( defined $err, '$err defined for getaddrinfo("127.0.0.1")' );
diff --git a/cpan/Socket/t/getnameinfo.t b/cpan/Socket/t/getnameinfo.t
new file mode 100644
index 0000000000..803e8c0c57
--- /dev/null
+++ b/cpan/Socket/t/getnameinfo.t
@@ -0,0 +1,37 @@
+use strict;
+use warnings;
+use Test::More tests => 10;
+
+use Socket qw(
+ AF_INET NI_NUMERICHOST NI_NUMERICSERV
+ getnameinfo pack_sockaddr_in inet_aton
+);
+
+my ( $err, $host, $service );
+
+( $err, $host, $service ) = getnameinfo( pack_sockaddr_in( 80, inet_aton( "127.0.0.1" ) ), NI_NUMERICHOST|NI_NUMERICSERV );
+cmp_ok( $err, "==", 0, '$err == 0 for {family=AF_INET,port=80,sinaddr=127.0.0.1}/NI_NUMERICHOST|NI_NUMERICSERV' );
+cmp_ok( $err, "eq", "", '$err eq "" for {family=AF_INET,port=80,sinaddr=127.0.0.1}/NI_NUMERICHOST|NI_NUMERICSERV' );
+
+is( $host, "127.0.0.1", '$host is 127.0.0.1 for NH/NS' );
+is( $service, "80", '$service is 80 for NH/NS' );
+
+# Probably "localhost" but we'd better ask the system to be sure
+my $expect_host = gethostbyaddr( inet_aton( "127.0.0.1" ), AF_INET );
+defined $expect_host or $expect_host = "127.0.0.1";
+
+( $err, $host, $service ) = getnameinfo( pack_sockaddr_in( 80, inet_aton( "127.0.0.1" ) ), NI_NUMERICSERV );
+cmp_ok( $err, "==", 0, '$err == 0 for {family=AF_INET,port=80,sinaddr=127.0.0.1}/NI_NUMERICSERV' );
+
+is( $host, $expect_host, "\$host is $expect_host for NS" );
+is( $service, "80", '$service is 80 for NS' );
+
+# Probably "www" but we'd better ask the system to be sure
+my $expect_service = getservbyport( 80, "tcp" );
+defined $expect_service or $expect_service = "80";
+
+( $err, $host, $service ) = getnameinfo( pack_sockaddr_in( 80, inet_aton( "127.0.0.1" ) ), NI_NUMERICHOST );
+cmp_ok( $err, "==", 0, '$err == 0 for {family=AF_INET,port=80,sinaddr=127.0.0.1}/NI_NUMERICHOST' );
+
+is( $host, "127.0.0.1", '$host is 127.0.0.1 for NH' );
+is( $service, $expect_service, "\$service is $expect_service for NH" );
diff --git a/cpan/Socket/t/ipv6_mreq.t b/cpan/Socket/t/ipv6_mreq.t
new file mode 100644
index 0000000000..43fb8f804b
--- /dev/null
+++ b/cpan/Socket/t/ipv6_mreq.t
@@ -0,0 +1,26 @@
+use strict;
+use warnings;
+use Test::More;
+
+use Socket qw(
+ pack_ipv6_mreq unpack_ipv6_mreq
+);
+
+# Check that pack/unpack_ipv6_mreq either croak with "Not implemented", or
+# roundtrip as identity
+
+my $packed;
+eval {
+ $packed = pack_ipv6_mreq "ANADDRESSIN16CHR", 123;
+};
+if( !defined $packed ) {
+ plan skip_all => "No pack_ipv6_mreq" if $@ =~ m/ not implemented /;
+ die $@;
+}
+
+plan tests => 2;
+
+my @unpacked = unpack_ipv6_mreq $packed;
+
+is( $unpacked[0], "ANADDRESSIN16CHR", 'unpack_ipv6_mreq multiaddr' );
+is( $unpacked[1], 123, 'unpack_ipv6_mreq ifindex' );
diff --git a/cpan/Socket/t/socketpair.t b/cpan/Socket/t/socketpair.t
new file mode 100644
index 0000000000..997628c3bd
--- /dev/null
+++ b/cpan/Socket/t/socketpair.t
@@ -0,0 +1,245 @@
+#!./perl -w
+
+my $child;
+my $can_fork;
+my $has_perlio;
+
+BEGIN {
+ require Config; import Config;
+ $can_fork = $Config{'d_fork'} || $Config{'d_pseudofork'};
+
+ if ($^O eq "hpux" or $Config{'extensions'} !~ /\bSocket\b/ &&
+ !(($^O eq 'VMS') && $Config{d_socket})) {
+ print "1..0\n";
+ exit 0;
+ }
+}
+
+{
+ # This was in the BEGIN block, but since Test::More 0.47 added support to
+ # detect forking, we don't need to fork before Test::More initialises.
+
+ # Too many things in this test will hang forever if something is wrong,
+ # so we need a self destruct timer. And IO can hang despite an alarm.
+
+ if( $can_fork) {
+ my $parent = $$;
+ $child = fork;
+ die "Fork failed" unless defined $child;
+ if (!$child) {
+ $SIG{INT} = sub {exit 0}; # You have 60 seconds. Your time starts now.
+ my $must_finish_by = time + 60;
+ my $remaining;
+ while (($remaining = $must_finish_by - time) > 0) {
+ sleep $remaining;
+ }
+ warn "Something unexpectedly hung during testing";
+ kill "INT", $parent or die "Kill failed: $!";
+ exit 1;
+ }
+ }
+ unless ($has_perlio = find PerlIO::Layer 'perlio') {
+ print <<EOF;
+# Since you don't have perlio you might get failures with UTF-8 locales.
+EOF
+ }
+}
+
+use Socket;
+use Test::More;
+use strict;
+use warnings;
+use Errno;
+
+my $skip_reason;
+
+if( !$Config{d_alarm} ) {
+ plan skip_all => "alarm() not implemented on this platform";
+} elsif( !$can_fork ) {
+ plan skip_all => "fork() not implemented on this platform";
+} else {
+ # This should fail but not die if there is real socketpair
+ eval {socketpair LEFT, RIGHT, -1, -1, -1};
+ if ($@ =~ /^Unsupported socket function "socketpair" called/ ||
+ $! =~ /^The operation requested is not supported./) { # Stratus VOS
+ plan skip_all => 'No socketpair (real or emulated)';
+ } else {
+ eval {AF_UNIX};
+ if ($@ =~ /^Your vendor has not defined Socket macro AF_UNIX/) {
+ plan skip_all => 'No AF_UNIX';
+ } else {
+ plan tests => 45;
+ }
+ }
+}
+
+# But we'll install an alarm handler in case any of the races below fail.
+$SIG{ALRM} = sub {die "Unexpected alarm during testing"};
+
+ok (socketpair (LEFT, RIGHT, AF_UNIX, SOCK_STREAM, PF_UNSPEC),
+ "socketpair (LEFT, RIGHT, AF_UNIX, SOCK_STREAM, PF_UNSPEC)")
+ or print "# \$\! = $!\n";
+
+if ($has_perlio) {
+ binmode(LEFT, ":bytes");
+ binmode(RIGHT, ":bytes");
+}
+
+my @left = ("hello ", "world\n");
+my @right = ("perl ", "rules!"); # Not like I'm trying to bias any survey here.
+
+foreach (@left) {
+ # is (syswrite (LEFT, $_), length $_, "write " . _qq ($_) . " to left");
+ is (syswrite (LEFT, $_), length $_, "syswrite to left");
+}
+foreach (@right) {
+ # is (syswrite (RIGHT, $_), length $_, "write " . _qq ($_) . " to right");
+ is (syswrite (RIGHT, $_), length $_, "syswrite to right");
+}
+
+# stream socket, so our writes will become joined:
+my ($buffer, $expect);
+$expect = join '', @right;
+undef $buffer;
+is (read (LEFT, $buffer, length $expect), length $expect, "read on left");
+is ($buffer, $expect, "content what we expected?");
+$expect = join '', @left;
+undef $buffer;
+is (read (RIGHT, $buffer, length $expect), length $expect, "read on right");
+is ($buffer, $expect, "content what we expected?");
+
+ok (shutdown(LEFT, SHUT_WR), "shutdown left for writing");
+# This will hang forever if eof is buggy, and alarm doesn't interrupt system
+# Calls. Hence the child process minder.
+SKIP: {
+ skip "SCO Unixware / OSR have a bug with shutdown",2 if $^O =~ /^(?:svr|sco)/;
+ local $SIG{ALRM} = sub { warn "EOF on right took over 3 seconds" };
+ local $TODO = "Known problems with unix sockets on $^O"
+ if $^O eq 'hpux' || $^O eq 'super-ux';
+ alarm 3;
+ $! = 0;
+ ok (eof RIGHT, "right is at EOF");
+ local $TODO = "Known problems with unix sockets on $^O"
+ if $^O eq 'unicos' || $^O eq 'unicosmk';
+ is ($!, '', 'and $! should report no error');
+ alarm 60;
+}
+
+my $err = $!;
+$SIG{PIPE} = 'IGNORE';
+{
+ local $SIG{ALRM}
+ = sub { warn "syswrite to left didn't fail within 3 seconds" };
+ alarm 3;
+ # Split the system call from the is() - is() does IO so
+ # (say) a flush may do a seek which on a pipe may disturb errno
+ my $ans = syswrite (LEFT, "void");
+ $err = $!;
+ is ($ans, undef, "syswrite to shutdown left should fail");
+ alarm 60;
+}
+{
+ # This may need skipping on some OSes - restoring value saved above
+ # should help
+ $! = $err;
+ ok (($!{EPIPE} or $!{ESHUTDOWN}), '$! should be EPIPE or ESHUTDOWN')
+ or printf "\$\!=%d(%s)\n", $err, $err;
+}
+
+my @gripping = (chr 255, chr 127);
+foreach (@gripping) {
+ is (syswrite (RIGHT, $_), length $_, "syswrite to right");
+}
+
+ok (!eof LEFT, "left is not at EOF");
+
+$expect = join '', @gripping;
+undef $buffer;
+is (read (LEFT, $buffer, length $expect), length $expect, "read on left");
+is ($buffer, $expect, "content what we expected?");
+
+ok (close LEFT, "close left");
+ok (close RIGHT, "close right");
+
+
+# And now datagrams
+# I suspect we also need a self destruct time-bomb for these, as I don't see any
+# guarantee that the stack won't drop a UDP packet, even if it is for localhost.
+
+SKIP: {
+ skip "No usable SOCK_DGRAM for socketpair", 24 if ($^O =~ /^(MSWin32|os2)\z/);
+ local $TODO = "socketpair not supported on $^O" if $^O eq 'nto';
+
+ok (socketpair (LEFT, RIGHT, AF_UNIX, SOCK_DGRAM, PF_UNSPEC),
+ "socketpair (LEFT, RIGHT, AF_UNIX, SOCK_DGRAM, PF_UNSPEC)")
+ or print "# \$\! = $!\n";
+
+if ($has_perlio) {
+ binmode(LEFT, ":bytes");
+ binmode(RIGHT, ":bytes");
+}
+
+foreach (@left) {
+ # is (syswrite (LEFT, $_), length $_, "write " . _qq ($_) . " to left");
+ is (syswrite (LEFT, $_), length $_, "syswrite to left");
+}
+foreach (@right) {
+ # is (syswrite (RIGHT, $_), length $_, "write " . _qq ($_) . " to right");
+ is (syswrite (RIGHT, $_), length $_, "syswrite to right");
+}
+
+# stream socket, so our writes will become joined:
+my ($total);
+$total = join '', @right;
+foreach $expect (@right) {
+ undef $buffer;
+ is (sysread (LEFT, $buffer, length $total), length $expect, "read on left");
+ is ($buffer, $expect, "content what we expected?");
+}
+$total = join '', @left;
+foreach $expect (@left) {
+ undef $buffer;
+ is (sysread (RIGHT, $buffer, length $total), length $expect, "read on right");
+ is ($buffer, $expect, "content what we expected?");
+}
+
+ok (shutdown(LEFT, 1), "shutdown left for writing");
+
+# eof uses buffering. eof is indicated by a sysread of zero.
+# but for a datagram socket there's no way it can know nothing will ever be
+# sent
+SKIP: {
+ skip "$^O does length 0 udp reads", 2 if ($^O eq 'os390');
+
+ my $alarmed = 0;
+ local $SIG{ALRM} = sub { $alarmed = 1; };
+ print "# Approximate forever as 3 seconds. Wait 'forever'...\n";
+ alarm 3;
+ undef $buffer;
+ is (sysread (RIGHT, $buffer, 1), undef,
+ "read on right should be interrupted");
+ is ($alarmed, 1, "alarm should have fired");
+}
+
+alarm 30;
+
+#ok (eof RIGHT, "right is at EOF");
+
+foreach (@gripping) {
+ is (syswrite (RIGHT, $_), length $_, "syswrite to right");
+}
+
+$total = join '', @gripping;
+foreach $expect (@gripping) {
+ undef $buffer;
+ is (sysread (LEFT, $buffer, length $total), length $expect, "read on left");
+ is ($buffer, $expect, "content what we expected?");
+}
+
+ok (close LEFT, "close left");
+ok (close RIGHT, "close right");
+
+} # end of DGRAM SKIP
+
+kill "INT", $child or warn "Failed to kill child process $child: $!";
+exit 0;
View Lorry Controller Status