2015-11-14 08:15:33 -05:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2009-01-17 04:39:14 -05:00
|
|
|
begin
|
|
|
|
require "socket"
|
|
|
|
require "test/unit"
|
2017-04-18 21:08:16 -04:00
|
|
|
require "io/nonblock"
|
2009-01-17 04:39:14 -05:00
|
|
|
rescue LoadError
|
|
|
|
end
|
|
|
|
|
2009-02-10 23:17:57 -05:00
|
|
|
class TestSocket_BasicSocket < Test::Unit::TestCase
|
2009-01-17 04:39:14 -05:00
|
|
|
def inet_stream
|
|
|
|
sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
|
|
|
|
yield sock
|
|
|
|
ensure
|
2015-01-15 10:26:03 -05:00
|
|
|
assert(sock.closed?)
|
2009-01-17 04:39:14 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_getsockopt
|
|
|
|
inet_stream do |s|
|
2016-03-04 19:29:39 -05:00
|
|
|
begin
|
|
|
|
n = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_TYPE)
|
|
|
|
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
|
2009-01-17 04:39:14 -05:00
|
|
|
|
2016-03-04 19:29:39 -05:00
|
|
|
n = s.getsockopt("SOL_SOCKET", "SO_TYPE")
|
|
|
|
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
|
2009-01-17 04:39:14 -05:00
|
|
|
|
2016-03-04 19:29:39 -05:00
|
|
|
n = s.getsockopt(:SOL_SOCKET, :SO_TYPE)
|
|
|
|
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
|
2009-01-17 04:39:14 -05:00
|
|
|
|
2016-03-04 19:29:39 -05:00
|
|
|
n = s.getsockopt(:SOCKET, :TYPE)
|
|
|
|
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
|
2009-01-17 04:39:14 -05:00
|
|
|
|
2016-03-04 19:29:39 -05:00
|
|
|
n = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
|
|
|
|
assert_equal([0].pack("i"), n.data)
|
|
|
|
rescue Minitest::Assertion
|
|
|
|
s.close
|
|
|
|
if /aix/ =~ RUBY_PLATFORM
|
|
|
|
skip "Known bug in getsockopt(2) on AIX"
|
|
|
|
end
|
|
|
|
raise $!
|
|
|
|
end
|
2009-01-17 04:39:14 -05:00
|
|
|
|
|
|
|
val = Object.new
|
|
|
|
class << val; self end.send(:define_method, :to_int) {
|
|
|
|
s.close
|
|
|
|
Socket::SO_TYPE
|
|
|
|
}
|
|
|
|
assert_raise(IOError) {
|
|
|
|
n = s.getsockopt(Socket::SOL_SOCKET, val)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_setsockopt
|
|
|
|
s = nil
|
|
|
|
linger = [0, 0].pack("ii")
|
|
|
|
|
|
|
|
val = Object.new
|
|
|
|
class << val; self end.send(:define_method, :to_str) {
|
|
|
|
s.close
|
|
|
|
linger
|
|
|
|
}
|
|
|
|
inet_stream do |sock|
|
|
|
|
s = sock
|
|
|
|
assert_equal(0, s.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, linger))
|
|
|
|
|
|
|
|
assert_raise(IOError, "[ruby-dev:25039]") {
|
|
|
|
s.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, val)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
val = Object.new
|
|
|
|
class << val; self end.send(:define_method, :to_int) {
|
|
|
|
s.close
|
|
|
|
Socket::SO_LINGER
|
|
|
|
}
|
|
|
|
inet_stream do |sock|
|
|
|
|
s = sock
|
|
|
|
assert_raise(IOError) {
|
|
|
|
s.setsockopt(Socket::SOL_SOCKET, val, linger)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_listen
|
|
|
|
s = nil
|
|
|
|
log = Object.new
|
|
|
|
class << log; self end.send(:define_method, :to_int) {
|
|
|
|
s.close
|
|
|
|
2
|
|
|
|
}
|
|
|
|
inet_stream do |sock|
|
|
|
|
s = sock
|
|
|
|
assert_raise(IOError) {
|
|
|
|
s.listen(log)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
2015-01-13 18:22:17 -05:00
|
|
|
|
2015-01-13 18:37:05 -05:00
|
|
|
def socks
|
2017-05-15 03:33:10 -04:00
|
|
|
sserv = TCPServer.new('localhost', 0)
|
2015-01-13 18:22:17 -05:00
|
|
|
ssock = nil
|
|
|
|
t = Thread.new { ssock = sserv.accept }
|
2015-01-13 18:37:05 -05:00
|
|
|
csock = TCPSocket.new('localhost', sserv.addr[1])
|
2015-01-13 18:22:17 -05:00
|
|
|
t.join
|
|
|
|
yield sserv, ssock, csock
|
|
|
|
ensure
|
|
|
|
ssock.close rescue nil
|
|
|
|
csock.close rescue nil
|
|
|
|
sserv.close rescue nil
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_close_read
|
2015-01-13 18:37:05 -05:00
|
|
|
socks do |sserv, ssock, csock|
|
2015-01-13 18:22:17 -05:00
|
|
|
|
|
|
|
# close_read makes subsequent reads raise IOError
|
|
|
|
csock.close_read
|
|
|
|
assert_raise(IOError) { csock.read(5) }
|
|
|
|
|
|
|
|
# close_read ignores any error from shutting down half of still-open socket
|
|
|
|
assert_nothing_raised { csock.close_read }
|
|
|
|
|
|
|
|
# close_read raises if socket is not open
|
|
|
|
assert_nothing_raised { csock.close }
|
|
|
|
assert_raise(IOError) { csock.close_read }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_close_write
|
2015-01-13 18:37:05 -05:00
|
|
|
socks do |sserv, ssock, csock|
|
2015-01-13 18:22:17 -05:00
|
|
|
|
|
|
|
# close_write makes subsequent writes raise IOError
|
|
|
|
csock.close_write
|
|
|
|
assert_raise(IOError) { csock.write(5) }
|
|
|
|
|
|
|
|
# close_write ignores any error from shutting down half of still-open socket
|
|
|
|
assert_nothing_raised { csock.close_write }
|
|
|
|
|
|
|
|
# close_write raises if socket is not open
|
|
|
|
assert_nothing_raised { csock.close }
|
|
|
|
assert_raise(IOError) { csock.close_write }
|
2015-01-13 18:22:31 -05:00
|
|
|
end
|
2015-01-13 18:22:17 -05:00
|
|
|
end
|
|
|
|
|
2015-12-21 13:57:50 -05:00
|
|
|
def test_for_fd
|
2015-12-22 13:20:20 -05:00
|
|
|
assert_raise(Errno::EBADF, '[ruby-core:72418] [Bug #11854]') do
|
2015-12-21 13:57:50 -05:00
|
|
|
BasicSocket.for_fd(-1)
|
|
|
|
end
|
|
|
|
inet_stream do |sock|
|
|
|
|
s = BasicSocket.for_fd(sock.fileno)
|
|
|
|
assert_instance_of BasicSocket, s
|
|
|
|
s.autoclose = false
|
|
|
|
sock.close
|
|
|
|
end
|
|
|
|
end
|
2017-04-18 21:08:16 -04:00
|
|
|
|
|
|
|
def test_read_write_nonblock
|
|
|
|
socks do |sserv, ssock, csock|
|
|
|
|
set_nb = true
|
|
|
|
buf = String.new
|
|
|
|
if ssock.respond_to?(:nonblock?)
|
2018-11-22 03:46:51 -05:00
|
|
|
csock.nonblock = ssock.nonblock = false
|
2017-04-18 21:08:16 -04:00
|
|
|
|
|
|
|
# Linux may use MSG_DONTWAIT to avoid setting O_NONBLOCK
|
|
|
|
if RUBY_PLATFORM.match?(/linux/) && Socket.const_defined?(:MSG_DONTWAIT)
|
|
|
|
set_nb = false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
assert_equal :wait_readable, ssock.read_nonblock(1, buf, exception: false)
|
|
|
|
assert_equal 5, csock.write_nonblock('hello')
|
|
|
|
IO.select([ssock])
|
|
|
|
assert_same buf, ssock.read_nonblock(5, buf, exception: false)
|
|
|
|
assert_equal 'hello', buf
|
|
|
|
buf = '*' * 16384
|
|
|
|
n = 0
|
|
|
|
|
|
|
|
case w = csock.write_nonblock(buf, exception: false)
|
|
|
|
when Integer
|
|
|
|
n += w
|
|
|
|
when :wait_writable
|
|
|
|
break
|
|
|
|
end while true
|
|
|
|
|
|
|
|
assert_equal :wait_writable, w
|
|
|
|
assert_raise(IO::WaitWritable) { loop { csock.write_nonblock(buf) } }
|
|
|
|
assert_operator n, :>, 0
|
|
|
|
assert_not_predicate(csock, :nonblock?, '[Feature #13362]') unless set_nb
|
|
|
|
csock.close
|
|
|
|
|
|
|
|
case r = ssock.read_nonblock(16384, buf, exception: false)
|
|
|
|
when String
|
|
|
|
next
|
|
|
|
when nil
|
|
|
|
break
|
2017-04-21 16:38:58 -04:00
|
|
|
when :wait_readable
|
|
|
|
IO.select([ssock], nil, nil, 10) or
|
|
|
|
flunk 'socket did not become readable'
|
2017-04-18 21:08:16 -04:00
|
|
|
else
|
|
|
|
flunk "unexpected read_nonblock return: #{r.inspect}"
|
|
|
|
end while true
|
|
|
|
|
|
|
|
assert_raise(EOFError) { ssock.read_nonblock(1) }
|
|
|
|
|
|
|
|
assert_not_predicate(ssock, :nonblock?) unless set_nb
|
|
|
|
end
|
|
|
|
end
|
2017-10-27 19:26:48 -04:00
|
|
|
|
|
|
|
def test_read_nonblock_mix_buffered
|
|
|
|
socks do |sserv, ssock, csock|
|
|
|
|
ssock.write("hello\nworld\n")
|
|
|
|
assert_equal "hello\n", csock.gets
|
|
|
|
IO.select([csock], nil, nil, 10) or
|
|
|
|
flunk 'socket did not become readable'
|
|
|
|
assert_equal "world\n", csock.read_nonblock(8)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_write_nonblock_buffered
|
|
|
|
socks do |sserv, ssock, csock|
|
|
|
|
ssock.sync = false
|
|
|
|
ssock.write("h")
|
|
|
|
assert_equal :wait_readable, csock.read_nonblock(1, exception: false)
|
|
|
|
assert_equal 4, ssock.write_nonblock("ello")
|
|
|
|
ssock.close
|
|
|
|
assert_equal "hello", csock.read(5)
|
|
|
|
end
|
|
|
|
end
|
2009-01-17 04:39:14 -05:00
|
|
|
end if defined?(BasicSocket)
|