diff options
Diffstat (limited to 'jni/ruby/test/socket/test_socket.rb')
-rw-r--r-- | jni/ruby/test/socket/test_socket.rb | 654 |
1 files changed, 654 insertions, 0 deletions
diff --git a/jni/ruby/test/socket/test_socket.rb b/jni/ruby/test/socket/test_socket.rb new file mode 100644 index 0000000..1db0ea2 --- /dev/null +++ b/jni/ruby/test/socket/test_socket.rb @@ -0,0 +1,654 @@ +begin + require "socket" + require "tmpdir" + require "fcntl" + require "etc" + require "test/unit" +rescue LoadError +end + +class TestSocket < Test::Unit::TestCase + def test_socket_new + begin + s = Socket.new(:INET, :STREAM) + assert_kind_of(Socket, s) + ensure + s.close + end + end + + def test_socket_new_cloexec + return unless defined? Fcntl::FD_CLOEXEC + begin + s = Socket.new(:INET, :STREAM) + assert(s.close_on_exec?) + ensure + s.close + end + end + + def test_unpack_sockaddr + sockaddr_in = Socket.sockaddr_in(80, "") + assert_raise(ArgumentError) { Socket.unpack_sockaddr_un(sockaddr_in) } + sockaddr_un = Socket.sockaddr_un("/testdir/s") + assert_raise(ArgumentError) { Socket.unpack_sockaddr_in(sockaddr_un) } + assert_raise(ArgumentError) { Socket.unpack_sockaddr_in("") } + assert_raise(ArgumentError) { Socket.unpack_sockaddr_un("") } + end if Socket.respond_to?(:sockaddr_un) + + def test_sysaccept + serv = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0) + serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) + serv.listen 5 + c = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0) + c.connect(serv.getsockname) + fd, peeraddr = serv.sysaccept + assert_equal(c.getsockname, peeraddr.to_sockaddr) + ensure + serv.close if serv + c.close if c + IO.for_fd(fd).close if fd + end + + def test_initialize + Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0) {|s| + s.bind(Socket.sockaddr_in(0, "127.0.0.1")) + addr = s.getsockname + assert_nothing_raised { Socket.unpack_sockaddr_in(addr) } + assert_raise(ArgumentError, NoMethodError) { Socket.unpack_sockaddr_un(addr) } + } + Socket.open("AF_INET", "SOCK_STREAM", 0) {|s| + s.bind(Socket.sockaddr_in(0, "127.0.0.1")) + addr = s.getsockname + assert_nothing_raised { Socket.unpack_sockaddr_in(addr) } + assert_raise(ArgumentError, NoMethodError) { Socket.unpack_sockaddr_un(addr) } + } + Socket.open(:AF_INET, :SOCK_STREAM, 0) {|s| + s.bind(Socket.sockaddr_in(0, "127.0.0.1")) + addr = s.getsockname + assert_nothing_raised { Socket.unpack_sockaddr_in(addr) } + assert_raise(ArgumentError, NoMethodError) { Socket.unpack_sockaddr_un(addr) } + } + end + + def test_bind + Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0) {|bound| + bound.bind(Socket.sockaddr_in(0, "127.0.0.1")) + addr = bound.getsockname + port, = Socket.unpack_sockaddr_in(addr) + + Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0) {|s| + e = assert_raises(Errno::EADDRINUSE) do + s.bind(Socket.sockaddr_in(port, "127.0.0.1")) + end + + assert_match "bind(2) for 127.0.0.1:#{port}", e.message + } + } + end + + def test_getaddrinfo + # This should not send a DNS query because AF_UNIX. + assert_raise(SocketError) { Socket.getaddrinfo("www.kame.net", 80, "AF_UNIX") } + end + + def test_getaddrinfo_raises_no_errors_on_port_argument_of_0 # [ruby-core:29427] + assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', 0, Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) } + assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', '0', Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) } + assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', '00', Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) } + assert_raise(SocketError, '[ruby-core:29427]'){ Socket.getaddrinfo(nil, nil, Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) } + assert_nothing_raised('[ruby-core:29427]'){ TCPServer.open('localhost', 0) {} } + end + + + def test_getnameinfo + assert_raise(SocketError) { Socket.getnameinfo(["AF_UNIX", 80, "0.0.0.0"]) } + end + + def test_ip_address_list + begin + list = Socket.ip_address_list + rescue NotImplementedError + return + end + list.each {|ai| + assert_instance_of(Addrinfo, ai) + assert(ai.ip?) + } + end + + def test_tcp + TCPServer.open(0) {|serv| + addr = serv.connect_address + addr.connect {|s1| + s2 = serv.accept + begin + assert_equal(s2.remote_address.ip_unpack, s1.local_address.ip_unpack) + ensure + s2.close + end + } + } + end + + def test_tcp_cloexec + return unless defined? Fcntl::FD_CLOEXEC + TCPServer.open(0) {|serv| + addr = serv.connect_address + addr.connect {|s1| + s2 = serv.accept + begin + assert(s2.close_on_exec?) + ensure + s2.close + end + } + + } + end + + def random_port + # IANA suggests dynamic port for 49152 to 65535 + # http://www.iana.org/assignments/port-numbers + 49152 + rand(65535-49152+1) + end + + def errors_addrinuse + [Errno::EADDRINUSE] + end + + def test_tcp_server_sockets + port = random_port + begin + sockets = Socket.tcp_server_sockets(port) + rescue *errors_addrinuse + return # not test failure + end + begin + sockets.each {|s| + assert_equal(port, s.local_address.ip_port) + } + ensure + sockets.each {|s| + s.close + } + end + end + + def test_tcp_server_sockets_port0 + sockets = Socket.tcp_server_sockets(0) + ports = sockets.map {|s| s.local_address.ip_port } + the_port = ports.first + ports.each {|port| + assert_equal(the_port, port) + } + ensure + if sockets + sockets.each {|s| + s.close + } + end + end + + if defined? UNIXSocket + def test_unix + Dir.mktmpdir {|tmpdir| + path = "#{tmpdir}/sock" + UNIXServer.open(path) {|serv| + Socket.unix(path) {|s1| + s2 = serv.accept + begin + s2raddr = s2.remote_address + s1laddr = s1.local_address + assert(s2raddr.to_sockaddr.empty? || + s1laddr.to_sockaddr.empty? || + s2raddr.unix_path == s1laddr.unix_path) + assert(s2.close_on_exec?) + ensure + s2.close + end + } + } + } + end + + def test_unix_server_socket + Dir.mktmpdir {|tmpdir| + path = "#{tmpdir}/sock" + 2.times { + serv = Socket.unix_server_socket(path) + begin + assert_kind_of(Socket, serv) + assert(File.socket?(path)) + assert_equal(path, serv.local_address.unix_path) + ensure + serv.close + end + } + } + end + + def test_accept_loop_with_unix + Dir.mktmpdir {|tmpdir| + tcp_servers = [] + clients = [] + accepted = [] + begin + tcp_servers = Socket.tcp_server_sockets(0) + unix_server = Socket.unix_server_socket("#{tmpdir}/sock") + tcp_servers.each {|s| + addr = s.connect_address + assert_nothing_raised("connect to #{addr.inspect}") { + clients << addr.connect + } + } + addr = unix_server.connect_address + assert_nothing_raised("connect to #{addr.inspect}") { + clients << addr.connect + } + Socket.accept_loop(tcp_servers, unix_server) {|s| + accepted << s + break if clients.length == accepted.length + } + assert_equal(clients.length, accepted.length) + ensure + tcp_servers.each {|s| s.close if !s.closed? } + unix_server.close if unix_server && !unix_server.closed? + clients.each {|s| s.close if !s.closed? } + accepted.each {|s| s.close if !s.closed? } + end + } + end + end + + def test_accept_loop + servers = [] + begin + servers = Socket.tcp_server_sockets(0) + port = servers[0].local_address.ip_port + Socket.tcp("localhost", port) {|s1| + Socket.accept_loop(servers) {|s2, client_ai| + begin + assert_equal(s1.local_address.ip_unpack, client_ai.ip_unpack) + ensure + s2.close + end + break + } + } + ensure + servers.each {|s| s.close if !s.closed? } + end + end + + def test_accept_loop_multi_port + servers = [] + begin + servers = Socket.tcp_server_sockets(0) + port = servers[0].local_address.ip_port + servers2 = Socket.tcp_server_sockets(0) + servers.concat servers2 + port2 = servers2[0].local_address.ip_port + + Socket.tcp("localhost", port) {|s1| + Socket.accept_loop(servers) {|s2, client_ai| + begin + assert_equal(s1.local_address.ip_unpack, client_ai.ip_unpack) + ensure + s2.close + end + break + } + } + Socket.tcp("localhost", port2) {|s1| + Socket.accept_loop(servers) {|s2, client_ai| + begin + assert_equal(s1.local_address.ip_unpack, client_ai.ip_unpack) + ensure + s2.close + end + break + } + } + ensure + servers.each {|s| s.close if !s.closed? } + end + end + + def test_udp_server + begin + ifaddrs = Socket.getifaddrs + rescue NotImplementedError + skip "Socket.getifaddrs not implemented" + end + + ifconfig = nil + Socket.udp_server_sockets(0) {|sockets| + famlies = {} + sockets.each {|s| famlies[s.local_address.afamily] = s } + nd6 = {} + ifaddrs.reject! {|ifa| + ai = ifa.addr + next true unless ai + s = famlies[ai.afamily] + next true unless s + next true if ai.ipv6_linklocal? # IPv6 link-local address is too troublesome in this test. + case RUBY_PLATFORM + when /linux/ + if ai.ip_address.include?('%') and + (Etc.uname[:release][/[0-9.]+/].split('.').map(&:to_i) <=> [2,6,18]) <= 0 + # Cent OS 5.6 (2.6.18-238.19.1.el5xen) doesn't correctly work + # sendmsg with pktinfo for link-local ipv6 addresses + next true + end + when /freebsd/ + if ifa.addr.ipv6_linklocal? + # FreeBSD 9.0 with default setting (ipv6_activate_all_interfaces + # is not YES) sets IFDISABLED to interfaces which don't have + # global IPv6 address. + # Link-local IPv6 addresses on those interfaces don't work. + ulSIOCGIFINFO_IN6 = 3225971052 + ulND6_IFF_IFDISABLED = 8 + in6_ondireq = ifa.name + s.ioctl(ulSIOCGIFINFO_IN6, in6_ondireq) + flag = in6_ondireq.unpack('A16L6').last + next true if flag & ulND6_IFF_IFDISABLED != 0 + nd6[ai] = flag + end + when /darwin/ + if !ai.ipv6? + elsif ai.ipv6_unique_local? && /darwin1[01]\./ =~ RUBY_PLATFORM + next true # iCloud addresses do not work, see Bug #6692 + elsif ifr_name = ai.ip_address[/%(.*)/, 1] + # Mac OS X may sets IFDISABLED as FreeBSD does + ulSIOCGIFFLAGS = 3223349521 + ulSIOCGIFINFO_IN6 = 3224398156 + ulIFF_POINTOPOINT = 0x10 + ulND6_IFF_IFDISABLED = 8 + in6_ondireq = ifr_name + s.ioctl(ulSIOCGIFINFO_IN6, in6_ondireq) + flag = in6_ondireq.unpack('A16L6').last + next true if (flag & ulND6_IFF_IFDISABLED) != 0 + nd6[ai] = flag + in6_ifreq = [ifr_name,ai.to_sockaddr].pack('a16A*') + s.ioctl(ulSIOCGIFFLAGS, in6_ifreq) + next true if in6_ifreq.unpack('A16L1').last & ulIFF_POINTOPOINT != 0 + else + ifconfig ||= `/sbin/ifconfig` + next true if ifconfig.scan(/^(\w+):(.*(?:\n\t.*)*)/).find do|ifname, value| + value.include?(ai.ip_address) && value.include?('POINTOPOINT') + end + end + end + false + } + skipped = false + begin + port = sockets.first.local_address.ip_port + + ping_p = false + th = Thread.new { + Socket.udp_server_loop_on(sockets) {|msg, msg_src| + break if msg == "exit" + rmsg = Marshal.dump([msg, msg_src.remote_address, msg_src.local_address]) + ping_p = true + msg_src.reply rmsg + } + } + + ifaddrs.each {|ifa| + ai = ifa.addr + Addrinfo.udp(ai.ip_address, port).connect {|s| + ping_p = false + msg1 = "<<<#{ai.inspect}>>>" + s.sendmsg msg1 + unless IO.select([s], nil, nil, 10) + nd6options = nd6.key?(ai) ? "nd6=%x " % nd6[ai] : '' + raise "no response from #{ifa.inspect} #{nd6options}ping=#{ping_p}" + end + msg2, addr = s.recvmsg + msg2, _, _ = Marshal.load(msg2) + assert_equal(msg1, msg2) + assert_equal(ai.ip_address, addr.ip_address) + } + } + rescue NotImplementedError, Errno::ENOSYS + skipped = true + skip "need sendmsg and recvmsg: #{$!}" + ensure + if th + if skipped + Thread.kill th unless th.join(10) + else + Addrinfo.udp("127.0.0.1", port).connect {|s| s.sendmsg "exit" } + unless th.join(10) + Thread.kill th + th.join(10) + raise "thread killed" + end + end + end + end + } + end + + def test_linger + opt = Socket::Option.linger(true, 0) + assert_equal([true, 0], opt.linger) + Addrinfo.tcp("127.0.0.1", 0).listen {|serv| + serv.local_address.connect {|s1| + s2, _ = serv.accept + begin + s1.setsockopt(opt) + s1.close + assert_raise(Errno::ECONNRESET) { s2.read } + ensure + s2.close + end + } + } + end + + def test_timestamp + return if /linux|freebsd|netbsd|openbsd|solaris|darwin/ !~ RUBY_PLATFORM + return if !defined?(Socket::AncillaryData) + t1 = Time.now.strftime("%Y-%m-%d") + stamp = nil + Addrinfo.udp("127.0.0.1", 0).bind {|s1| + Addrinfo.udp("127.0.0.1", 0).bind {|s2| + s1.setsockopt(:SOCKET, :TIMESTAMP, true) + s2.send "a", 0, s1.local_address + msg, _, _, stamp = s1.recvmsg + assert_equal("a", msg) + assert(stamp.cmsg_is?(:SOCKET, :TIMESTAMP)) + } + } + t2 = Time.now.strftime("%Y-%m-%d") + pat = Regexp.union([t1, t2].uniq) + assert_match(pat, stamp.inspect) + t = stamp.timestamp + assert_match(pat, t.strftime("%Y-%m-%d")) + pat = /\.#{"%06d" % t.usec}/ + assert_match(pat, stamp.inspect) + end + + def test_timestampns + return if /linux/ !~ RUBY_PLATFORM || !defined?(Socket::SO_TIMESTAMPNS) + t1 = Time.now.strftime("%Y-%m-%d") + stamp = nil + Addrinfo.udp("127.0.0.1", 0).bind {|s1| + Addrinfo.udp("127.0.0.1", 0).bind {|s2| + begin + s1.setsockopt(:SOCKET, :TIMESTAMPNS, true) + rescue Errno::ENOPROTOOPT + # SO_TIMESTAMPNS is available since Linux 2.6.22 + return + end + s2.send "a", 0, s1.local_address + msg, _, _, stamp = s1.recvmsg + assert_equal("a", msg) + assert(stamp.cmsg_is?(:SOCKET, :TIMESTAMPNS)) + } + } + t2 = Time.now.strftime("%Y-%m-%d") + pat = Regexp.union([t1, t2].uniq) + assert_match(pat, stamp.inspect) + t = stamp.timestamp + assert_match(pat, t.strftime("%Y-%m-%d")) + pat = /\.#{"%09d" % t.nsec}/ + assert_match(pat, stamp.inspect) + end + + def test_bintime + return if /freebsd/ !~ RUBY_PLATFORM + t1 = Time.now.strftime("%Y-%m-%d") + stamp = nil + Addrinfo.udp("127.0.0.1", 0).bind {|s1| + Addrinfo.udp("127.0.0.1", 0).bind {|s2| + s1.setsockopt(:SOCKET, :BINTIME, true) + s2.send "a", 0, s1.local_address + msg, _, _, stamp = s1.recvmsg + assert_equal("a", msg) + assert(stamp.cmsg_is?(:SOCKET, :BINTIME)) + } + } + t2 = Time.now.strftime("%Y-%m-%d") + pat = Regexp.union([t1, t2].uniq) + assert_match(pat, stamp.inspect) + t = stamp.timestamp + assert_match(pat, t.strftime("%Y-%m-%d")) + assert_equal(stamp.data[-8,8].unpack("Q")[0], t.subsec * 2**64) + end + + def test_closed_read + require 'timeout' + require 'socket' + bug4390 = '[ruby-core:35203]' + server = TCPServer.new("localhost", 0) + serv_thread = Thread.new {server.accept} + begin sleep(0.1) end until serv_thread.stop? + sock = TCPSocket.new("localhost", server.addr[1]) + client_thread = Thread.new do + sock.readline + end + begin sleep(0.1) end until client_thread.stop? + Timeout.timeout(1) do + sock.close + sock = nil + assert_raise(IOError, bug4390) {client_thread.join} + end + ensure + serv_thread.value.close + server.close + end + + def test_connect_timeout + host = "127.0.0.1" + server = TCPServer.new(host, 0) + port = server.addr[1] + serv_thread = Thread.new {server.accept} + sock = Socket.tcp(host, port, :connect_timeout => 30) + accepted = serv_thread.value + assert_kind_of TCPSocket, accepted + assert_equal sock, IO.select(nil, [ sock ])[1][0], "not writable" + sock.close + + # some platforms may not timeout when the listener queue overflows, + # but we know Linux does with the default listen backlog of SOMAXCONN for + # TCPServer. + assert_raises(Errno::ETIMEDOUT) do + (Socket::SOMAXCONN*2).times do |i| + sock = Socket.tcp(host, port, :connect_timeout => 0) + assert_equal sock, IO.select(nil, [ sock ])[1][0], + "not writable (#{i})" + sock.close + end + end if RUBY_PLATFORM =~ /linux/ + ensure + server.close + accepted.close if accepted + sock.close if sock && ! sock.closed? + end + + def test_getifaddrs + begin + list = Socket.getifaddrs + rescue NotImplementedError + return + end + list.each {|ifaddr| + assert_instance_of(Socket::Ifaddr, ifaddr) + } + end + + def test_connect_in_rescue + serv = Addrinfo.tcp(nil, 0).listen + addr = serv.connect_address + begin + raise "dummy error" + rescue + s = addr.connect + assert(!s.closed?) + end + ensure + serv.close if serv && !serv.closed? + s.close if s && !s.closed? + end + + def test_bind_in_rescue + begin + raise "dummy error" + rescue + s = Addrinfo.tcp(nil, 0).bind + assert(!s.closed?) + end + ensure + s.close if s && !s.closed? + end + + def test_listen_in_rescue + begin + raise "dummy error" + rescue + s = Addrinfo.tcp(nil, 0).listen + assert(!s.closed?) + end + ensure + s.close if s && !s.closed? + end + + def test_udp_server_sockets_in_rescue + begin + raise "dummy error" + rescue + ss = Socket.udp_server_sockets(0) + ss.each {|s| + assert(!s.closed?) + } + end + ensure + if ss + ss.each {|s| + s.close if !s.closed? + } + end + end + + def test_tcp_server_sockets_in_rescue + begin + raise "dummy error" + rescue + ss = Socket.tcp_server_sockets(0) + ss.each {|s| + assert(!s.closed?) + } + end + ensure + if ss + ss.each {|s| + s.close if !s.closed? + } + end + end + +end if defined?(Socket) |