The R13B03 release.OTP_R13B03

1 files changed, 2362 insertions, 0 deletions

diff --git a/lib/kernel/test/gen_tcp_misc_SUITE.erl b/lib/kernel/test/gen_tcp_misc_SUITE.erl
new file mode 100644
index 0000000000..5d726a3b1b
--- /dev/null
+++ b/lib/kernel/test/gen_tcp_misc_SUITE.erl
@@ -0,0 +1,2362 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1998-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(gen_tcp_misc_SUITE).
+
+-include("test_server.hrl").
+
+%-compile(export_all).
+
+-export([all/1, controlling_process/1, no_accept/1, close_with_pending_output/1,
+	 data_before_close/1, iter_max_socks/1, get_status/1,
+	 passive_sockets/1, accept_closed_by_other_process/1,
+	 init_per_testcase/2, fin_per_testcase/2,
+	 otp_3924/1, otp_3924_sender/4, closed_socket/1,
+	 shutdown_active/1, shutdown_passive/1, shutdown_pending/1,
+	 default_options/1, http_bad_packet/1, 
+	 busy_send/1, busy_disconnect_passive/1, busy_disconnect_active/1,
+	 fill_sendq/1, partial_recv_and_close/1, 
+	 partial_recv_and_close_2/1,partial_recv_and_close_3/1,so_priority/1,
+	 % Accept tests
+	 primitive_accept/1,multi_accept_close_listen/1,accept_timeout/1,
+	 accept_timeouts_in_order/1,accept_timeouts_in_order2/1,accept_timeouts_in_order3/1,
+	 accept_timeouts_mixed/1, 
+	 killing_acceptor/1,killing_multi_acceptors/1,killing_multi_acceptors2/1,
+	 several_accepts_in_one_go/1,active_once_closed/1, send_timeout/1, otp_7731/1,
+	 zombie_sockets/1, otp_7816/1, otp_8102/1]).
+
+%% Internal exports.
+-export([sender/3, not_owner/1, passive_sockets_server/2, priority_server/1, otp_7731_server/1, zombie_server/2]).
+
+init_per_testcase(_Func, Config) when is_list(Config) ->
+    Dog = test_server:timetrap(test_server:seconds(240)),
+    [{watchdog, Dog}|Config].
+fin_per_testcase(_Func, Config) ->
+    Dog = ?config(watchdog, Config),
+    test_server:timetrap_cancel(Dog).
+
+all(suite) ->
+    [controlling_process, no_accept,
+     close_with_pending_output,
+     data_before_close, iter_max_socks, passive_sockets,
+     accept_closed_by_other_process, otp_3924, closed_socket,
+     shutdown_active, shutdown_passive, shutdown_pending,
+     default_options, http_bad_packet, 
+     busy_send, busy_disconnect_passive, busy_disconnect_active,
+     fill_sendq, partial_recv_and_close, 
+     partial_recv_and_close_2, partial_recv_and_close_3, so_priority,
+     primitive_accept,multi_accept_close_listen,accept_timeout,
+     accept_timeouts_in_order,accept_timeouts_in_order2,accept_timeouts_in_order3,
+     accept_timeouts_mixed, 
+     killing_acceptor,killing_multi_acceptors,killing_multi_acceptors2,
+     several_accepts_in_one_go, active_once_closed, send_timeout, otp_7731,
+     zombie_sockets, otp_7816, otp_8102].
+
+
+default_options(doc) ->
+    ["Tests kernel application variables inet_default_listen_options and "
+     "inet_default_connect_options"];
+default_options(suite) ->
+    [];
+default_options(Config) when is_list(Config) ->
+    %% First check the delay_send option
+    ?line {true,true,true}=do_delay_send_1(),
+    ?line {false,false,false}=do_delay_send_2(),
+    ?line {true,false,false}=do_delay_send_3(),
+    ?line {false,false,false}=do_delay_send_4(),
+    ?line {false,false,false}=do_delay_send_5(),
+    ?line {false,true,true}=do_delay_send_6(),
+    %% Now lets start some nodes with different combinations of options:
+    ?line {true,true,true} = do_delay_on_other_node("",
+						    fun do_delay_send_1/0),
+    ?line {true,false,false} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_2/0),
+    
+    ?line {false,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_listen_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_2/0),
+    
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_listen_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_3/0),
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_6/0),
+    ?line {false,false,false} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_5/0),
+    ?line {false,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{delay_send,true}]\" "
+			       "-kernel inet_default_listen_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_5/0),
+    ?line {true,false,false} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{delay_send,true}]\" "
+			       "-kernel inet_default_listen_options "
+			       "\"[{delay_send,true}]\"",
+			       fun do_delay_send_4/0),
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"{delay_send,true}\" "
+			       "-kernel inet_default_listen_options "
+			       "\"{delay_send,true}\"",
+			       fun do_delay_send_2/0),
+    %% Active is to dangerous and is supressed
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"{active,false}\" "
+			       "-kernel inet_default_listen_options "
+			       "\"{active,false}\"",
+			       fun do_delay_send_7/0),
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{active,false},{delay_send,true}]\" "
+			       "-kernel inet_default_listen_options "
+			       "\"[{active,false},{delay_send,true}]\"",
+			       fun do_delay_send_7/0),
+    ?line {true,true,true} = 
+	do_delay_on_other_node("-kernel inet_default_connect_options "
+			       "\"[{active,false},{delay_send,true}]\" "
+			       "-kernel inet_default_listen_options "
+			       "\"[{active,false},{delay_send,true}]\"",
+			       fun do_delay_send_2/0),
+    ok.
+
+
+do_delay_on_other_node(XArgs, Function) ->
+    Dir = filename:dirname(code:which(?MODULE)),
+    {ok,Node} = test_server:start_node(test_default_options_slave,slave,
+				       [{args,"-pa " ++ Dir ++ " " ++
+					 XArgs}]),
+    Res = rpc:call(Node,erlang,apply,[Function,[]]),
+    test_server:stop_node(Node),
+    Res.
+					      
+
+do_delay_send_1() ->
+    {ok,LS}=gen_tcp:listen(0,[{delay_send,true}]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[{delay_send,true}]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+
+do_delay_send_2() ->
+    {ok,LS}=gen_tcp:listen(0,[]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+
+do_delay_send_3() ->
+    {ok,LS}=gen_tcp:listen(0,[]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[{delay_send,true}]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+    
+do_delay_send_4() ->
+    {ok,LS}=gen_tcp:listen(0,[{delay_send,false}]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+    
+do_delay_send_5() ->
+    {ok,LS}=gen_tcp:listen(0,[]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[{delay_send,false}]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+    
+do_delay_send_6() ->
+    {ok,LS}=gen_tcp:listen(0,[{delay_send,true}]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{delay_send,B1}]}=inet:getopts(S,[delay_send]),
+    {ok,[{delay_send,B2}]}=inet:getopts(LS,[delay_send]),
+    {ok,[{delay_send,B3}]}=inet:getopts(S2,[delay_send]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+    
+do_delay_send_7() ->
+    {ok,LS}=gen_tcp:listen(0,[]),
+    {ok,{{0,0,0,0},PortNum}}=inet:sockname(LS),
+    {ok,S}=gen_tcp:connect("localhost",PortNum,[]),
+    {ok,S2}= gen_tcp:accept(LS),
+    {ok,[{active,B1}]}=inet:getopts(S,[active]),
+    {ok,[{active,B2}]}=inet:getopts(LS,[active]),
+    {ok,[{active,B3}]}=inet:getopts(S2,[active]),
+    gen_tcp:close(S2),
+    gen_tcp:close(S),
+    gen_tcp:close(LS),
+    {B1,B2,B3}.
+    
+ 
+
+controlling_process(doc) ->
+    ["Open a listen port and change controlling_process for it",
+     "The result should be ok of done by the owner process,"
+     "Otherwise is should return {error,not_owner} or similar"];
+controlling_process(suite) -> [];
+controlling_process(Config) when is_list(Config) ->
+    {ok,S} = gen_tcp:listen(0,[]),
+    Pid2 = spawn(?MODULE,not_owner,[S]),
+    Pid2 ! {self(),2,control},
+    ?line {error, E} = receive {2,_E} ->
+			      _E
+		      after 10000 -> timeout
+		      end,
+    io:format("received ~p~n",[E]),
+    Pid = spawn(?MODULE,not_owner,[S]),
+    ?line ok = gen_tcp:controlling_process(S,Pid),
+    Pid ! {self(),1,control},
+    ?line ok = receive {1,ok} ->
+		       ok
+	       after 1000 -> timeout
+	       end,
+    Pid ! close.
+
+not_owner(S) ->
+    receive
+	{From,Tag,control} ->
+	    From ! {Tag,gen_tcp:controlling_process(S,self())};
+	close ->
+	    gen_tcp:close(S)
+    after 1000 ->
+	    ok
+    end.
+
+no_accept(doc) ->
+    ["Open a listen port and connect to it, then close the listen port ",
+     "without doing any accept.  The connected socket should receive ",
+     "a tcp_closed message."];
+no_accept(suite) -> [];
+no_accept(Config) when is_list(Config) ->
+    case os:type() of
+	vxworks ->
+	    {skip,"Too tough for vxworks"};
+	_ ->
+	    no_accept2()
+    end.
+
+no_accept2() ->
+    ?line {ok, L} = gen_tcp:listen(0, []),
+    ?line {ok, {_, Port}} = inet:sockname(L),
+    ?line {ok, Client} = gen_tcp:connect(localhost, Port, []),
+    ?line ok = gen_tcp:close(L),
+    ?line receive
+	      {tcp_closed, Client} ->
+		  ok
+	  after 5000 ->
+		  ?line test_server:fail(never_closed)
+	  
+	  end.
+
+close_with_pending_output(doc) ->
+    ["Send several packets to a socket and close it.  All packets should arrive ",
+     "to the other end."];
+close_with_pending_output(suite) -> [];
+close_with_pending_output(Config) when is_list(Config) ->
+    case os:type() of
+	vxworks ->
+	    {skipped,"Too tough for vxworks"};
+	_ ->
+	    close_with_pending_output2()
+    end.
+
+close_with_pending_output2() ->
+    ?line {ok, L} = gen_tcp:listen(0, [binary, {active, false}]),
+    ?line {ok, {_, Port}} = inet:sockname(L),
+    ?line Packets = 16,
+    ?line Total = 2048*Packets,
+    case start_remote(close_pending) of
+	{ok, Node} ->
+	    ?line {ok, Host} = inet:gethostname(),
+	    ?line spawn_link(Node, ?MODULE, sender, [Port, Packets, Host]),
+	    ?line {ok, A} = gen_tcp:accept(L),
+	    ?line case gen_tcp:recv(A, Total) of
+		      {ok, Bin} when byte_size(Bin) == Total ->
+			  gen_tcp:close(A),
+			  gen_tcp:close(L);
+		      {ok, Bin} ->
+			  ?line test_server:fail({small_packet, 
+                                                  byte_size(Bin)});
+		      Error ->
+			  ?line test_server:fail({unexpected, Error})
+		  end,
+	    ok;
+	{error, no_remote_hosts} ->
+	    {skipped,"No remote hosts"};
+	{error, Other} ->
+	    ?line ?t:fail({failed_to_start_slave_node, Other})
+    end.
+
+sender(Port, Packets, Host) ->
+    X256 = lists:seq(0, 255),
+    X512 = [X256|X256],
+    X1K = [X512|X512],
+    Bin = list_to_binary([X1K|X1K]),
+    {ok, Sock} = gen_tcp:connect(Host, Port, []),
+    send_loop(Sock, Bin, Packets),
+    ok = gen_tcp:close(Sock).
+
+send_loop(_Sock, _Data, 0) -> ok;
+send_loop(Sock, Data, Left) ->
+    ok = gen_tcp:send(Sock, Data),
+    send_loop(Sock, Data, Left-1).
+
+-define(OTP_3924_MAX_DELAY, 100).
+%% Taken out of the blue, but on intra host connections
+%% I expect propagation of a close to be quite fast
+%% so 100 ms seems reasonable.
+
+otp_3924(doc) ->
+    ["Tests that a socket can be closed fast enough."];
+otp_3924(suite) -> [];
+otp_3924(Config) when is_list(Config) ->
+    MaxDelay = (case has_superfluous_schedulers() of
+		    true -> 4;
+		    false -> 1
+		end
+		* case {erlang:system_info(debug_compiled),
+			erlang:system_info(lock_checking)} of
+		      {true, _} -> 6;
+		      {_, true} -> 2;
+		      _ -> 1
+		  end * ?OTP_3924_MAX_DELAY),
+    case os:type() of
+	vxworks ->
+%%	    {skip,"Too tough for vxworks"};
+	    otp_3924_1(MaxDelay);
+	_ ->
+	    otp_3924_1(MaxDelay)
+    end.
+
+otp_3924_1(MaxDelay) ->
+    Dog = test_server:timetrap(test_server:seconds(240)),
+    ?line {ok, Node} = start_node(otp_3924),
+    ?line DataLen = 100*1024,
+    ?line Data = otp_3924_data(DataLen),
+    % Repeat the test a couple of times to prevent the test from passing
+    % by chance.
+    repeat(10,
+	   fun (N) ->
+		   ?line ok = otp_3924(MaxDelay, Node, Data, DataLen, N)
+	   end),
+    ?line test_server:stop_node(Node),
+    test_server:timetrap_cancel(Dog),
+    ok.
+
+otp_3924(MaxDelay, Node, Data, DataLen, N) ->
+    ?line {ok, L} = gen_tcp:listen(0, [list, {active, false}]),
+    ?line {ok, {_, Port}} = inet:sockname(L),
+    ?line {ok, Host} = inet:gethostname(),
+    ?line Sender = spawn_link(Node,
+			      ?MODULE,
+			      otp_3924_sender,
+			      [self(), Host, Port, Data]),
+    ?line Data = otp_3924_receive_data(L, Sender, MaxDelay, DataLen, N),
+    ?line ok = gen_tcp:close(L).
+
+otp_3924_receive_data(LSock, Sender, MaxDelay, Len, N) ->
+    ?line OP = process_flag(priority, max),
+    ?line OTE = process_flag(trap_exit, true),
+    ?line TimeoutRef = make_ref(),
+    ?line Data = (catch begin
+			    ?line Sender ! start,
+			    ?line {ok, Sock} = gen_tcp:accept(LSock),
+			    ?line D = otp_3924_receive_data(Sock,
+							    TimeoutRef,
+							    MaxDelay,
+							    Len,
+							    [],
+							    0),
+			    ?line ok = gen_tcp:close(Sock),
+			    D
+			end),
+    ?line unlink(Sender),
+    ?line process_flag(trap_exit, OTE),
+    ?line process_flag(priority, OP),
+    receive
+	{'EXIT', _, TimeoutRef} ->
+	    ?line test_server:fail({close_not_fast_enough,MaxDelay,N});
+	{'EXIT', Sender, Reason} ->
+	    ?line test_server:fail({sender_exited, Reason});
+	{'EXIT', _Other, Reason} ->
+	    ?line test_server:fail({linked_process_exited, Reason})
+    after 0 ->
+	    case Data of
+		{'EXIT', {A,B}} ->
+		    ?line test_server:fail({A,B,N});
+		{'EXIT', Failure} ->
+		    ?line test_server:fail(Failure);
+		_ ->
+		    ?line Data
+	    end
+    end.
+    
+
+otp_3924_receive_data(Sock, TimeoutRef, MaxDelay, Len, Acc, AccLen) ->
+    case gen_tcp:recv(Sock, 0) of
+	{ok, Data} ->
+	    NewAccLen = AccLen + length(Data),
+	    if
+		NewAccLen == Len ->
+		    ?line {ok, TRef} = timer:exit_after(MaxDelay,
+							self(),
+							TimeoutRef),
+		    ?line {error, closed} = gen_tcp:recv(Sock, 0),
+		    ?line timer:cancel(TRef),
+		    ?line lists:flatten([Acc, Data]);
+		NewAccLen > Len ->
+		    exit({received_too_much, NewAccLen});
+		true ->
+		    otp_3924_receive_data(Sock,
+					  TimeoutRef,
+					  MaxDelay,
+					  Len,
+					  [Acc, Data],
+					  NewAccLen)
+	    end;
+	{error, closed} ->
+	    exit({premature_close, AccLen});
+	Error ->
+	    exit({unexpected_error, Error})
+    end.
+    
+otp_3924_data(Size) ->
+    Block =
+	"This is a sequence of characters that will be repeated "
+	"again and again and again and again and again and ...  ",
+    L = length(Block), 
+    otp_3924_data(Block, [], Size div L, Size rem L).
+
+otp_3924_data(_, Acc, 0, 0) ->
+    lists:flatten(Acc);
+otp_3924_data(_, Acc, 0, SingleLeft) ->
+    otp_3924_data(false, ["."|Acc], 0, SingleLeft-1);
+otp_3924_data(Block, Acc, BlockLeft, SingleLeft) ->
+    otp_3924_data(Block, [Block|Acc], BlockLeft-1, SingleLeft).
+
+otp_3924_sender(Receiver, Host, Port, Data) ->
+    receive
+	start ->
+	    {ok, Sock} = gen_tcp:connect(Host, Port, [list]),
+	    gen_tcp:send(Sock, Data),
+	    ok = gen_tcp:close(Sock),
+	    unlink(Receiver)
+    end.
+
+
+data_before_close(doc) ->
+    ["Tests that a huge amount of data can be received before a close."];
+data_before_close(Config) when is_list(Config) ->
+    case os:type() of
+	vxworks ->
+	    {skip,"Too tough for vxworks"};
+	_ ->
+	    data_before_close2()
+    end.
+
+data_before_close2() ->
+    ?line {ok, L} = gen_tcp:listen(0, [binary]),
+    ?line {ok, {_, TcpPort}} = inet:sockname(L),
+    ?line Bytes = 256*1024,
+    ?line spawn_link(fun() -> huge_sender(TcpPort, Bytes) end),
+    ?line {ok, A} = gen_tcp:accept(L),
+    ?line case count_bytes_recv(A, 0) of
+	      {Bytes, Result} ->
+		  io:format("Result: ~p", [Result]);
+	      {Wrong, Result} ->
+		  io:format("Result: ~p", [Result]),
+		  test_server:fail({wrong_count, Wrong})
+	  end,
+    ok.
+
+count_bytes_recv(Sock, Total) ->
+    receive
+	{tcp, Sock, Bin} ->
+	    count_bytes_recv(Sock, Total+byte_size(Bin));
+	Other ->
+	    {Total, Other}
+    end.
+
+huge_sender(TcpPort, Bytes) ->
+    {ok, Client} = gen_tcp:connect(localhost, TcpPort, []),
+    receive after 500 -> ok end,
+    gen_tcp:send(Client, make_zero_packet(Bytes)),
+    gen_tcp:close(Client).
+
+make_zero_packet(0) -> [];
+make_zero_packet(N) when N rem 2 == 0 ->
+    P = make_zero_packet(N div 2),
+    [P|P];
+make_zero_packet(N) ->
+    P = make_zero_packet(N div 2),
+    [0, P|P].
+get_status(doc) ->    
+    ["OTP-2924",
+     "test that the socket process does not crash when sys:get_status(Pid)",
+     "is called."];
+get_status(suite) -> [];
+get_status(Config) when is_list(Config) ->
+    ?line {ok,{socket,Pid,_,_}} = gen_tcp:listen(5678,[]),
+    ?line {status,Pid,_,_} = sys:get_status(Pid).
+
+iter_max_socks(doc) ->
+    ["Open as many sockets as possible. Do this several times and check ",
+     "that we get the same number of sockets every time."];
+iter_max_socks(Config) when is_list(Config) ->
+    case os:type() of
+	vxworks ->
+	    {skip,"Too tough for vxworks"};
+	_ ->
+	    iter_max_socks2()
+    end.
+
+-define(RECOVER_SLEEP, 60000).
+-define(RETRY_SLEEP, 15000).
+
+iter_max_socks2() ->
+    ?line N = 
+	case os:type() of
+	    vxworks ->
+		10;
+	    _ ->
+		20
+	end,
+    L = do_iter_max_socks(N, initalize),
+    ?line io:format("Result: ~p",[L]),
+    ?line all_equal(L),
+    ?line {comment, "Max sockets: " ++ integer_to_list(hd(L))}.
+
+do_iter_max_socks(0, _) ->
+    [];
+do_iter_max_socks(N, initalize) ->
+    MS = max_socks(),
+    [MS|do_iter_max_socks(N-1, MS)];
+do_iter_max_socks(N, failed) ->
+    MS = max_socks(),
+    [MS|do_iter_max_socks(N-1, failed)];
+do_iter_max_socks(N, First) when is_integer(First) ->
+    ?line MS = max_socks(),
+    if MS == First -> 
+	    ?line [MS|do_iter_max_socks(N-1, First)];
+       true ->
+	    ?line io:format("Sleeping for ~p seconds...~n",
+			    [?RETRY_SLEEP/1000]), 
+	    ?line ?t:sleep(?RETRY_SLEEP),
+	    ?line io:format("Trying again...~n", []),
+	    ?line RetryMS = max_socks(),
+	    ?line if RetryMS == First ->
+			  ?line [RetryMS|do_iter_max_socks(N-1, First)];
+		     true ->
+			  ?line [RetryMS|do_iter_max_socks(N-1, failed)]
+		  end
+    end.
+
+all_equal([]) ->
+    ok;
+all_equal([Rule | T]) ->
+    all_equal(Rule, T).
+
+all_equal(Rule, [Rule | T]) ->
+    all_equal(Rule, T);
+all_equal(_, [_ | _]) ->
+    ?line ?t:sleep(?RECOVER_SLEEP), % Wait a while and *hope* that we'll
+                                    % recover so other tests won't be
+                                    % affected.
+    ?t:fail(max_socket_mismatch);
+all_equal(_Rule, []) ->
+    ok.
+
+max_socks() ->
+    ?line Socks = open_socks(),
+    ?line N = length(Socks),
+    ?line lists:foreach(fun(S) -> ok = gen_tcp:close(S) end, Socks),
+    io:format("Got ~p sockets", [N]),
+    N.
+
+open_socks() ->
+    case gen_tcp:listen(0, []) of
+	{ok, L} ->
+	    {ok, {_, Port}} = inet:sockname(L),
+	    [L| connect_accept(L, Port)];
+	_ ->
+	    []
+    end.
+
+connect_accept(L, Port) ->
+    case gen_tcp:connect(localhost, Port, []) of
+	{ok, C} ->
+	    [C| do_accept(L, Port)];
+	_ ->
+	    []
+    end.
+
+do_accept(L, Port) ->
+    case gen_tcp:accept(L) of
+	{ok, A} -> [A| connect_accept(L, Port)];
+	_ -> []
+    end.
+
+start_node(Name) ->
+    Pa = filename:dirname(code:which(?MODULE)),
+    test_server:start_node(Name, slave, [{args, "-pa " ++ Pa}]).
+
+start_remote(Name) ->
+    Pa = filename:dirname(code:which(?MODULE)),
+    test_server:start_node(Name, slave, [{remote, true}, {args, "-pa " ++ Pa}]).
+
+passive_sockets(doc) ->
+    ["Tests that when 'the other side' on a passive socket closes, the connecting",
+     "side still can read until the end of data."];
+passive_sockets(Config) when is_list(Config) ->
+    ?line spawn_link(?MODULE, passive_sockets_server,
+		     [[{active,false}],self()]),
+    ?line receive
+	      {socket,Port} -> ok
+	  end,
+    ?t:sleep(500),
+    ?line case gen_tcp:connect("localhost", Port, [{active, false}]) of
+	      {ok, Sock} ->
+		  passive_sockets_read(Sock);
+	      Error ->
+		  ?t:fail({"Could not connect to server", Error})
+	  end.
+
+%%
+%% Read until we get an {error, closed}. If we get another error, this test case
+%% should fail.
+%%
+passive_sockets_read(Sock) ->
+    case gen_tcp:recv(Sock, 0, 2000) of
+	{ok, Data} ->
+	    io:format("Received ~p bytes~n", [length(Data)]),
+	    passive_sockets_read(Sock);
+	{error, closed} ->
+	    gen_tcp:close(Sock);
+	Error ->
+	    gen_tcp:close(Sock),
+	    ?t:fail({"Did not get {error, closed} before other error", Error})
+    end.
+
+passive_sockets_server(Opts, Parent) ->
+    ?line case gen_tcp:listen(0, Opts) of
+	      {ok, LSock} ->
+		  {ok,{_,Port}} = inet:sockname(LSock),
+		  Parent ! {socket,Port},
+		  passive_sockets_server_accept(LSock);
+	      Error ->
+		  ?t:fail({"Could not create listen socket", Error})
+	  end.
+
+passive_sockets_server_accept(Sock) ->
+    ?line case gen_tcp:accept(Sock) of
+	      {ok, Socket} ->
+		  ?t:sleep(500),   % Simulate latency
+		  passive_sockets_server_send(Socket, 5),
+		  passive_sockets_server_accept(Sock);
+	      Error ->
+		  ?t:fail({"Could not accept connection", Error})
+	  end.
+
+passive_sockets_server_send(Socket, 0) ->
+    io:format("Closing other end..~n", []),
+    gen_tcp:close(Socket);
+passive_sockets_server_send(Socket, X) ->
+    ?line Data = lists:duplicate(1024*X, $a),
+    ?line case gen_tcp:send(Socket, Data) of
+	      ok ->
+		  ?t:sleep(50),   % Simulate some processing.
+		  passive_sockets_server_send(Socket, X-1);
+	      {error, _Reason} ->
+		  ?t:fail("Failed to send data")
+	  end.
+
+
+accept_closed_by_other_process(doc) ->
+    ["Tests the return value from gen_tcp:accept when ",
+     "the socket is closed from an other process. (OTP-3817)"];
+accept_closed_by_other_process(Config) when is_list(Config) ->
+    ?line Parent = self(),
+    ?line {ok, ListenSocket} = gen_tcp:listen(0, []),
+    ?line Child = 
+	spawn_link(
+	  fun() ->
+		  Parent ! {self(), gen_tcp:accept(ListenSocket)}
+	  end),
+    ?line receive after 1000 -> ok end,
+    ?line ok = gen_tcp:close(ListenSocket),
+    ?line receive
+	      {Child, {error, closed}} ->
+		  ok;
+	      {Child, Other} ->
+		  ?t:fail({"Wrong result of gen_tcp:accept", Other})
+	  end.
+
+repeat(N, Fun) ->
+    repeat(N, N, Fun).
+
+repeat(N, T, Fun) when is_integer(N), N > 0 ->
+    Fun(T-N),
+    repeat(N-1, T, Fun);
+repeat(_, _, _) ->
+    ok.
+
+
+closed_socket(suite) ->
+    [];
+closed_socket(doc) ->
+    ["Tests the response when using a closed socket as argument"];
+closed_socket(Config) when is_list(Config) ->
+    ?line {ok, LS1} = gen_tcp:listen(0, []),
+    ?line erlang:yield(),
+    ?line ok = gen_tcp:close(LS1),
+    %% If the following delay is uncommented, the result error values
+    %% below will change from {error, einval} to {error, closed} since
+    %% inet_db then will have noticed that the socket is closed.
+    %% This is a scheduling issue, i.e when the gen_server in 
+    %% in inet_db processes the 'EXIT' message from the port,
+    %% the socket is unregistered.
+    %%
+    %% ?line test_server:sleep(test_server:seconds(2)),
+    %%
+    ?line {error, R_send} = gen_tcp:send(LS1, "data"),
+    ?line {error, R_recv} = gen_tcp:recv(LS1, 17),
+    ?line {error, R_accept} = gen_tcp:accept(LS1),
+    ?line {error, R_controlling_process} = 
+	gen_tcp:controlling_process(LS1, self()),
+    %%
+    ?line ok = io:format("R_send = ~p~n", [R_send]),
+    ?line ok = io:format("R_recv = ~p~n", [R_recv]),
+    ?line ok = io:format("R_accept = ~p~n", [R_accept]),
+    ?line ok = io:format("R_controlling_process = ~p~n", 
+			 [R_controlling_process]),
+    ok.
+
+%%%
+%%% Test using the gen_tcp:shutdown/2 function using a sort server.
+%%% 
+
+shutdown_active(Config) when is_list(Config) ->
+    ?line shutdown_common(true).
+
+shutdown_passive(Config) when is_list(Config) ->
+    ?line shutdown_common(false).
+
+shutdown_common(Active) ->
+    ?line P = sort_server(Active),
+    io:format("Sort server port: ~p\n", [P]),
+
+    ?line do_sort(P, []),
+    ?line do_sort(P, ["glurf"]),
+    ?line do_sort(P, ["abc","nisse","dum"]),
+
+    ?line do_sort(P, [lists:reverse(integer_to_list(I)) || I <- lists:seq(25, 255)]),
+    ?line do_sort(P, [lists:reverse(integer_to_list(I)) || I <- lists:seq(77, 999)]),
+    ?line do_sort(P, [lists:reverse(integer_to_list(I)) || I <- lists:seq(25, 55)]),
+    ?line do_sort(P, []),
+    ?line do_sort(P, ["apa"]),
+    ?line do_sort(P, ["kluns","gorilla"]),
+    ?line do_sort(P, [lists:reverse(integer_to_list(I)) || I <- lists:seq(25, 1233)]),
+    ?line do_sort(P, []),
+
+    receive
+	Any ->
+	    ?t:fail({unexpected_message,Any})
+    after 0 -> ok
+    end.
+
+do_sort(P, List0) ->
+    List = [El++"\n" || El <- List0],
+    {ok,S} = gen_tcp:connect(localhost, P, [{packet,line}]),
+    send_lines(S, List),
+    gen_tcp:shutdown(S, write),
+    Lines = collect_lines(S, true),
+    io:format("~p\n", [Lines]),
+    Lines = lists:sort(List),
+    ok = gen_tcp:close(S).
+
+sort_server(Active) ->
+    Opts = [{exit_on_close,false},{packet,line},{active,Active}],
+    ?line {ok,L} = gen_tcp:listen(0, Opts),
+    Go = make_ref(),
+    ?line Pid = spawn_link(fun() ->
+				   receive Go -> sort_server_1(L, Active) end
+			   end),
+    ?line ok = gen_tcp:controlling_process(L, Pid),
+    ?line Pid ! Go,
+    ?line {ok,Port} = inet:port(L),
+    Port.
+
+sort_server_1(L, Active) ->
+    {ok,S} = gen_tcp:accept(L),
+    Go = make_ref(),
+    Sorter = spawn(fun() -> receive Go -> sorter(S, Active) end end),
+    ok = gen_tcp:controlling_process(S, Sorter),
+    Sorter ! Go,
+    sort_server_1(L, Active).
+
+sorter(S, Active) ->
+    Lines = collect_lines(S, Active),
+    send_lines(S, lists:sort(Lines)),
+    gen_tcp:shutdown(S, write),
+    gen_tcp:close(S).
+
+collect_lines(S, true) ->
+    collect_lines_1(S, []);
+collect_lines(S, false) ->
+    passive_collect_lines_1(S, []).
+
+collect_lines_1(S, Acc) ->
+    receive
+	{tcp,S,Line} -> collect_lines_1(S, [Line|Acc]);
+	{tcp_closed,S} -> lists:reverse(Acc)
+    end.
+
+passive_collect_lines_1(S, Acc) ->
+    case gen_tcp:recv(S, 0) of
+	{ok,Line} -> passive_collect_lines_1(S, [Line|Acc]);
+	{error,closed} -> lists:reverse(Acc)
+    end.
+
+
+send_lines(S, Lines) ->    
+    lists:foreach(fun(Line) ->
+			  gen_tcp:send(S, Line)
+		  end, Lines).
+
+%%%
+%%% Shutdown pending.
+%%%
+
+shutdown_pending(Config) when is_list(Config) ->
+    N = 512*1024+17,
+    io:format("~p\n", [N]),
+    Data = [<<N:32>>,ones(N),42],
+    P = a_server(),
+    io:format("Server port: ~p\n", [P]),
+    ?line {ok,S} = gen_tcp:connect(localhost, P, []),
+    ?line gen_tcp:send(S, Data),
+    ?line gen_tcp:shutdown(S, write),
+    ?line receive
+	      {tcp,S,Msg} ->
+		  io:format("~p\n", [Msg]),
+		  ?line N = list_to_integer(Msg) - 5;
+	      Other ->
+		  ?t:fail({unexpected,Other})
+	  end,
+     ok.
+
+ ones(0) -> [];
+ ones(1) -> [1];
+ ones(N) ->
+     Half = N div 2,
+     Ones = ones(Half),
+     case 2*Half of
+	 N -> [Ones|Ones];
+	 _ -> [1,Ones|Ones]
+     end.
+
+ a_server() ->
+     ?line {ok,L} = gen_tcp:listen(0, [{exit_on_close,false},{active,false}]),
+     ?line Pid = spawn_link(fun() -> a_server(L) end),
+     ?line ok = gen_tcp:controlling_process(L, Pid),
+     ?line {ok,Port} = inet:port(L),
+     Port.
+
+ a_server(L) ->
+     {ok,S} = gen_tcp:accept(L),
+     do_recv(S, []).
+
+ do_recv(S, Bs0) ->
+     case gen_tcp:recv(S, 0) of
+	 {ok,B} ->
+	     do_recv(S, [Bs0,B]);
+	 {error,closed} ->
+	     Bs = list_to_binary(Bs0),
+	     gen_tcp:send(S, integer_to_list(byte_size(Bs))),
+	     gen_tcp:close(S)
+     end.
+
+
+%% Thanks to Luke Gorrie. Tests for a very specific problem with 
+%% corrupt data. The testcase will be killed by the timetrap timeout
+%% if the bug is present.
+http_bad_packet(Config) when is_list(Config) ->
+    ?line {ok,L} = gen_tcp:listen(0,
+				  [{active, false},
+				   binary,
+				   {reuseaddr, true},
+				   {packet, http}]),
+    ?line {ok,Port} = inet:port(L),
+    ?line spawn_link(fun() -> erlang:yield(), http_bad_client(Port) end),
+    ?line case gen_tcp:accept(L) of
+	      {ok,S} ->
+		  http_worker(S);
+	      Err ->
+		  exit({accept,Err})
+	  end.
+
+http_worker(S) ->
+    case gen_tcp:recv(S, 0, 30000) of
+	{ok,Data} ->
+	    io:format("Data: ~p\n", [Data]),
+	    http_worker(S);
+	{error,Rsn} ->
+	    io:format("Error: ~p\n", [Rsn]),
+	    ok
+    end.
+
+http_bad_client(Port) ->
+    {ok,S} = gen_tcp:connect("localhost", Port, [{active,false}, binary]),
+    ok = gen_tcp:send(S, "\r\n"),
+    ok = gen_tcp:close(S).
+
+
+%% Fill send queue and then start receiving.
+%%
+busy_send(Config) when is_list(Config) ->
+    ?line Master = self(),
+    ?line Msg = <<"the quick brown fox jumps over a lazy dog~n">>,
+    ?line Server =
+	spawn_link(fun () ->
+			   {ok,L} = gen_tcp:listen
+				      (0, [{active,false},binary,
+					   {reuseaddr,true},{packet,0}]),
+			   {ok,Port} = inet:port(L),
+			   Master ! {self(),client,
+				     busy_send_client(Port, Master, Msg)},
+			   busy_send_srv(L, Master, Msg)
+		   end),
+    ?line io:format("~p Server~n", [Server]),
+    ?line receive 
+	      {Server,client,Client} ->
+		  ?line io:format("~p Client~n", [Client]),
+		  ?line busy_send_loop(Server, Client, 0)
+	  end.
+
+busy_send_loop(Server, Client, N) ->
+    %% Master
+    %%
+    ?line receive {Server,send} ->
+		  busy_send_loop(Server, Client, N+1)
+	  after 2000 ->
+		  %% Send queue full, sender blocked 
+		  %% -> stop sender and release client
+		  ?line io:format("Send timeout, time to receive...~n", []),
+		  ?line Server ! {self(),close},
+		  ?line Client ! {self(),recv,N+1},
+		  ?line receive
+			    {Server,send} ->
+				?line busy_send_2(Server, Client, N+1)
+			after 10000 ->
+				?t:fail({timeout,{server,not_send,flush([])}})
+			end
+	  end.
+
+busy_send_2(Server, Client, _N) ->
+    %% Master
+    %%
+    ?line receive
+	      {Server,[closed]} ->
+		  ?line receive 
+			    {Client,[0,{error,closed}]} -> 
+				ok 
+			end
+	  after 10000 ->
+		  ?t:fail({timeout,{server,not_closed,flush([])}})
+	  end.
+
+busy_send_srv(L, Master, Msg) ->
+    %% Server
+    %%
+    {ok,Socket} = gen_tcp:accept(L),
+    busy_send_srv_loop(Socket, Master, Msg).
+
+busy_send_srv_loop(Socket, Master, Msg) ->
+    %% Server
+    %%
+    receive
+	{Master,close} ->
+	    ok = gen_tcp:close(Socket),
+	    Master ! {self(),flush([closed])}
+    after 0 ->
+	    ok = gen_tcp:send(Socket, Msg),
+	    Master ! {self(),send},
+	    busy_send_srv_loop(Socket, Master, Msg)
+    end.
+
+busy_send_client(Port, Master, Msg) ->    
+    %% Client
+    %%
+    spawn_link(
+      fun () ->
+	      {ok,Socket} = gen_tcp:connect(
+			 "localhost", Port,
+			 [{active,false},binary,{packet,0}]),
+	      receive
+		  {Master,recv, N} ->
+		      busy_send_client_loop(Socket, Master, Msg, N)
+	      end
+      end).
+
+busy_send_client_loop(Socket, Master, Msg, N) ->
+    %% Client
+    %%
+    Size = byte_size(Msg),
+    case gen_tcp:recv(Socket, Size) of
+	{ok,Msg} ->
+	    busy_send_client_loop(Socket, Master, Msg, N-1);
+	Other ->
+	    Master ! {self(),flush([Other,N])}
+    end.
+
+%%%
+%%% Send to a socket whose other end does not read until the port gets busy.
+%%% Then close the other end. The writer should get an {error,closed} error.
+%%% (Passive mode.)
+%%%
+
+busy_disconnect_passive(Config) when is_list(Config) ->
+    MuchoData = list_to_binary(ones(64*1024)),
+    ?line [do_busy_disconnect_passive(MuchoData) || _ <- lists:seq(1, 10)],
+    ok.
+
+do_busy_disconnect_passive(MuchoData) ->
+    S = busy_disconnect_prepare_server([{active,false}]),
+    busy_disconnect_passive_send(S, MuchoData).
+
+busy_disconnect_passive_send(S, Data) ->
+    ?line case gen_tcp:send(S, Data) of
+	ok -> ?line busy_disconnect_passive_send(S, Data);
+	{error,closed} -> ok
+    end.
+
+%%%
+%%% Send to a socket whose other end does not read until the port gets busy.
+%%% Then close the other end. The writer should get an {error,closed} error and
+%%% a {tcp_closed,Socket} message. (Active mode.)
+%%%
+busy_disconnect_active(Config) when is_list(Config) ->
+    MuchoData = list_to_binary(ones(64*1024)),
+    ?line [do_busy_disconnect_active(MuchoData) || _ <- lists:seq(1, 10)],
+    ok.
+
+do_busy_disconnect_active(MuchoData) ->
+    S = busy_disconnect_prepare_server([{active,true}]),
+    busy_disconnect_active_send(S, MuchoData).
+
+busy_disconnect_active_send(S, Data) ->
+    ?line case gen_tcp:send(S, Data) of
+	ok -> ?line busy_disconnect_active_send(S, Data);
+	{error,closed} ->
+	    receive
+		{tcp_closed,S} -> ok;
+		_Other -> ?line ?t:fail()
+	    end
+    end.
+
+
+busy_disconnect_prepare_server(ConnectOpts) ->
+    ?line Sender = self(),
+    ?line Server = spawn_link(fun() -> busy_disconnect_server(Sender) end),
+    receive {port,Server,Port} -> ok end,
+    ?line {ok,S} = gen_tcp:connect(localhost, Port, ConnectOpts),
+    Server ! {Sender,sending},
+    S.
+
+busy_disconnect_server(Sender) ->
+    {ok,L} = gen_tcp:listen(0, [{active,false},binary,{reuseaddr,true},{packet,0}]),
+    {ok,Port} = inet:port(L),
+    Sender ! {port,self(),Port},
+    {ok,S} = gen_tcp:accept(L),
+    receive
+	{Sender,sending} ->
+	    busy_disconnect_server_wait_for_busy(Sender, S)
+    end.
+
+%% Close the socket as soon as the Sender process can't send because of
+%% a busy port.
+busy_disconnect_server_wait_for_busy(Sender, S) ->
+    case process_info(Sender, status) of
+	{status,waiting} ->
+	    %% We KNOW that the sender will be in state 'waiting' only
+	    %% if the port has become busy. (Fallback solution if the
+	    %% implementation changes: Watch Sender's reduction count;
+	    %% when it stops changing, wait 2 seconds and then close.)
+	    gen_tcp:close(S);
+	_Other ->
+	    io:format("~p\n", [_Other]),
+	    timer:sleep(100),
+	    busy_disconnect_server_wait_for_busy(Sender, S)
+    end.
+
+%%%
+%%% Fill send queue
+%%%
+fill_sendq(Config) when is_list(Config) ->
+    ?line Master = self(),
+    ?line Server = 
+	spawn_link(fun () ->
+			   {ok,L} = gen_tcp:listen
+				      (0, [{active,false},binary,
+					   {reuseaddr,true},{packet,0}]),
+			   {ok,Port} = inet:port(L),
+			   Master ! {self(),client,
+				     fill_sendq_client(Port, Master)},
+			   fill_sendq_srv(L, Master)
+		   end),
+    ?line io:format("~p Server~n", [Server]),
+    ?line receive {Server,client,Client} ->
+		  ?line io:format("~p Client~n", [Client]),
+		  ?line receive {Server,reader,Reader} ->
+				?line io:format("~p Reader~n", [Reader]),
+				?line fill_sendq_loop(Server, Client, Reader)
+	    end
+    end.
+
+fill_sendq_loop(Server, Client, Reader) ->
+    %% Master
+    %%
+    receive {Server,send} ->
+	    fill_sendq_loop(Server, Client, Reader)
+    after 2000 ->
+	    %% Send queue full, sender blocked -> close client.
+	    ?line io:format("Send timeout, closing Client...~n", []),
+	    ?line Client ! {self(),close},
+	    ?line receive {Server,[{error,closed}]} ->
+			  ?line io:format("Got server closed.~n"),
+			  ?line receive {Reader,[{error,closed}]} ->
+					?line io:format
+						("Got reader closed.~n"),
+					ok
+				after 3000 ->
+					?t:fail({timeout,{closed,reader}})
+				end;
+			  {Reader,[{error,closed}]} ->
+			  ?line io:format("Got reader closed.~n"),
+			  ?line receive {Server,[{error,closed}]} ->
+					?line io:format("Got server closed~n"),
+					ok
+				after 3000 ->
+					?t:fail({timeout,{closed,server}})
+				end
+		  after 3000 ->
+			  ?t:fail({timeout,{closed,[server,reader]}})
+		  end
+    end.
+
+fill_sendq_srv(L, Master) ->
+    %% Server
+    %%
+    case gen_tcp:accept(L) of
+	{ok,S} ->
+	    Master ! {self(),reader,
+		      spawn_link(fun () -> fill_sendq_read(S, Master) end)},
+	    Msg = "the quick brown fox jumps over a lazy dog~n",
+	    fill_sendq_write(S, Master, [Msg,Msg,Msg,Msg,Msg,Msg,Msg,Msg]);
+	Error ->
+	    io:format("~p error: ~p.~n", [self(),Error]),
+	    Master ! {self(),flush([Error])}
+    end.
+
+fill_sendq_write(S, Master, Msg) ->
+    %% Server
+    %%
+    %%io:format("~p sending...~n", [self()]),
+    Master ! {self(),send},
+    case gen_tcp:send(S, Msg) of
+	ok ->
+	    %%io:format("~p ok.~n", [self()]),
+	    fill_sendq_write(S, Master, Msg);
+	E ->
+	    Error = flush([E]),
+	    io:format("~p error: ~p.~n", [self(),Error]),
+	    Master ! {self(),Error}
+    end.
+
+fill_sendq_read(S, Master) ->
+    %% Reader
+    %%
+    io:format("~p read infinity...~n", [self()]),
+    case gen_tcp:recv(S, 0, infinity) of
+	{ok,Data} ->
+	    io:format("~p got: ~p.~n", [self(),Data]),
+	    fill_sendq_read(S, Master);
+	E ->
+	    Error = flush([E]),
+	    io:format("~p error: ~p.~n", [self(),Error]),
+	    Master ! {self(),Error}
+    end.
+
+fill_sendq_client(Port, Master) ->
+    %% Client
+    %%
+    spawn_link(fun () ->
+		       %% Just close on order
+		       {ok,S} = gen_tcp:connect(
+				  "localhost", Port,
+				  [{active,false},binary,{packet,0}]),
+		       receive
+			   {Master,close} ->
+			       ok = gen_tcp:close(S)
+		       end
+	       end).
+
+%%% Try to receive more than available number of bytes from 
+%%% a closed socket.
+%%%
+partial_recv_and_close(Config) when is_list(Config) ->
+    ?line Msg = "the quick brown fox jumps over a lazy dog 0123456789\n",
+    ?line Len = length(Msg),
+    ?line {ok,L} = gen_tcp:listen(0, [{active,false}]),
+    ?line {ok,P} = inet:port(L),
+    ?line {ok,S} = gen_tcp:connect("localhost", P, [{active,false}]),
+    ?line {ok,A} = gen_tcp:accept(L),
+    ?line ok = gen_tcp:send(S, Msg),
+    ?line ok = gen_tcp:close(S),
+    ?line {error,closed} = gen_tcp:recv(A, Len+1),
+    ok.
+
+%%% Try to receive more than available number of bytes from 
+%%% a closed socket, this time waiting in the recv before closing.
+%%%
+partial_recv_and_close_2(Config) when is_list(Config) ->
+    ?line Msg = "the quick brown fox jumps over a lazy dog 0123456789\n",
+    ?line Len = length(Msg),
+    ?line {ok,L} = gen_tcp:listen(0, [{active,false}]),
+    ?line {ok,P} = inet:port(L),
+    ?line Server = self(),
+    ?line Client = 
+	spawn_link(
+	  fun () ->
+		  receive after 2000 -> ok end,
+		  {ok,S} = gen_tcp:connect("localhost", P, [{active,false}]),
+		  ?line ok = gen_tcp:send(S, Msg),
+		  receive {Server,close} -> ok end,
+		  receive after 2000 -> ok end,
+		  ?line ok = gen_tcp:close(S)
+	  end),
+    ?line {ok,A} = gen_tcp:accept(L),
+    ?line Client ! {Server,close},
+    ?line {error,closed} = gen_tcp:recv(A, Len+1),
+    ok.
+
+%%% Here we tests that gen_tcp:recv/2 will return {error,closed} following
+%%% a send operation of a huge amount data when the other end closed the socket.
+%%%
+partial_recv_and_close_3(Config) when is_list(Config) ->
+    [do_partial_recv_and_close_3() || _ <- lists:seq(0, 20)],
+    ok.
+
+do_partial_recv_and_close_3() ->
+    Parent = self(),
+    spawn_link(fun() ->
+		       {ok,L} = gen_tcp:listen(0, [{active,false}]),
+		       {ok,{_,Port}} = inet:sockname(L),
+		       Parent ! {port,Port},
+		       {ok,S} = gen_tcp:accept(L),
+		       gen_tcp:recv(S, 1),
+		       gen_tcp:close(S)
+	       end),
+    receive
+	{port,Port} -> ok
+    end,
+    ?line Much = ones(8*64*1024),
+    ?line {ok,S} = gen_tcp:connect(localhost, Port, [{active,false}]),
+
+    %% Send a lot of data (most of it will be queued). The receiver will read one byte
+    %% and close the connection. The write operation will fail.
+    ?line gen_tcp:send(S, Much),
+
+    %% We should always get {error,closed} here.
+    ?line {error,closed} = gen_tcp:recv(S, 0).
+    
+
+test_prio_put_get() ->
+    Tos = 3 bsl 5,
+    ?line {ok,L1} = gen_tcp:listen(0, [{active,false}]),
+    ?line ok = inet:setopts(L1,[{priority,3}]),
+    ?line ok = inet:setopts(L1,[{tos,Tos}]),
+    ?line {ok,[{priority,3},{tos,Tos}]} = inet:getopts(L1,[priority,tos]),
+    ?line ok = inet:setopts(L1,[{priority,3}]), % Dont destroy each other
+    ?line {ok,[{priority,3},{tos,Tos}]} = inet:getopts(L1,[priority,tos]),
+    ?line ok = inet:setopts(L1,[{reuseaddr,true}]), % Dont let others destroy
+    ?line {ok,[{priority,3},{tos,Tos}]} = inet:getopts(L1,[priority,tos]),
+    ?line gen_tcp:close(L1),
+    ok.
+test_prio_accept() ->
+    ?line {ok,Sock}=gen_tcp:listen(0,[binary,{packet,0},{active,false},
+					 {reuseaddr,true},{priority,4}]),
+    ?line {ok,Port} = inet:port(Sock),
+    ?line {ok,Sock2}=gen_tcp:connect("localhost",Port,[binary,{packet,0},
+						       {active,false},
+						       {reuseaddr,true},
+						       {priority,4}]),
+    ?line {ok,Sock3}=gen_tcp:accept(Sock),
+    ?line {ok,[{priority,4}]} = inet:getopts(Sock,[priority]),
+    ?line {ok,[{priority,4}]} = inet:getopts(Sock2,[priority]),
+    ?line {ok,[{priority,4}]} = inet:getopts(Sock3,[priority]),
+    ?line gen_tcp:close(Sock),
+    ?line gen_tcp:close(Sock2),
+    ?line gen_tcp:close(Sock3),
+    ok.
+
+test_prio_accept2() ->
+    Tos1 = 4 bsl 5,
+    Tos2 = 3 bsl 5,
+    ?line {ok,Sock}=gen_tcp:listen(0,[binary,{packet,0},{active,false},
+					 {reuseaddr,true},{priority,4},
+					 {tos,Tos1}]),
+    ?line {ok,Port} = inet:port(Sock),
+    ?line {ok,Sock2}=gen_tcp:connect("localhost",Port,[binary,{packet,0},
+						       {active,false},
+						       {reuseaddr,true},
+						       {priority,4},
+						       {tos,Tos2}]),
+    ?line {ok,Sock3}=gen_tcp:accept(Sock),
+    ?line {ok,[{priority,4},{tos,Tos1}]} = inet:getopts(Sock,[priority,tos]),
+    ?line {ok,[{priority,4},{tos,Tos2}]} = inet:getopts(Sock2,[priority,tos]),
+    ?line {ok,[{priority,4},{tos,Tos1}]} = inet:getopts(Sock3,[priority,tos]),
+    ?line gen_tcp:close(Sock),
+    ?line gen_tcp:close(Sock2),
+    ?line gen_tcp:close(Sock3),
+    ok.
+
+test_prio_accept3() ->
+    Tos1 = 4 bsl 5,
+    Tos2 = 3 bsl 5,
+    ?line {ok,Sock}=gen_tcp:listen(0,[binary,{packet,0},{active,false},
+				      {reuseaddr,true},
+				      {tos,Tos1}]),
+    ?line {ok,Port} = inet:port(Sock),
+    ?line {ok,Sock2}=gen_tcp:connect("localhost",Port,[binary,{packet,0},
+						       {active,false},
+						       {reuseaddr,true},
+						       {tos,Tos2}]),
+    ?line {ok,Sock3}=gen_tcp:accept(Sock),
+    ?line {ok,[{priority,0},{tos,Tos1}]} = inet:getopts(Sock,[priority,tos]),
+    ?line {ok,[{priority,0},{tos,Tos2}]} = inet:getopts(Sock2,[priority,tos]),
+    ?line {ok,[{priority,0},{tos,Tos1}]} = inet:getopts(Sock3,[priority,tos]),
+    ?line gen_tcp:close(Sock),
+    ?line gen_tcp:close(Sock2),
+    ?line gen_tcp:close(Sock3),
+    ok.
+    
+test_prio_accept_async() ->
+    Tos1 = 4 bsl 5,
+    Tos2 = 3 bsl 5,
+    Ref = make_ref(),
+    ?line spawn(?MODULE,priority_server,[{self(),Ref}]),
+    ?line Port = receive 
+		     {Ref,P} -> P 
+		 after 5000 -> ?t:fail({error,"helper process timeout"}) 
+		 end,
+    ?line receive
+	  after 3000 -> ok
+	  end,
+    ?line {ok,Sock2}=gen_tcp:connect("localhost",Port,[binary,{packet,0},
+						       {active,false},
+						       {reuseaddr,true},
+						       {priority,4},
+						       {tos,Tos2}]),
+    ?line receive 
+	      {Ref,{ok,[{priority,4},{tos,Tos1}]}} -> 
+		  ok ;
+	      {Ref,Error} ->
+		   ?t:fail({missmatch,Error})
+	  after 5000 -> ?t:fail({error,"helper process timeout"}) 
+	  end,
+    ?line receive 
+	      {Ref,{ok,[{priority,4},{tos,Tos1}]}} -> 
+		  ok ;
+	      {Ref,Error2} ->
+		   ?t:fail({missmatch,Error2})
+	  after 5000 -> ?t:fail({error,"helper process timeout"}) 
+	  end,
+    
+    ?line {ok,[{priority,4},{tos,Tos2}]} = inet:getopts(Sock2,[priority,tos]),
+    ?line catch gen_tcp:close(Sock2),
+    ok.
+
+priority_server({Parent,Ref}) ->
+    Tos1 = 4 bsl 5,
+    ?line {ok,Sock}=gen_tcp:listen(0,[binary,{packet,0},{active,false},
+				      {reuseaddr,true},{priority,4},
+				      {tos,Tos1}]),
+    ?line {ok,Port} = inet:port(Sock),
+    Parent ! {Ref,Port},
+    ?line {ok,Sock3}=gen_tcp:accept(Sock),
+    Parent ! {Ref, inet:getopts(Sock,[priority,tos])},
+    Parent ! {Ref, inet:getopts(Sock3,[priority,tos])},
+    ok.
+
+test_prio_fail() ->
+    ?line {ok,L} = gen_tcp:listen(0, [{active,false}]),
+    ?line {error,_} = inet:setopts(L,[{priority,1000}]),
+%   This error could only happen in linux kernels earlier than 2.6.24.4
+%   Privilege check is now disabled and IP_TOS can never fail (only silently
+%   be masked).
+%   ?line {error,_} = inet:setopts(L,[{tos,6 bsl 5}]),
+    ?line gen_tcp:close(L),
+    ok.
+
+test_prio_udp() ->
+    Tos = 3 bsl 5,
+    ?line {ok,S} = gen_udp:open(0,[{active,false},binary,{tos, Tos}, 
+				   {priority,3}]),
+    ?line {ok,[{priority,3},{tos,Tos}]} = inet:getopts(S,[priority,tos]),
+    ?line gen_udp:close(S),
+    ok.
+
+so_priority(doc) ->
+    ["Tests the so_priority and ip_tos options on sockets when applicable."];
+so_priority(suite) ->
+    [];
+so_priority(Config) when is_list(Config) ->
+    ?line {ok,L} = gen_tcp:listen(0, [{active,false}]),
+    ?line ok = inet:setopts(L,[{priority,1}]),
+    ?line case inet:getopts(L,[priority]) of
+	{ok,[{priority,1}]} ->
+	    gen_tcp:close(L),
+	    test_prio_put_get(),
+	    test_prio_accept(),
+	    test_prio_accept2(),
+	    test_prio_accept3(),
+	    test_prio_accept_async(),
+	    test_prio_fail(),
+	    test_prio_udp(),
+	    ok;
+	_ ->
+	    case os:type() of
+		{unix,linux} ->
+		    case os:version() of
+			{X,Y,_} when (X > 2) or ((X =:= 2) and (Y >= 4)) ->
+			    ?line ?t:fail({error,
+					   "so_priority should work on this "
+					   "OS, but does not"});
+			_ ->
+			    {skip, "SO_PRIORITY not suppoorted"}
+		    end;
+		_ ->
+		   {skip, "SO_PRIORITY not suppoorted"}
+	    end
+    end.
+
+%% Accept test utilities (suites are below)
+
+millis() ->
+    {A,B,C}=erlang:now(),
+    (A*1000000*1000)+(B*1000)+(C div 1000).
+	
+collect_accepts(Tmo) ->
+    A = millis(),
+    receive
+	{accepted,P,Msg} ->
+	    [{P,Msg}] ++ collect_accepts(Tmo-(millis() - A))
+    after Tmo ->
+	    []
+    end.
+   
+-define(EXPECT_ACCEPTS(Pattern,Timeout),
+	(fun() ->
+		 case collect_accepts(Timeout) of
+		     Pattern ->
+			 ok;
+		     Other ->
+			 {error,{unexpected,{Other,process_info(self(),messages)}}}
+		 end
+	 end)()).
+	
+collect_connects(Tmo) ->
+    A = millis(),
+    receive
+	{connected,P,Msg} ->
+	    [{P,Msg}] ++ collect_connects(Tmo-(millis() - A))
+    after Tmo ->
+	    []
+    end.
+   
+-define(EXPECT_CONNECTS(Pattern,Timeout),
+	(fun() ->
+		 case collect_connects(Timeout) of
+		     Pattern ->
+			 ok;
+		     Other ->
+			 {error,{unexpected,Other}}
+		 end
+	 end)()).
+
+mktmofun(Tmo,Parent,LS) ->
+    fun() -> Parent ! {accepted,self(), catch gen_tcp:accept(LS,Tmo)} end.
+
+%% Accept tests
+primitive_accept(suite) ->
+    [];
+primitive_accept(doc) ->
+    ["Test singular accept"];
+primitive_accept(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line {ok,PortNo}=inet:port(LS),
+    ?line Parent = self(),
+    ?line F = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS)} end,
+    ?line P = spawn(F),
+    ?line gen_tcp:connect("localhost",PortNo,[]),
+    ?line receive
+	      {accepted,P,{ok,P0}} when is_port(P0) ->
+		  ok;
+	      {accepted,P,Other0} ->
+		  {error,Other0}
+	  after 500 ->
+		  {error,timeout}
+	  end.
+
+	
+multi_accept_close_listen(suite) ->
+    [];
+multi_accept_close_listen(doc) ->
+    ["Closing listen socket when multi-accepting"];
+multi_accept_close_listen(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line F = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS)} end,
+    ?line spawn(F),
+    ?line spawn(F),
+    ?line spawn(F),
+    ?line spawn(F),
+    ?line gen_tcp:close(LS),
+    ?line ?EXPECT_ACCEPTS([{_,{error,closed}},{_,{error,closed}},
+			   {_,{error,closed}},{_,{error,closed}}], 500).
+	
+accept_timeout(suite) ->
+    [];
+accept_timeout(doc) ->
+    ["Single accept with timeout"];
+accept_timeout(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line F = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS,1000)} end,
+    ?line P = spawn(F),
+    ?line ?EXPECT_ACCEPTS([{P,{error,timeout}}],2000).
+
+accept_timeouts_in_order(suite) ->
+    [];
+accept_timeouts_in_order(doc) ->
+    ["Check that multi-accept timeouts happen in the correct order"];
+accept_timeouts_in_order(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line P1 = spawn(mktmofun(1000,Parent,LS)),
+    ?line P2 = spawn(mktmofun(1200,Parent,LS)),
+    ?line P3 = spawn(mktmofun(1300,Parent,LS)),
+    ?line P4 = spawn(mktmofun(1400,Parent,LS)),
+    ?line ?EXPECT_ACCEPTS([{P1,{error,timeout}},{P2,{error,timeout}},
+			   {P3,{error,timeout}},{P4,{error,timeout}}], 2000).
+
+accept_timeouts_in_order2(suite) ->
+    [];
+accept_timeouts_in_order2(doc) ->
+    ["Check that multi-accept timeouts happen in the correct order (more)"];
+accept_timeouts_in_order2(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line P1 = spawn(mktmofun(1400,Parent,LS)),
+    ?line P2 = spawn(mktmofun(1300,Parent,LS)),
+    ?line P3 = spawn(mktmofun(1200,Parent,LS)),
+    ?line P4 = spawn(mktmofun(1000,Parent,LS)),
+    ?line ?EXPECT_ACCEPTS([{P4,{error,timeout}},{P3,{error,timeout}},
+			   {P2,{error,timeout}},{P1,{error,timeout}}], 2000).
+
+accept_timeouts_in_order3(suite) ->
+    [];
+accept_timeouts_in_order3(doc) ->
+    ["Check that multi-accept timeouts happen in the correct order (even more)"];
+accept_timeouts_in_order3(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line P1 = spawn(mktmofun(1200,Parent,LS)),
+    ?line P2 = spawn(mktmofun(1400,Parent,LS)),
+    ?line P3 = spawn(mktmofun(1300,Parent,LS)),
+    ?line P4 = spawn(mktmofun(1000,Parent,LS)),
+    ?line ?EXPECT_ACCEPTS([{P4,{error,timeout}},{P1,{error,timeout}},
+			   {P3,{error,timeout}},{P2,{error,timeout}}], 2000).
+
+accept_timeouts_mixed(suite) ->
+    [];
+accept_timeouts_mixed(doc) ->
+    ["Check that multi-accept timeouts behave correctly when mixed with successful timeouts"];
+accept_timeouts_mixed(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]),
+    ?line Parent = self(),
+    ?line {ok,PortNo}=inet:port(LS),
+    ?line P1 = spawn(mktmofun(1000,Parent,LS)),
+    ?line wait_until_accepting(P1,500),
+    ?line P2 = spawn(mktmofun(2000,Parent,LS)),
+    ?line wait_until_accepting(P2,500),
+    ?line P3 = spawn(mktmofun(3000,Parent,LS)),
+    ?line wait_until_accepting(P3,500),
+    ?line P4 = spawn(mktmofun(4000,Parent,LS)),
+    ?line wait_until_accepting(P4,500),
+    ?line ok = ?EXPECT_ACCEPTS([{P1,{error,timeout}}],1500),
+    ?line {ok,_}=gen_tcp:connect("localhost",PortNo,[]),
+    ?line ok = ?EXPECT_ACCEPTS([{P2,{ok,Port0}}] when is_port(Port0),100),
+    ?line ok = ?EXPECT_ACCEPTS([{P3,{error,timeout}}],2000),	
+    ?line gen_tcp:connect("localhost",PortNo,[]),
+    ?line ?EXPECT_ACCEPTS([{P4,{ok,Port1}}] when is_port(Port1),100).
+
+killing_acceptor(suite) ->
+    [];
+killing_acceptor(doc) ->
+    ["Check that single acceptor behaves as expected when killed"];
+killing_acceptor(Config) when is_list(Config) ->    
+    ?line {ok,LS}=gen_tcp:listen(0,[]), 
+    ?line Pid = spawn(fun() -> erlang:display({accepted,self(),gen_tcp:accept(LS)}) end),
+    ?line receive after 100 ->
+			  ok
+		  end,
+    ?line {ok,L1} = prim_inet:getstatus(LS),
+    ?line true = lists:member(accepting, L1),
+    ?line exit(Pid,kill),
+    ?line receive after 100 ->
+			  ok
+		  end,
+    ?line {ok,L2} = prim_inet:getstatus(LS),
+    ?line false  = lists:member(accepting, L2),
+    ok.
+
+killing_multi_acceptors(suite) ->
+    [];
+killing_multi_acceptors(doc) ->
+    ["Check that multi acceptors behaves as expected when killed"];
+killing_multi_acceptors(Config) when is_list(Config) ->    
+    ?line {ok,LS}=gen_tcp:listen(0,[]), 
+    ?line Parent = self(),
+    ?line F = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS)} end,
+    ?line F2 = mktmofun(1000,Parent,LS),
+    ?line Pid = spawn(F),
+    ?line Pid2 = spawn(F2),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L1} = prim_inet:getstatus(LS),
+    ?line true = lists:member(accepting, L1),
+    ?line exit(Pid,kill),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L2} = prim_inet:getstatus(LS),
+    ?line true  = lists:member(accepting, L2),
+    ?line ok = ?EXPECT_ACCEPTS([{Pid2,{error,timeout}}],1000),
+    ?line {ok,L3} = prim_inet:getstatus(LS),
+    ?line false  = lists:member(accepting, L3),
+    ok.
+
+killing_multi_acceptors2(suite) ->
+    [];
+killing_multi_acceptors2(doc) ->
+    ["Check that multi acceptors behaves as expected when killed (more)"];
+killing_multi_acceptors2(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]), 
+    ?line Parent = self(),
+    ?line {ok,PortNo}=inet:port(LS),
+    ?line F = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS)} end,
+    ?line F2 = mktmofun(1000,Parent,LS),
+    ?line Pid = spawn(F),
+    ?line Pid2 = spawn(F),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L1} = prim_inet:getstatus(LS),
+    ?line true = lists:member(accepting, L1),
+    ?line exit(Pid,kill),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L2} = prim_inet:getstatus(LS),
+    ?line true  = lists:member(accepting, L2),
+    ?line exit(Pid2,kill),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L3} = prim_inet:getstatus(LS),
+    ?line false  = lists:member(accepting, L3),
+    ?line Pid3 = spawn(F2),
+    ?line receive after 100 ->
+		    ok
+	    end,
+    ?line {ok,L4} = prim_inet:getstatus(LS),
+    ?line true  = lists:member(accepting, L4),
+    ?line gen_tcp:connect("localhost",PortNo,[]),
+    ?line ok = ?EXPECT_ACCEPTS([{Pid3,{ok,Port}}] when is_port(Port),100),
+    ?line {ok,L5} = prim_inet:getstatus(LS),
+    ?line false  = lists:member(accepting, L5),
+    ok.
+    
+several_accepts_in_one_go(suite) ->
+    [];
+several_accepts_in_one_go(doc) ->
+    ["checks that multi-accept works when more than one accept can be "
+     "done at once (wb test of inet_driver)"];
+several_accepts_in_one_go(Config) when is_list(Config) ->
+    ?line {ok,LS}=gen_tcp:listen(0,[]), 
+    ?line Parent = self(),
+    ?line {ok,PortNo}=inet:port(LS),
+    ?line F1 = fun() -> Parent ! {accepted,self(),gen_tcp:accept(LS)} end,
+    ?line F2 = fun() -> Parent ! {connected,self(),gen_tcp:connect("localhost",PortNo,[])} end,
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line spawn(F1),
+    ?line ok = ?EXPECT_ACCEPTS([],500),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line spawn(F2),
+    ?line ok = ?EXPECT_ACCEPTS([{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}}],15000),
+    ?line ok = ?EXPECT_CONNECTS([{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}},{_,{ok,_}}],1000),
+    ok.
+
+
+flush(Msgs) ->
+    erlang:yield(),
+    receive Msg -> flush([Msg|Msgs])
+    after     0 -> lists:reverse(Msgs)
+    end.
+
+wait_until_accepting(Proc,0) ->
+    exit({timeout_waiting_for_accepting,Proc});
+wait_until_accepting(Proc,N) ->
+    case process_info(Proc,current_function) of
+        {current_function,{prim_inet,accept0,2}} ->
+            case process_info(Proc,status) of
+                {status,waiting} -> 
+                    ok;
+                _O1 ->
+                    receive 
+                    after 5 ->
+                        wait_until_accepting(Proc,N-1)
+                    end
+            end;
+         _O2 ->
+            receive 
+            after 5 ->
+                wait_until_accepting(Proc,N-1)
+            end
+    end.
+
+
+
+active_once_closed(suite) ->
+    [];
+active_once_closed(doc) ->
+    ["Check that active once and tcp_close messages behave as expected"];
+active_once_closed(Config) when is_list(Config) ->
+    (fun() ->
+	     ?line {Loop,A} = setup_closed_ao(),
+	     ?line Loop({{error,closed},{error,econnaborted}}, 
+			fun() -> gen_tcp:send(A,"Hello") end),
+	     ?line ok = inet:setopts(A,[{active,once}]),
+	     ?line ok = receive {tcp_closed, A} -> ok after 1000 -> error end,
+	     ?line {error,einval} = inet:setopts(A,[{active,once}]),
+	     ?line ok = receive {tcp_closed, A} -> error after 1000 -> ok end
+     end)(),
+    (fun() ->
+	     ?line {Loop,A} = setup_closed_ao(),
+	     ?line Loop({{error,closed},{error,econnaborted}}, 
+			fun() -> gen_tcp:send(A,"Hello") end),
+	     ?line ok = inet:setopts(A,[{active,true}]),
+	     ?line ok = receive {tcp_closed, A} -> ok after 1000 -> error end,
+	     ?line {error,einval} = inet:setopts(A,[{active,true}]),
+	     ?line ok = receive {tcp_closed, A} -> error after 1000 -> ok end
+     end)(),
+     (fun() ->
+	     ?line {Loop,A} = setup_closed_ao(),
+	     ?line Loop({{error,closed},{error,econnaborted}}, 
+			fun() -> gen_tcp:send(A,"Hello") end),
+	     ?line ok = inet:setopts(A,[{active,true}]),
+	     ?line ok = receive {tcp_closed, A} -> ok after 1000 -> error end,
+	     ?line {error,einval} = inet:setopts(A,[{active,once}]),
+	     ?line ok = receive {tcp_closed, A} -> error after 1000 -> ok end
+     end)(),
+    (fun() ->
+	     ?line {Loop,A} = setup_closed_ao(),
+	     ?line Loop({{error,closed},{error,econnaborted}}, 
+			fun() -> gen_tcp:send(A,"Hello") end),
+	     ?line ok = inet:setopts(A,[{active,once}]),
+	     ?line ok = receive {tcp_closed, A} -> ok after 1000 -> error end,
+	     ?line {error,einval} = inet:setopts(A,[{active,true}]),
+	     ?line ok = receive {tcp_closed, A} -> error after 1000 -> ok end
+     end)(),
+    (fun() ->
+	     ?line {Loop,A} = setup_closed_ao(),
+	     ?line Loop({{error,closed},{error,econnaborted}}, 
+			fun() -> gen_tcp:send(A,"Hello") end),
+	     ?line ok = inet:setopts(A,[{active,false}]),
+	     ?line ok = receive {tcp_closed, A} -> error after 1000 -> ok end,
+	     ?line ok = inet:setopts(A,[{active,once}]),
+	     ?line ok = receive {tcp_closed, A} -> ok after 1000 -> error end
+     end)().
+   
+send_timeout(suite) ->
+    [];
+send_timeout(doc) ->
+    ["Test the send_timeout socket option"];
+send_timeout(Config) when is_list(Config) ->
+    %% Basic
+    BasicFun = 
+	fun(AutoClose) ->
+	     ?line {Loop,A,RNode} = setup_timeout_sink(1000, AutoClose),
+	     ?line {error,timeout} = 
+		 Loop(fun() ->
+			      Res = gen_tcp:send(A,<<1:10000>>),
+			      %%erlang:display(Res),
+			      Res
+		      end),
+	     %% Check that the socket is not busy/closed...
+	     Error = after_send_timeout(AutoClose),
+	     ?line {error,Error} = gen_tcp:send(A,<<"Hej">>),
+	     ?line test_server:stop_node(RNode)
+	end,
+    BasicFun(false),
+    BasicFun(true),
+    %% Check timeout length
+   ?line  Self = self(),
+   ?line  Pid = 
+	spawn(fun() ->
+		      {Loop,A,RNode} = setup_timeout_sink(1000, true),
+		      {error,timeout} = 
+			  Loop(fun() ->
+				       Res = gen_tcp:send(A,<<1:10000>>),
+				       %%erlang:display(Res),
+				       Self ! Res,
+				       Res
+			       end),
+		      test_server:stop_node(RNode)
+	      end),		  
+    ?line Diff = get_max_diff(),
+    ?line io:format("Max time for send: ~p~n",[Diff]),
+    ?line true = (Diff > 500) and (Diff < 1500),
+    %% Let test_server slave die...
+    ?line Mon = erlang:monitor(process, Pid),
+    ?line receive {'DOWN',Mon,process,Pid,_} -> ok end,
+    %% Check that parallell writers do not hang forever
+    ParaFun = 
+	fun(AutoClose) ->
+		?line {Loop,A,RNode} = setup_timeout_sink(1000, AutoClose),
+		SenderFun = fun() ->
+				    {error,Error} = 
+					Loop(fun() ->
+						     gen_tcp:send(A, <<1:10000>>)
+					     end),
+				    Self ! {error,Error}
+			    end,
+		?line spawn_link(SenderFun),
+		?line spawn_link(SenderFun),
+		?line receive 
+			  {error,timeout} -> ok
+		      after 10000 ->
+			      ?line exit(timeout)
+		      end,
+		NextErr = after_send_timeout(AutoClose),
+		?line receive
+			  {error,NextErr} -> ok
+		      after 10000 ->
+			      ?line exit(timeout)
+		      end,
+		?line {error,NextErr} = gen_tcp:send(A,<<"Hej">>),
+		?line test_server:stop_node(RNode)
+	end,
+    ParaFun(false),
+    ParaFun(true),
+    ok.
+
+after_send_timeout(AutoClose) ->
+    case AutoClose of
+	true -> enotconn;
+	false -> timeout
+    end.
+
+get_max_diff() ->
+    receive
+	ok ->
+	    get_max_diff(0)
+    after 10000 ->
+	    exit(timeout)
+    end.
+
+get_max_diff(Max) ->
+    T1 = millistamp(),
+    receive
+	ok ->
+	    Diff = millistamp() - T1,
+	    if
+		Diff > Max ->
+		    get_max_diff(Diff);
+		true ->
+		    get_max_diff(Max)
+	    end;
+	{error,timeout} ->
+	    Diff = millistamp() - T1,
+	    if
+		Diff > Max ->
+		    Diff;
+		true ->
+		    Max
+	    end
+    after 10000 ->
+	    exit(timeout)
+    end.
+	    
+setup_closed_ao() ->
+    Dir = filename:dirname(code:which(?MODULE)),
+    {ok,R} = test_server:start_node(test_default_options_slave,slave,
+				       [{args,"-pa " ++ Dir}]),    
+    Host = list_to_atom(lists:nth(2,string:tokens(atom_to_list(node()),"@"))),
+    {ok, L} = gen_tcp:listen(0, [{active,false},{packet,2}]),
+    Fun = fun(F) -> 
+		  receive 
+		      {From,X} when is_function(X) -> 
+			  From ! {self(),X()}, F(F); 
+		      die -> ok 
+		  end 
+	  end, 
+    Pid =  rpc:call(R,erlang,spawn,[fun() -> Fun(Fun) end]),
+    {ok, Port} = inet:port(L),
+    Remote = fun(Fu) -> 
+		     Pid ! {self(), Fu}, 
+		     receive {Pid,X} -> X 
+		     end 
+	     end,
+    {ok, C} = Remote(fun() -> 
+			     gen_tcp:connect(Host,Port,
+					     [{active,false},{packet,2}]) 
+		     end),
+    {ok,A} = gen_tcp:accept(L),
+    gen_tcp:send(A,"Hello"),
+    {ok, "Hello"} = Remote(fun() -> gen_tcp:recv(C,0) end),
+    ok =  Remote(fun() -> gen_tcp:close(C) end), 
+    Loop2 = fun(_,_,_,0) -> 
+		    {failure, timeout}; 
+	       (L2,{MA,MB},F2,N) -> 
+		    case F2() of 
+			MA -> MA; 
+			MB -> MB; 
+			Other -> io:format("~p~n",[Other]), 
+				 receive after 1000 -> ok end, 
+				 L2(L2,{MA,MB},F2,N-1) 
+		    end 
+	    end,
+    Loop = fun(Match2,F3) ->  Loop2(Loop2,Match2,F3,10) end,
+    test_server:stop_node(R),
+    {Loop,A}.
+    
+setup_timeout_sink(Timeout, AutoClose) ->
+    Dir = filename:dirname(code:which(?MODULE)),
+    {ok,R} = test_server:start_node(test_default_options_slave,slave,
+				       [{args,"-pa " ++ Dir}]),    
+    Host = list_to_atom(lists:nth(2,string:tokens(atom_to_list(node()),"@"))),
+    {ok, L} = gen_tcp:listen(0, [{active,false},{packet,2},
+				 {send_timeout,Timeout},
+				 {send_timeout_close,AutoClose}]),
+    Fun = fun(F) -> 
+		  receive 
+		      {From,X} when is_function(X) -> 
+			  From ! {self(),X()}, F(F); 
+		      die -> ok 
+		  end 
+	  end, 
+    Pid =  rpc:call(R,erlang,spawn,[fun() -> Fun(Fun) end]),
+    {ok, Port} = inet:port(L),
+    Remote = fun(Fu) -> 
+		     Pid ! {self(), Fu}, 
+		     receive {Pid,X} -> X 
+		     end 
+	     end,
+    {ok, C} = Remote(fun() -> 
+			     gen_tcp:connect(Host,Port,
+					     [{active,false},{packet,2}]) 
+		     end),
+    {ok,A} = gen_tcp:accept(L),
+    gen_tcp:send(A,"Hello"),
+    {ok, "Hello"} = Remote(fun() -> gen_tcp:recv(C,0) end),
+    Loop2 = fun(_,_,0) -> 
+		    {failure, timeout}; 
+	       (L2,F2,N) -> 
+		    Ret = F2(),
+		    io:format("~p~n",[Ret]),
+		    case Ret of
+			ok -> receive after 1 -> ok end, 
+			      L2(L2,F2,N-1);
+			Other -> Other
+		    end 
+	    end,
+    Loop = fun(F3) ->  Loop2(Loop2,F3,1000) end,
+    {Loop,A,R}.
+    
+millistamp() ->
+    {Mega, Secs, Micros} = erlang:now(),
+    (Micros div 1000) + Secs * 1000 + Mega * 1000000000.
+
+has_superfluous_schedulers() ->
+    case {erlang:system_info(schedulers),
+	  erlang:system_info(logical_processors)} of
+	{S, unknown} when S > 1 -> true;
+	{S, P} when S > P -> true;
+	_ -> false
+    end.
+
+
+otp_7731(suite) -> [];    
+otp_7731(doc) -> 
+    "Leaking message from inet_drv {inet_reply,P,ok} "
+    "when a socket sending resumes working after a send_timeout";
+otp_7731(Config) when is_list(Config) ->
+    ?line ServerPid = spawn_link(?MODULE, otp_7731_server, [self()]),
+    ?line receive {ServerPid, ready, PortNum} -> ok end,
+
+    ?line {ok, Socket} = gen_tcp:connect("localhost", PortNum, 
+					 [binary, {active, false}, {packet, raw},
+					  {send_timeout, 1000}]),
+    otp_7731_send(Socket),
+    io:format("Sending complete...\n",[]),
+    ServerPid ! {self(), recv},
+    receive {ServerPid, ok} -> ok end,	    
+    
+    io:format("Client waiting for leaking messages...\n",[]),
+
+    %% Now make sure inet_drv does not leak any internal messages.
+    receive Msg ->
+	    ?line test_server:fail({unexpected, Msg})
+    after 1000 ->
+	    ok
+    end,
+    io:format("No leaking messages. Done.\n",[]),
+    gen_tcp:close(Socket).
+    
+otp_7731_send(Socket) ->
+    Bin = <<1:10000>>,
+    io:format("Client sending ~p bytes...\n",[size(Bin)]),
+    ?line case gen_tcp:send(Socket, Bin) of
+	      ok -> otp_7731_send(Socket);
+	      {error,timeout} -> ok
+	  end.
+
+otp_7731_server(ClientPid) ->
+    ?line {ok, LSocket} = gen_tcp:listen(0, [binary, {packet, raw}, 
+					     {active, false}]),
+    ?line {ok, {_, PortNum}} = inet:sockname(LSocket),
+    io:format("Listening on ~w with port number ~p\n", [LSocket, PortNum]),
+    ClientPid ! {self(), ready, PortNum},
+
+    {ok, CSocket} = gen_tcp:accept(LSocket),
+    gen_tcp:close(LSocket),
+
+    io:format("Server got connection, wait for recv order...\n",[]),
+
+    receive {ClientPid, recv} -> ok end,
+    
+    io:format("Server start receiving...\n",[]),
+
+    otp_7731_recv(CSocket),
+
+    ClientPid ! {self(), ok},
+
+    io:format("Server finished, closing...\n",[]),
+    gen_tcp:close(CSocket).
+
+
+otp_7731_recv(Socket) ->
+    ?line case gen_tcp:recv(Socket, 0, 1000) of
+	      {ok, Bin} -> 
+		  io:format("Server received ~p bytes\n",[size(Bin)]),
+		  otp_7731_recv(Socket);
+	      {error,timeout} ->
+		  io:format("Server got receive timeout\n",[]),
+		  ok
+	  end.
+
+
+%% OTP-7615: TCP-ports hanging in CLOSING state when sending large
+%% buffer followed by a recv() that returns error due to closed
+%% connection.
+zombie_sockets(suite) -> [];
+zombie_sockets(doc) -> ["OTP-7615 Leaking closed ports."];
+zombie_sockets(Config) when is_list(Config) ->
+    register(zombie_collector,self()),
+    Calls = 10,
+    Server = spawn_link(?MODULE, zombie_server,[self(), Calls]),
+    ?line {Server, ready, PortNum} = receive Msg -> Msg  end,
+    io:format("Ports before = ~p\n",[lists:sort(erlang:ports())]),
+    zombie_client_loop(Calls, PortNum),
+    Ports = lists:sort(zombie_collector(Calls,[])),
+    Server ! terminate,
+    io:format("Collected ports = ~p\n",[Ports]),
+    ?line [] = zombies_alive(Ports, 10),
+    timer:sleep(1000),
+    ok.
+
+zombie_client_loop(0, _) -> ok;
+zombie_client_loop(N, PortNum) when is_integer(PortNum) ->
+    ?line {ok, Socket} = gen_tcp:connect("localhost", PortNum, 
+					 [binary, {active, false}, {packet, raw}]),
+    ?line gen_tcp:close(Socket), % to make server recv fail
+    zombie_client_loop(N-1, PortNum).
+
+
+zombie_collector(0,Acc) ->
+    Acc;
+zombie_collector(N,Acc) ->
+    receive 
+	{closed, Socket} -> 
+	    zombie_collector(N-1,[Socket|Acc]);
+	E -> 
+	    {unexpected, E, Acc}
+    end.
+	    
+zombies_alive(Ports, WaitSec) ->
+    Alive = lists:sort(erlang:ports()),
+    io:format("Alive = ~p\n",[Alive]),
+    Zombies = lists:filter(fun(P) -> lists:member(P, Alive) end, Ports),
+    case Zombies of
+	[] -> [];
+	_ ->
+	    case WaitSec of
+		0 -> Zombies;
+		_ -> timer:sleep(1000), % Wait some more for zombies to die
+		     zombies_alive(Zombies, WaitSec-1)
+	    end
+    end.
+
+zombie_server(Pid, Calls) ->
+    ?line {ok, LSocket} = gen_tcp:listen(0, [binary, {packet, raw}, 
+					     {active, false}, {backlog, Calls}]),
+    ?line {ok, {_, PortNum}} = inet:sockname(LSocket),
+    io:format("Listening on ~w with port number ~p\n", [LSocket, PortNum]),
+    BigBin = list_to_binary(lists:duplicate(100*1024, 77)),
+    Pid ! {self(), ready, PortNum},
+    zombie_accept_loop(LSocket, BigBin, Calls),
+    ?line terminate = receive Msg -> Msg end.	    
+
+zombie_accept_loop(_, _, 0) ->
+    ok;
+zombie_accept_loop(Socket, BigBin, Calls) ->
+    ?line case gen_tcp:accept(Socket) of
+	{ok, NewSocket} ->
+	    spawn_link(fun() -> zombie_serve_client(NewSocket, BigBin) end),
+	    zombie_accept_loop(Socket, BigBin, Calls-1);
+	E ->
+	    E
+    end.
+
+zombie_serve_client(Socket, Bin) ->
+    %%io:format("Got connection on ~p\n",[Socket]),
+    ?line gen_tcp:send(Socket, Bin),
+    %%io:format("Sent data, waiting for reply on ~p\n",[Socket]),
+    ?line case gen_tcp:recv(Socket, 4) of
+	      {error,closed} -> ok;
+	      {error,econnaborted} -> ok % may be returned on Windows
+	  end,
+    %%io:format("Closing ~p\n",[Socket]),
+    ?line gen_tcp:close(Socket),
+    zombie_collector ! {closed, Socket}.
+
+
+
+otp_7816(suite) -> [];    
+otp_7816(doc) -> 
+    "Hanging send on windows when sending iolist with more than 16 binaries.";
+otp_7816(Config) when is_list(Config) ->
+    Client = self(),
+    ?line Server = spawn_link(fun()-> otp_7816_server(Client) end),
+    ?line receive {Server, ready, PortNum} -> ok end,
+
+    ?line {ok, Socket} = gen_tcp:connect("localhost", PortNum, 
+					 [binary, {active, false}, {packet, 4},
+					  {send_timeout, 10}]),
+    %% We use the undocumented feature that sending can be resumed after
+    %% a send_timeout without any data loss if the peer starts to receive data.
+    %% Unless of course the 7816-bug is in affect, in which case the write event
+    %% for the socket is lost on windows and not all data is sent.
+
+    [otp_7816_send(Socket,18,BinSize,Server) || BinSize <- lists:seq(1000, 2000, 123)],
+
+    io:format("Sending complete...\n",[]),
+
+    ?line ok = gen_tcp:close(Socket),
+    Server ! {self(), closed},
+    ?line {Server, closed} = receive M -> M end.
+
+    
+otp_7816_send(Socket, BinNr, BinSize, Server) ->
+    Data = lists:duplicate(BinNr, <<1:(BinSize*8)>>),
+    SentBytes = otp_7816_send_data(Socket, Data, 0) * BinNr * BinSize,
+    io:format("Client sent ~p bytes...\n",[SentBytes]),
+    Server ! {self(),recv,SentBytes},
+    ?line {Server, ok} = receive M -> M end.
+
+    
+
+otp_7816_send_data(Socket, Data, Loops) ->
+    io:format("Client sending data...\n",[]),
+    case gen_tcp:send(Socket, Data) of
+	ok ->
+	    otp_7816_send_data(Socket,Data, Loops+1);
+	{error,timeout} ->
+	    Loops+1
+    end.
+    
+    
+otp_7816_server(Client) ->
+    ?line {ok, LSocket} = gen_tcp:listen(0, [binary, {packet, 4},
+					     {active, false}]),
+    ?line {ok, {_, PortNum}} = inet:sockname(LSocket),
+    io:format("Listening on ~w with port number ~p\n", [LSocket, PortNum]),
+    Client ! {self(), ready, PortNum},
+
+    ?line {ok, CSocket} = gen_tcp:accept(LSocket),
+    io:format("Server got connection...\n",[]),
+    ?line gen_tcp:close(LSocket),
+
+    otp_7816_server_loop(CSocket),
+
+    io:format("Server terminating.\n",[]).
+
+
+otp_7816_server_loop(CSocket) ->
+    io:format("Server waiting for order...\n",[]),
+
+    receive 
+	{Client, recv, RecvBytes} -> 
+	    io:format("Server start receiving...\n",[]),
+
+	    ?line ok = otp_7816_recv(CSocket, RecvBytes),
+	    
+	    Client ! {self(), ok},
+	    otp_7816_server_loop(CSocket);
+	
+	{Client, closed} ->
+	    ?line {error, closed} = gen_tcp:recv(CSocket, 0, 1000),
+	    Client ! {self(), closed}
+    end.
+
+
+otp_7816_recv(_, 0) ->
+    io:format("Server got all.\n",[]),
+    ok;
+otp_7816_recv(CSocket, BytesLeft) ->
+    ?line case gen_tcp:recv(CSocket, 0, 1000) of
+	      {ok, Bin} when byte_size(Bin) =< BytesLeft -> 
+		  io:format("Server received ~p of ~p bytes.\n",[size(Bin), BytesLeft]),
+		  otp_7816_recv(CSocket, BytesLeft - byte_size(Bin));
+	      {error,timeout} ->
+		  io:format("Server got receive timeout when expecting more data\n",[]),
+		  error
+	  end.
+
+otp_8102(doc) -> ["Receive a packet with a faulty packet header"];
+otp_8102(suite) -> [];
+otp_8102(Config) when is_list(Config) ->
+    ?line {ok, LSocket} = gen_tcp:listen(0, []),
+    ?line {ok, {_, PortNum}} = inet:sockname(LSocket),
+    io:format("Listening on ~w with port number ~p\n", [LSocket, PortNum]),
+
+    [otp_8102_do(LSocket, PortNum, otp_8102_packet(Type,Size))
+     || Size <- lists:seq(-10,-1), 
+	Type <- [4, {cdr,big}, {cdr,little}]],
+    
+    gen_tcp:close(LSocket),
+    ok.
+
+otp_8102_packet(4, Size) ->
+    {<<Size:32/big>>, 4};
+otp_8102_packet({cdr,big}, Size) ->
+    {<<"GIOP",0,0,0,0,Size:32/big>>, cdr};
+otp_8102_packet({cdr,little}, Size) ->
+    {<<"GIOP",0,0,1,0,Size:32/little>>, cdr}.
+
+otp_8102_do(LSocket, PortNum, {Bin,PType}) ->
+
+    io:format("Connect with packet option ~p ...\n",[PType]),
+    ?line {ok, RSocket} = gen_tcp:connect("localhost", PortNum, [binary,
+								 {packet,PType},
+								 {active,true}]),
+    ?line {ok, SSocket} = gen_tcp:accept(LSocket),
+
+    io:format("Got connection, sending ~p...\n",[Bin]),
+
+    ?line ok = gen_tcp:send(SSocket, Bin),
+
+    io:format("Sending complete...\n",[]),
+
+    ?line {tcp_error,RSocket,emsgsize} = receive M -> M end,
+
+    io:format("Got error msg, ok.\n",[]),
+    gen_tcp:close(SSocket),    
+    gen_tcp:close(RSocket).
+