# IO::WantRead and IO::WantWrite module for nonblocking exceptions

**URL:** <https://www.ruby-forum.com/t/io-wantread-and-io-wantwrite-module-for-nonblocking-exceptions/162060>\
**Category:** Development\
**Created:** [March 5, 2009, 10:51am UTC](https://www.ruby-forum.com/t/io-wantread-and-io-wantwrite-module-for-nonblocking-exceptions/162060 "2009-03-05T10:51:32Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![Tanaka\_A](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/t/c67d28/32.png) [@Tanaka\_A](https://www.ruby-forum.com/u/Tanaka_A)\
**Post date:** [March 5, 2009, 10:51am UTC](https://www.ruby-forum.com/t/io-wantread-and-io-wantwrite-module-for-nonblocking-exceptions/162060/1 "2009-03-05T10:51:32Z")

</div>

IO::WantRead e$B$He(B IO::WantWrite e$B$H$$$&%b%8%e!\<%k$r:n$C$F!"e(B  
EAGAIN e$B$de(B EWOULDBLOCK e$B$J$I$,H/@8$7$?$H$-$K!"Nc30%_%V%8%'%/%He(B  
e$B$Ke(B extend e$B$7$F$_$/$N$O$I$&$G$7$g$&$+!#e(B

e$BM}M3$O$U$?$D$"$j$^$9!#e(B

- rescue Errno::EAGAIN, Errno::EWOULDBLOCK e$B$HJB$Y$k$N$OLLE]e(B

- openssl e$B$Ne(B read\_nonblock e$B$N\>l9g!"e(Bread e$B$He(B write  
e$B$N$I$A$i$re(B  
e$BBT$D$Y$-$+$o$+$i$J$$e(B

e$B$H$$$&$o$1$G$I$&$G$7$g$&$+!#e(B

# % svn diff --diff-cmd diff -x ‘-u -p’ Index: include/ruby/ruby.h

— include/ruby/ruby.h (revision 22781)  
+++ include/ruby/ruby.h (working copy)  
@@ -979,6 +979,7 @@ PRINTF\_ARGS(NORETURN(void rb\_raise(VALUE  
PRINTF\_ARGS(NORETURN(void rb\_fatal(const char\*, …)), 1, 2);  
PRINTF\_ARGS(NORETURN(void rb\_bug(const char\*, …)), 1, 2);  
NORETURN(void rb\_sys\_fail(const char\*));  
+NORETURN(void rb\_sys\_fail\_with\_mod(VALUE, const char\*));  
NORETURN(void rb\_iter\_break(void));  
NORETURN(void rb\_exit(int));  
NORETURN(void rb\_notimplement(void));  
@@ -1033,6 +1034,8 @@ RUBY\_EXTERN VALUE rb\_mFileTest;  
RUBY\_EXTERN VALUE rb\_mGC;  
RUBY\_EXTERN VALUE rb\_mMath;  
RUBY\_EXTERN VALUE rb\_mProcess;  
+RUBY\_EXTERN VALUE rb\_mWantRead;  
+RUBY\_EXTERN VALUE rb\_mWantWrite;

# RUBY\_EXTERN VALUE rb\_cBasicObject; RUBY\_EXTERN VALUE rb\_cObject; Index: io.c

— io.c (revision 22781)  
+++ io.c (working copy)  
@@ -110,6 +110,8 @@ extern void Init\_File(void);  
VALUE rb\_cIO;  
VALUE rb\_eEOFError;  
VALUE rb\_eIOError;  
+VALUE rb\_mWantRead;  
+VALUE rb\_mWantWrite;

VALUE rb\_stdin, rb\_stdout, rb\_stderr;  
VALUE rb\_deferr; /\* rescue VIM plugin \*/  
@@ -1755,7 +1757,7 @@ io\_getpartial(int argc, VALUE \*argv, VAL  
if (!nonblock && rb\_io\_wait\_readable(fptr-\>fd))  
goto again;  
if (nonblock && errno == EWOULDBLOCK)

- 

```
           rb_sys_fail("WANT_READ");

```

- 

```
           rb_sys_fail_with_mod(rb_mWantRead, "WANT_READ");
       rb_sys_fail_path(fptr->pathv);
   }

```

else if (n == 0) {  
@@ -1956,7 +1958,7 @@ rb\_io\_write\_nonblock(VALUE io, VALUE str

if (n == -1) {  
if (errno == EWOULDBLOCK)

- 

```
       rb_sys_fail("WANT_WRITE");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantWrite, "WANT_WRITE");
   rb_sys_fail_path(fptr->pathv);

```

}

@@ -8635,6 +8637,9 @@ Init\_IO(void)  
rb\_cIO = rb\_define\_class(“IO”, rb\_cObject);  
rb\_include\_module(rb\_cIO, rb\_mEnumerable);

- rb\_mWantRead = rb\_define\_module\_under(rb\_cIO, “WantRead”);
- rb\_mWantWrite = rb\_define\_module\_under(rb\_cIO, “WantWrite”);
- 

# #if 0 /\* This is necessary only for forcing rdoc handle File::open \*/ rb\_define\_singleton\_method(rb\_cFile, “open”, rb\_io\_s\_open, -1); Index: ext/openssl/ossl\_ssl.c

— ext/openssl/ossl\_ssl.c (revision 22781)  
+++ ext/openssl/ossl\_ssl.c (working copy)  
@@ -1115,14 +1115,14 @@ ossl\_ssl\_read\_internal(int argc, VALUE \*  
case SSL\_ERROR\_WANT\_WRITE:  
if (nonblock) {  
errno = EWOULDBLOCK;

- 

```
               rb_sys_fail("SSL_ERROR_WANT_WRITE");

```

- 

```
               rb_sys_fail_with_mod(rb_mWantWrite, 

```

“SSL\_ERROR\_WANT\_WRITE”);  
}  
rb\_io\_wait\_writable(FPTR\_TO\_FD(fptr));  
continue;  
case SSL\_ERROR\_WANT\_READ:  
if (nonblock) {  
errno = EWOULDBLOCK;

- 

```
               rb_sys_fail("SSL_ERROR_WANT_READ");

```

- 

```
               rb_sys_fail_with_mod(rb_mWantRead, 

```

# “SSL\_ERROR\_WANT\_READ”); } rb\_io\_wait\_readable(FPTR\_TO\_FD(fptr)); continue; Index: ext/socket/init.c

— ext/socket/init.c (revision 22781)  
+++ ext/socket/init.c (working copy)  
@@ -200,7 +200,7 @@ rsock\_s\_recvfrom\_nonblock(VALUE sock, in  
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN  
case EWOULDBLOCK:  
#endif

- 

```
       rb_sys_fail("recvfrom(2) WANT_READ");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantRead, "recvfrom(2) 

```

WANT\_READ");  
}  
rb\_sys\_fail(“recvfrom(2)”);  
}  
@@ -472,7 +472,7 @@ rsock\_s\_accept\_nonblock(VALUE klass, rb\_  
#if defined EPROTO  
case EPROTO:  
#endif

- 

```
       rb_sys_fail("accept(2) WANT_READ");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantRead, "accept(2) WANT_READ");

```

}  
rb\_sys\_fail(“accept(2)”);  
}  
Index: ext/socket/socket.c  
===================================================================  
— ext/socket/socket.c (revision 22781)  
+++ ext/socket/socket.c (working copy)  
@@ -312,7 +312,7 @@ sock\_connect\_nonblock(VALUE sock, VALUE  
n = connect(fptr-\>fd, (struct sockaddr\*)RSTRING\_PTR(addr),  
RSTRING\_LEN(addr));  
if (n \< 0) {  
if (errno == EINPROGRESS)

- 

```
       rb_sys_fail("connect(2) WANT_WRITE");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantWrite, "connect(2) 

```

WANT\_WRITE");  
rb\_sys\_fail(“connect(2)”);  
}

# Index: ext/socket/ancdata.c

— ext/socket/ancdata.c (revision 22781)  
+++ ext/socket/ancdata.c (working copy)  
@@ -1280,7 +1280,7 @@ bsock\_sendmsg\_internal(int argc, VALUE \*

```
 if (ss == -1) {
     if (nonblock && errno == EWOULDBLOCK)

```

- 

```
       rb_sys_fail("sendmsg(2) WANT_WRITE");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantWrite, "sendmsg(2) 

```

WANT\_WRITE");  
rb\_sys\_fail(“sendmsg(2)”);  
}

@@ -1565,7 +1565,7 @@ bsock\_recvmsg\_internal(int argc, VALUE \*

```
 if (ss == -1) {
     if (nonblock && errno == EWOULDBLOCK)

```

- 

```
       rb_sys_fail("recvmsg(2) WANT_READ");

```

- 

```
       rb_sys_fail_with_mod(rb_mWantRead, "recvmsg(2) WANT_READ");

```

# #if defined(HAVE\_ST\_MSG\_CONTROL) if (!gc\_done && (errno == EMFILE || errno == EMSGSIZE)) { /\* Index: error.c

— error.c (revision 22781)  
+++ error.c (working copy)  
@@ -1129,8 +1129,8 @@ rb\_fatal(const char \*fmt, …)  
rb\_exc\_fatal(rb\_exc\_new3(rb\_eFatal, mesg));  
}

-void  
-rb\_sys\_fail(const char \*mesg)  
+static VALUE  
+make\_errno\_exc(const char \*mesg)  
{  
int n = errno;  
VALUE arg;  
@@ -1141,7 +1141,21 @@ rb\_sys\_fail(const char \*mesg)  
}

```
 arg = mesg ? rb_str_new2(mesg) : Qnil;

```

- rb\_exc\_raise(rb\_class\_new\_instance(1, &arg, get\_syserr(n)));

- return rb\_class\_new\_instance(1, &arg, get\_syserr(n));  
+}
- 

+void  
+rb\_sys\_fail(const char \*mesg)  
+{

- rb\_exc\_raise(make\_errno\_exc(mesg));  
+}
- 

+void  
+rb\_sys\_fail\_with\_mod(VALUE mod, const char \*mesg)  
+{

- VALUE exc = make\_errno\_exc(mesg);
- rb\_extend\_object(exc, mod);
- rb\_exc\_raise(exc);  
}

# void Index: test/openssl/test\_pair.rb

— test/openssl/test\_pair.rb (revision 22781)  
+++ test/openssl/test\_pair.rb (working copy)  
@@ -147,7 +147,7 @@ class OpenSSL::TestPair \< Test::Unit::Te  
def test\_read\_nonblock  
ssl\_pair {|s1, s2|  
err = nil

- 

```
 assert_raise(Errno::EWOULDBLOCK) {

```

- 

```
 assert_raise(IO::WantRead) {
   begin
     s2.read_nonblock(10)
   ensure

```

# Index: test/openssl/test\_ssl.rb

— test/openssl/test\_ssl.rb (revision 22781)  
+++ test/openssl/test\_ssl.rb (working copy)  
@@ -172,12 +172,12 @@ class OpenSSL::TestSSL \< Test::Unit::Tes  
ssl = OpenSSL::SSL::SSLSocket.new(sock)  
ssl.sync\_close = true  
ssl.connect

- 

```
 assert_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) { 

```

ssl.read\_nonblock(100) }

- 

```
 assert_raise(IO::WantRead) { ssl.read_nonblock(100) }
 ssl.write("abc\n")
 IO.select [ssl]
 assert_equal('a', ssl.read_nonblock(1))
 assert_equal("bc\n", ssl.read_nonblock(100))

```

- 

```
 assert_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) { 

```

ssl.read\_nonblock(100) }

- 

```
 assert_raise(IO::WantRead) { ssl.read_nonblock(100) }

```

}  
end

# Index: test/socket/test\_nonblock.rb

— test/socket/test\_nonblock.rb (revision 22781)  
+++ test/socket/test\_nonblock.rb (working copy)  
@@ -12,13 +12,13 @@ class TestSocketNonblock \< Test::Unit::T  
serv = Socket.new(Socket::AF\_INET, Socket::SOCK\_STREAM, 0)  
serv.bind(Socket.sockaddr\_in(0, “127.0.0.1”))  
serv.listen(5)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
serv.accept\_nonblock }

- assert\_raise(IO::WantRead) { serv.accept\_nonblock }  
c = Socket.new(Socket::AF\_INET, Socket::SOCK\_STREAM, 0)  
c.connect(serv.getsockname)  
begin  
s, sockaddr = serv.accept\_nonblock

- rescue Errno::EWOULDBLOCK
- 

```
 IO.select nil, [serv]

```

- rescue IO::WantRead
- 

```
 IO.select [serv]
 s, sockaddr = serv.accept_nonblock

```

end  
assert\_equal(Socket.unpack\_sockaddr\_in(c.getsockname),  
Socket.unpack\_sockaddr\_in(sockaddr))  
@@ -57,8 +57,8 @@ class TestSocketNonblock \< Test::Unit::T  
u1 = UDPSocket.new  
u2 = UDPSocket.new  
u1.bind(“127.0.0.1”, 0)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
u1.recvfrom\_nonblock(100) }
- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINVAL) {  
u2.recvfrom\_nonblock(100) }

- assert\_raise(IO::WantRead) { u1.recvfrom\_nonblock(100) }
- assert\_raise(IO::WantRead, Errno::EINVAL) {  
u2.recvfrom\_nonblock(100) }  
u2.send(“aaa”, 0, u1.getsockname)  
IO.select [u1]  
mesg, inet\_addr = u1.recvfrom\_nonblock(100)  
@@ -67,7 +67,7 @@ class TestSocketNonblock \< Test::Unit::T  
af, port, host, addr = inet\_addr  
u2\_port, u2\_addr = Socket.unpack\_sockaddr\_in(u2.getsockname)  
assert\_equal(u2\_port, port)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
u1.recvfrom\_nonblock(100) }

- assert\_raise(IO::WantRead) { u1.recvfrom\_nonblock(100) }  
u2.send(“”, 0, u1.getsockname)  
assert\_nothing\_raised(“cygwin 1.5.19 has a problem to send an empty  
UDP packet. [ruby-dev:28915]”) {  
timeout(1) { IO.select [u1] }  
@@ -83,13 +83,13 @@ class TestSocketNonblock \< Test::Unit::T  
u1 = UDPSocket.new  
u2 = UDPSocket.new  
u1.bind(“127.0.0.1”, 0)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
u1.recv\_nonblock(100) }
- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINVAL) {  
u2.recv\_nonblock(100) }

- assert\_raise(IO::WantRead) { u1.recv\_nonblock(100) }
- assert\_raise(IO::WantRead, Errno::EINVAL) { u2.recv\_nonblock(100) }  
u2.send(“aaa”, 0, u1.getsockname)  
IO.select [u1]  
mesg = u1.recv\_nonblock(100)  
assert\_equal(“aaa”, mesg)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
u1.recv\_nonblock(100) }

- assert\_raise(IO::WantRead) { u1.recv\_nonblock(100) }  
u2.send(“”, 0, u1.getsockname)  
assert\_nothing\_raised(“cygwin 1.5.19 has a problem to send an empty  
UDP packet. [ruby-dev:28915]”) {  
timeout(1) { IO.select [u1] }  
@@ -105,8 +105,8 @@ class TestSocketNonblock \< Test::Unit::T  
s1 = Socket.new(Socket::AF\_INET, Socket::SOCK\_DGRAM, 0)  
s1.bind(Socket.sockaddr\_in(0, “127.0.0.1”))  
s2 = Socket.new(Socket::AF\_INET, Socket::SOCK\_DGRAM, 0)

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
s1.recvfrom\_nonblock(100) }
- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINVAL) {  
s2.recvfrom\_nonblock(100) }

- assert\_raise(IO::WantRead) { s1.recvfrom\_nonblock(100) }
- assert\_raise(IO::WantRead, Errno::EINVAL) {  
s2.recvfrom\_nonblock(100) }  
s2.send(“aaa”, 0, s1.getsockname)  
IO.select [s1]  
mesg, sockaddr = s1.recvfrom\_nonblock(100)  
@@ -140,13 +140,13 @@ class TestSocketNonblock \< Test::Unit::T

def test\_tcp\_recv\_nonblock  
c, s = tcp\_pair

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
c.recv\_nonblock(100) }
- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
s.recv\_nonblock(100) }

- assert\_raise(IO::WantRead) { c.recv\_nonblock(100) }
- assert\_raise(IO::WantRead) { s.recv\_nonblock(100) }  
c.write(“abc”)  
IO.select [s]  
assert\_equal(“a”, s.recv\_nonblock(1))  
assert\_equal(“bc”, s.recv\_nonblock(100))

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
s.recv\_nonblock(100) }

- assert\_raise(IO::WantRead) { s.recv\_nonblock(100) }  
ensure  
c.close if c  
s.close if s  
@@ -154,13 +154,13 @@ class TestSocketNonblock \< Test::Unit::T

def test\_read\_nonblock  
c, s = tcp\_pair

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
c.read\_nonblock(100) }
- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
s.read\_nonblock(100) }

- assert\_raise(IO::WantRead) { c.read\_nonblock(100) }
- assert\_raise(IO::WantRead) { s.read\_nonblock(100) }  
c.write(“abc”)  
IO.select [s]  
assert\_equal(“a”, s.read\_nonblock(1))  
assert\_equal(“bc”, s.read\_nonblock(100))

- assert\_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {  
s.read\_nonblock(100) }

- assert\_raise(IO::WantRead) { s.read\_nonblock(100) }  
ensure  
c.close if c  
s.close if s  
@@ -175,7 +175,7 @@ class TestSocketNonblock \< Test::Unit::T  
ret = c.write\_nonblock(str)  
assert\_operator(ret, :\>, 0)  
loop {

- 

```
 assert_raise(Errno::EAGAIN, Errno::EWOULDBLOCK) {

```

- 

```
 assert_raise(IO::WantWrite) {
   loop {
     ret = c.write_nonblock(str)
     assert_operator(ret, :>, 0)

```

@@ -196,7 +196,7 @@ class TestSocketNonblock \< Test::Unit::T  
loop {  
c.sendmsg\_nonblock(“a” \* 100000)  
}

- 

```
 rescue Errno::EWOULDBLOCK

```

- 

```
 rescue IO::WantWrite
   assert_match(/WANT_WRITE/, $!.message)
 end

```

}  
@@ -206,7 +206,7 @@ class TestSocketNonblock \< Test::Unit::T  
tcp\_pair {|c, s|  
begin  
c.recvmsg\_nonblock(4096)

- 

```
 rescue Errno::EWOULDBLOCK

```

- 

```
 rescue IO::WantRead
   assert_match(/WANT_READ/, $!.message)
 end

```

}  
@@ -216,7 +216,7 @@ class TestSocketNonblock \< Test::Unit::T  
tcp\_pair {|c, s|  
begin  
c.recv\_nonblock(4096)

- 

```
 rescue Errno::EWOULDBLOCK

```

- 

```
 rescue IO::WantRead
   assert_match(/WANT_READ/, $!.message)
 end

```

}  
@@ -243,7 +243,7 @@ class TestSocketNonblock \< Test::Unit::T  
port = serv.local\_address.ip\_port  
begin  
s, \_ = serv.accept\_nonblock

- rescue Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO

- rescue IO::WantRead  
assert\_match(/WANT\_READ/, $!.message)  
end  
ensure  
Index: test/socket/test\_addrinfo.rb  
===================================================================  
— test/socket/test\_addrinfo.rb (revision 22781)  
+++ test/socket/test\_addrinfo.rb (working copy)  
@@ -236,7 +236,7 @@ class TestSocketAddrinfo \< Test::Unit::T  
c.connect(serv.local\_address)  
begin  
ret = serv.accept\_nonblock

- rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED,  
Errno::EPROTO, Errno::EINTR

- rescue IO::WantRead, Errno::EINTR  
IO.select([serv])  
retry  
end  
@@ -299,7 +299,7 @@ class TestSocketAddrinfo \< Test::Unit::T  
s2.send(“test-socket-recvfrom”, 0, s1.getsockname)  
begin  
data, ai = s1.recvfrom\_nonblock(100)

- rescue Errno::EWOULDBLOCK

- rescue IO::WantRead  
IO.select([s1])  
retry  
end

---

<div class="post-metadata">

**Author:** ![Tanaka\_A](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/t/c67d28/32.png) [@Tanaka\_A](https://www.ruby-forum.com/u/Tanaka_A)\
**Post date:** [March 6, 2009, 2:57am UTC](https://www.ruby-forum.com/t/io-wantread-and-io-wantwrite-module-for-nonblocking-exceptions/162060/2 "2009-03-06T02:57:07Z")

</div>

e$B!Ve(BWantReade$B!W$H!Ve(BWantWritee$B!W$O1Q8lE\*$K$A$g$C$HHyL/$JLL$,$"$k$N$G!"e(B  
e$BL\>A0$K$D$$$F$O0l2se(B ruby-core  
e$B$G5DO@$7$?J}$,$$$$$+$b$7$l$^$;$s!#e(B

e$B$h$m$7$/$\*4j$$$7$^$9!#e(B Martin.

At 18:48 09/03/05, you wrote:

> read\_nonblock e$B$G5/$-$?e(B EAGAIN e$B$He(B EWOULDBLOCK e$B$Ge(B
> 
> # e$B$3$3$G$I$A$i$rBT$D$Y$-$+$K1~$8$Fe(B IO::WantRead e$B$He(B Index: include/ruby/ruby.h NORETURN(void rb\_notimplement(void));
> 
> VALUE rb\_deferr; /\* rescue VIM plugin \*/
> 
> @@ -1115,14 +1115,14 @@ ossl\_ssl\_read\_internal(int argc, VALUE \*  
> errno = EWOULDBLOCK;  
> #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN  
> #endif  
> n = connect(fptr-\>fd, (struct sockaddr\*)RSTRING\_PTR(addr),  
> — ext/socket/ancdata.c (revision 22781)  
> @@ -1565,7 +1565,7 @@ bsock\_recvmsg\_internal(int argc, VALUE \*  
> — error.c (revision 22781)  
> int n = errno;  
> +rb\_sys\_fail(const char \*mesg)  
> }
> 
> - 
> 
> ```
> assert_raise(Errno::EWOULDBLOCK) {
> ssl.sync_close = true
> 
> ```
> 
> end
> 
> - assert\_raise(IO::WantRead) { serv.accept\_nonblock }  
> assert\_equal(Socket.unpack\_sockaddr\_in(c.getsockname),
> - assert\_raise(IO::WantRead, Errno::EINVAL) { u2.recvfrom\_nonblock(100) }  
> u2.send(“”, 0, u1.getsockname)
> - assert\_raise(IO::WantRead) { u1.recv\_nonblock(100) }  
> timeout(1) { IO.select [u1] }  
> s2.send(“aaa”, 0, s1.getsockname)  
> c.write(“abc”)  
> def test\_read\_nonblock
> - assert\_raise(IO::WantRead) { s.read\_nonblock(100) }  
> ret = c.write\_nonblock(str)  
> @@ -206,7 +206,7 @@ class TestSocketNonblock \< Test::Unit::T  
> begin
> 
> - rescue Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO  
> begin  
> data, ai = s1.recvfrom\_nonblock(100)
> - rescue Errno::EWOULDBLOCK
> 
> - rescue IO::WantRead  
> IO.select([s1])  
> retry  
> end  
> –  
> [e$BEDCfe(B e$BE/e(B][e$B$?$J$+e(B e$B$"$-$ie(B][Tanaka A.]

#-#-# Martin J. Du"rst, Assoc. Professor, Aoyama Gakuin University  
#-#-# [http://www.sw.it.aoyama.ac.jp](http://www.sw.it.aoyama.ac.jp)[mailto:removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)