The R13B03 release.OTP_R13B03

1 files changed, 705 insertions, 0 deletions

diff --git a/lib/kernel/test/erl_distribution_wb_SUITE.erl b/lib/kernel/test/erl_distribution_wb_SUITE.erl
new file mode 100644
index 0000000000..627fed1fdd
--- /dev/null
+++ b/lib/kernel/test/erl_distribution_wb_SUITE.erl
@@ -0,0 +1,705 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1999-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(erl_distribution_wb_SUITE).
+
+-include("test_server.hrl").
+-include_lib("kernel/include/inet.hrl").
+
+-export([all/1]).
+
+-export([init_per_testcase/2, fin_per_testcase/2, whitebox/1, 
+	 switch_options/1, missing_compulsory_dflags/1]).
+
+%% 1)
+%%
+%% Connections are now always set up symetrically with respect to
+%% publication. If connecting node doesn't send DFLAG_PUBLISHED
+%% the other node wont send DFLAG_PUBLISHED. If the connecting
+%% node send DFLAG_PUBLISHED but the other node doesn't send
+%% DFLAG_PUBLISHED, the connecting node should consider its
+%% DFLAG_PUBLISHED as dropped, i.e the connecting node wont be
+%% published on the other node.
+
+-define(to_port(Socket, Data),
+	case inet_tcp:send(Socket, Data) of
+	    {error, closed} ->
+		self() ! {tcp_closed, Socket},
+	        {error, closed};
+	    R ->
+	        R
+        end).
+
+-define(DFLAG_PUBLISHED,1).
+-define(DFLAG_ATOM_CACHE,2).
+-define(DFLAG_EXTENDED_REFERENCES,4).
+-define(DFLAG_DIST_MONITOR,8).
+-define(DFLAG_FUN_TAGS,16#10).
+-define(DFLAG_DIST_MONITOR_NAME,16#20).
+-define(DFLAG_HIDDEN_ATOM_CACHE,16#40).
+-define(DFLAG_NEW_FUN_TAGS,16#80).
+-define(DFLAG_EXTENDED_PIDS_PORTS,16#100).
+
+%% From R9 and forward extended references is compulsory
+%% From R10 and forward extended pids and ports are compulsory
+-define(COMPULSORY_DFLAGS, (?DFLAG_EXTENDED_REFERENCES bor ?DFLAG_EXTENDED_PIDS_PORTS)).
+
+
+-define(shutdown(X), exit(X)).
+-define(int16(X), [((X) bsr 8) band 16#ff, (X) band 16#ff]).
+
+-define(int32(X), 
+	[((X) bsr 24) band 16#ff, ((X) bsr 16) band 16#ff,
+	 ((X) bsr 8) band 16#ff, (X) band 16#ff]).
+
+-define(i16(X1,X0),
+        (?u16(X1,X0) - 
+         (if (X1) > 127 -> 16#10000; true -> 0 end))).
+
+-define(u16(X1,X0),
+        (((X1) bsl 8) bor (X0))).
+
+-define(u32(X3,X2,X1,X0),
+        (((X3) bsl 24) bor ((X2) bsl 16) bor ((X1) bsl 8) bor (X0))).
+
+all(suite) -> 
+    [whitebox,switch_options,missing_compulsory_dflags].
+
+init_per_testcase(Func, Config) when is_atom(Func), is_list(Config) ->
+    Dog=?t:timetrap(?t:minutes(1)),
+    [{watchdog, Dog}|Config].
+
+fin_per_testcase(_Func, Config) ->
+    Dog=?config(watchdog, Config),
+    ?t:timetrap_cancel(Dog).
+
+switch_options(doc) ->
+    ["Tests switching of options for the tcp port, as this is done"
+     " when the distribution port is to be shortcut into the emulator."
+     " Maybe this should be in the inet test suite, but only the distribution"
+     " does such horrible things..."];
+switch_options(Config) when is_list(Config) ->
+    ok = test_switch_active(),
+    ok = test_switch_active_partial() ,
+    ok = test_switch_active_and_packet(),    
+    ok.
+    
+
+whitebox(doc) ->
+    ["Whitebox testing of distribution handshakes. Tests both BC with R5 and "
+     "the md5 version. Note that after R6B, this should be revised to "
+     "remove BC code."];
+whitebox(Config) when is_list(Config) ->
+    ?line {ok, Node} = start_node(?MODULE,""),
+    ?line Cookie = erlang:get_cookie(),
+    ?line {_,Host} = split(node()),
+    ?line ok = pending_up_md5(Node, join(ccc,Host), Cookie),
+    ?line ok = simultaneous_md5(Node, join('A',Host), Cookie),
+    ?line ok = simultaneous_md5(Node, join(zzzzzzzzzzzzzz,Host), Cookie),
+    ?line stop_node(Node),
+    ok.
+    
+%%
+%% The actual tests
+%%
+
+%%
+%% Switch tcp options test
+%%
+
+test_switch_active() ->
+    ?line {Client, Server} = socket_pair(0, 4),
+    ?line ok = write_packets_32(Client, 1, 5),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 1, 1),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 2, 2),
+    ?line inet:setopts(Server, [{active, true}]),
+    ?line ok = receive_packets(Server, 3, 5),
+    close_pair({Client, Server}),
+    ok.
+    
+test_switch_active_partial() ->
+    ?line {Client, Server} = socket_pair(0, 4),
+    ?line ok = write_packets_32(Client, 1, 2),
+    ?line ok = gen_tcp:send(Client,[?int32(4), [0,0,0]]),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 1, 1),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 2, 2),
+    ?line inet:setopts(Server, [{active, true}]),
+    ?line ok = gen_tcp:send(Client,[3]),
+    ?line ok = write_packets_32(Client, 4, 5),
+    ?line ok = receive_packets(Server, 3, 5),
+    close_pair({Client, Server}),
+    ok.
+    
+do_test_switch_active_and_packet(SendBefore, SendAfter) ->
+    ?line {Client, Server} = socket_pair(0, 2),
+    ?line ok = write_packets_16(Client, 1, 2),
+    ?line ok = gen_tcp:send(Client,SendBefore),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 1, 1),
+    receive after 2000 -> ok end,
+    ?line ok = read_packets(Server, 2, 2),
+    ?line inet:setopts(Server, [{packet,4}, {active, true}]),
+    ?line ok = gen_tcp:send(Client,SendAfter),
+    ?line ok = write_packets_32(Client, 4, 5),
+    ?line ok = receive_packets(Server, 3, 5),
+    close_pair({Client, Server}),
+    ok.
+
+test_switch_active_and_packet() ->
+    ?line ok = do_test_switch_active_and_packet([0],[0,0,4,0,0,0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0],[0,4,0,0,0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0],[4,0,0,0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0,4],[0,0,0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0,4,0],[0,0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0,4,0,0],[0,3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0,4,0,0,0],[3]),
+    ?line ok = do_test_switch_active_and_packet([0,0,0,4,0,0,0,3],[]),
+    ok.
+
+
+%%
+%% Handshake tests
+%%
+pending_up_md5(Node,OurName,Cookie) ->
+    ?line {NA,NB} = split(Node),
+    ?line {port,PortNo,_} = erl_epmd:port_please(NA,NB),
+    ?line {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo,
+					  [{active,false},
+					   {packet,2}]),
+    ?line send_name(SocketA,OurName,5),
+    ?line ok = recv_status(SocketA),
+    ?line {hidden,Node,5,HisChallengeA} = recv_challenge(SocketA), % See 1)
+    ?line OurChallengeA = gen_challenge(),
+    ?line OurDigestA = gen_digest(HisChallengeA, Cookie),
+    ?line send_challenge_reply(SocketA, OurChallengeA, OurDigestA),
+    ?line ok = recv_challenge_ack(SocketA, OurChallengeA, Cookie),
+    %%%
+    %%% OK, one connection is up, now lets be nasty and try another up:
+    %%%
+    %%% But wait for a while, the other node might not have done setnode 
+    %%% just yet...
+    ?line receive after 1000 -> ok end,
+    ?line {ok, SocketB} = gen_tcp:connect(atom_to_list(NB),PortNo,
+					  [{active,false},
+					   {packet,2}]),
+    ?line send_name(SocketB,OurName,5),
+    ?line alive = recv_status(SocketB),
+    ?line send_status(SocketB, true),
+    ?line gen_tcp:close(SocketA),
+    ?line {hidden,Node,5,HisChallengeB} = recv_challenge(SocketB), % See 1)
+    ?line OurChallengeB = gen_challenge(),
+    ?line OurDigestB = gen_digest(HisChallengeB, Cookie),
+    ?line send_challenge_reply(SocketB, OurChallengeB, OurDigestB),
+    ?line ok = recv_challenge_ack(SocketB, OurChallengeB, Cookie),
+    %%%
+    %%% Well, are we happy?
+    %%%
+    
+    ?line inet:setopts(SocketB, [{active, false},
+				 {packet, 4}]),    
+    ?line gen_tcp:send(SocketB,build_rex_message('',OurName)),
+    ?line {Header, Message} = recv_message(SocketB),
+    ?line io:format("Received header ~p, data ~p.~n",
+	      [Header, Message]),
+    ?line gen_tcp:close(SocketB),
+    ok.
+
+simultaneous_md5(Node, OurName, Cookie) when OurName < Node ->
+    ?line pong = net_adm:ping(Node),
+    ?line LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of
+		  {ok, Socket} ->
+		      Socket;
+		  Else ->
+		      exit(Else)
+	      end,
+    ?line EpmdSocket = register(OurName, LSocket, 1, 5),
+    ?line {NA, NB} = split(Node),
+    ?line rpc:cast(Node, net_adm, ping, [OurName]),
+    ?line receive after 1000 -> ok end,
+    ?line {port, PortNo, _} = erl_epmd:port_please(NA,NB),
+    ?line {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo,
+					  [{active,false},
+					   {packet,2}]),
+    ?line send_name(SocketA,OurName,5),
+    %% We are still not marked up on the other side, as our first message 
+    %% is not sent.
+    ?line SocketB = case gen_tcp:accept(LSocket) of
+		  {ok, Socket1} ->
+		      ?line Socket1;
+		  Else2 ->
+		      ?line exit(Else2)
+	      end,
+    ?line nok = recv_status(SocketA),
+    % Now we are expected to close A
+    ?line gen_tcp:close(SocketA),
+    % But still Socket B will continue
+    ?line {normal,Node,5} = recv_name(SocketB),  % See 1)
+    ?line send_status(SocketB, ok_simultaneous),
+    ?line MyChallengeB = gen_challenge(),
+    ?line send_challenge(SocketB, OurName, MyChallengeB,5),
+    ?line HisChallengeB = recv_challenge_reply(SocketB, MyChallengeB, Cookie),
+    ?line DigestB = gen_digest(HisChallengeB,Cookie),
+    ?line send_challenge_ack(SocketB, DigestB),
+    ?line inet:setopts(SocketB, [{active, false},
+			  {packet, 4}]),    
+    % This should be the ping message.
+    ?line {Header, Message} = recv_message(SocketB),
+    ?line io:format("Received header ~p, data ~p.~n",
+	      [Header, Message]),
+    ?line gen_tcp:close(SocketB),
+    ?line gen_tcp:close(LSocket),
+    ?line gen_tcp:close(EpmdSocket),
+    ok;
+    
+simultaneous_md5(Node, OurName, Cookie) when OurName > Node ->
+    ?line pong = net_adm:ping(Node),
+    ?line LSocket = case gen_tcp:listen(0, [{active, false}, {packet,2}]) of
+			{ok, Socket} ->
+			    ?line Socket;
+			Else ->
+			    ?line exit(Else)
+		    end,
+    ?line EpmdSocket = register(OurName, LSocket, 1, 5),
+    ?line {NA, NB} = split(Node),
+    ?line rpc:cast(Node, net_adm, ping, [OurName]),
+    ?line receive after 1000 -> ok end,
+    ?line {port, PortNo, _} = erl_epmd:port_please(NA,NB),
+    ?line {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo,
+					  [{active,false},
+					   {packet,2}]),
+    ?line SocketB = case gen_tcp:accept(LSocket) of
+		  {ok, Socket1} ->
+		      ?line Socket1;
+		  Else2 ->
+		      ?line exit(Else2)
+	      end,
+    ?line send_name(SocketA,OurName,5),
+    ?line ok_simultaneous = recv_status(SocketA),
+    %% Socket B should die during this
+    ?line case catch begin
+			 ?line {normal,Node,5} = recv_name(SocketB),  % See 1)
+			 ?line send_status(SocketB, ok_simultaneous),
+			 ?line MyChallengeB = gen_challenge(),
+			 ?line send_challenge(SocketB, OurName, MyChallengeB,
+					      5),
+			 ?line HisChallengeB = recv_challenge_reply(
+						 SocketB, 
+						 MyChallengeB, 
+						 Cookie),
+			 ?line DigestB = gen_digest(HisChallengeB,Cookie),
+			 ?line send_challenge_ack(SocketB, DigestB),
+			 ?line inet:setopts(SocketB, [{active, false},
+						      {packet, 4}]),    
+			 ?line {HeaderB, MessageB} = recv_message(SocketB),
+			 ?line io:format("Received header ~p, data ~p.~n",
+					 [HeaderB, MessageB])
+		     end of
+	      {'EXIT', Exitcode} ->
+		  ?line io:format("Expected exitsignal caught: ~p.~n",
+				  [Exitcode]);
+	      Success ->
+		  ?line io:format("Unexpected success: ~p~n",
+				  [Success]),
+		  ?line exit(unexpected_success)
+	  end,
+    ?line gen_tcp:close(SocketB),
+    %% But still Socket A will continue
+    ?line {hidden,Node,5,HisChallengeA} = recv_challenge(SocketA), % See 1)
+    ?line OurChallengeA = gen_challenge(),
+    ?line OurDigestA = gen_digest(HisChallengeA, Cookie),
+    ?line send_challenge_reply(SocketA, OurChallengeA, OurDigestA),
+    ?line ok = recv_challenge_ack(SocketA, OurChallengeA, Cookie),
+    
+    ?line inet:setopts(SocketA, [{active, false},
+				 {packet, 4}]),    
+    ?line gen_tcp:send(SocketA,build_rex_message('',OurName)),
+    ?line {Header, Message} = recv_message(SocketA),
+    ?line io:format("Received header ~p, data ~p.~n",
+	      [Header, Message]),
+    ?line gen_tcp:close(SocketA),
+    ?line gen_tcp:close(LSocket),
+    ?line gen_tcp:close(EpmdSocket),
+    ok.
+
+missing_compulsory_dflags(doc) -> [];
+missing_compulsory_dflags(Config) when is_list(Config) ->
+    ?line [Name1, Name2] = get_nodenames(2, missing_compulsory_dflags),
+    ?line {ok, Node} = start_node(Name1,""),
+    ?line {NA,NB} = split(Node),
+    ?line {port,PortNo,_} = erl_epmd:port_please(NA,NB),
+    ?line {ok, SocketA} = gen_tcp:connect(atom_to_list(NB),PortNo,
+					  [{active,false},
+					   {packet,2}]),
+    ?line BadNode = list_to_atom(atom_to_list(Name2)++"@"++atom_to_list(NB)),
+    ?line send_name(SocketA,BadNode,5,0),
+    ?line not_allowed = recv_status(SocketA),
+    ?line gen_tcp:close(SocketA),
+    ?line stop_node(Node),
+    ?line ok.
+
+%%
+%% Here comes the utilities
+%%
+
+%%
+%% Switch option utilities
+%%
+write_packets_32(_, M, N) when M > N ->
+    ok;
+write_packets_32(Sock, M, N) ->
+    ok = gen_tcp:send(Sock,[?int32(4), ?int32(M)]),
+    write_packets_32(Sock, M+1, N).
+
+write_packets_16(_, M, N) when M > N ->
+    ok;
+write_packets_16(Sock, M, N) ->
+    ok = gen_tcp:send(Sock,[?int16(4), ?int32(M)]),
+    write_packets_16(Sock, M+1, N).
+
+read_packets(_, M, N) when M > N ->
+    ok;
+read_packets(Sock, M, N) ->
+    Expected = ?int32(M),
+    case gen_tcp:recv(Sock, 0) of
+	{ok, Expected} ->
+	    read_packets(Sock, M+1, N);
+	{ok, Unexpected} ->
+	    exit({unexpected_data_read, Unexpected});
+	Error ->
+	    exit({error_read, Error})
+    end.
+
+receive_packets(Sock, M, N) when M > N ->
+    receive
+	{tcp, Sock, Data} ->
+	    exit({extra_data, Data})
+    after 0 ->
+	    ok
+    end;
+
+receive_packets(Sock, M, N) ->
+    Expect = ?int32(M),
+    receive
+	{tcp, Sock, Expect} ->
+	    receive_packets(Sock, M+1, N); 
+	{tcp, Sock, Unexpected} ->
+	    exit({unexpected_data_received, Unexpected})
+    after 500 ->
+	    exit({no_data_received_for,M})
+    end.
+
+socket_pair(ClientPack, ServerPack) ->
+    {ok, Listen} = gen_tcp:listen(0, [{active, false}, 
+				      {packet, ServerPack}]),
+    {ok, Host} = inet:gethostname(),
+    {ok, Port} = inet:port(Listen),
+    {ok, Client} = gen_tcp:connect(Host, Port, [{active, false}, 
+						{packet, ClientPack}]),
+    {ok, Server} = gen_tcp:accept(Listen),
+    gen_tcp:close(Listen),
+    {Client, Server}.
+    
+close_pair({Client, Server}) ->
+    gen_tcp:close(Client),
+    gen_tcp:close(Server),
+    ok.
+
+
+%%
+%% Handshake utilities
+%%
+
+%%
+%% MD5 hashing
+%%
+
+%% This is no proper random number, but that is not really important in 
+%% this test
+gen_challenge() ->
+    {_,_,N} = erlang:now(), 
+    N.
+    
+%% Generate a message digest from Challenge number and Cookie	
+gen_digest(Challenge, Cookie) when is_integer(Challenge), is_atom(Cookie) ->
+    C0 = erlang:md5_init(),
+    C1 = erlang:md5_update(C0, atom_to_list(Cookie)),
+    C2 = erlang:md5_update(C1, integer_to_list(Challenge)),
+    binary_to_list(erlang:md5_final(C2)).
+
+
+%%
+%% The differrent stages of the MD5 handshake
+%%
+
+send_status(Socket, Stat) ->
+    case gen_tcp:send(Socket, [$s | atom_to_list(Stat)]) of
+	{error, _} ->
+	    ?shutdown(could_not_send_status);
+	_ -> 
+	    true
+    end.
+
+
+recv_status(Socket) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok, [$s|StrStat]} ->
+	    list_to_atom(StrStat);
+	Bad ->
+	    exit(Bad)
+    end.
+
+send_challenge(Socket, Node, Challenge, Version) ->
+    send_challenge(Socket, Node, Challenge, Version, ?COMPULSORY_DFLAGS).
+send_challenge(Socket, Node, Challenge, Version, Flags) ->
+    {ok, {{_Ip1,_Ip2,_Ip3,_Ip4}, _}} = inet:sockname(Socket),
+    ?to_port(Socket, [$n,?int16(Version),?int32(Flags),
+		      ?int32(Challenge), atom_to_list(Node)]).
+
+recv_challenge(Socket) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok,[$n,V1,V0,Fl1,Fl2,Fl3,Fl4,CA3,CA2,CA1,CA0 | Ns]} ->
+	    Flags = ?u32(Fl1,Fl2,Fl3,Fl4),
+	    Type = case Flags band ?DFLAG_PUBLISHED of
+		       0 ->
+			   hidden;
+		       _ ->
+			   normal
+		   end,
+	    Node =list_to_atom(Ns),
+	    Version = ?u16(V1,V0),
+	    Challenge = ?u32(CA3,CA2,CA1,CA0),
+	    {Type,Node,Version,Challenge};
+	_ ->
+	    ?shutdown(no_node)	    
+    end.
+
+send_challenge_reply(Socket, Challenge, Digest) ->
+    ?to_port(Socket, [$r,?int32(Challenge),Digest]).
+
+recv_challenge_reply(Socket, ChallengeA, Cookie) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok,[$r,CB3,CB2,CB1,CB0 | SumB]} when length(SumB) == 16 ->
+	    SumA = gen_digest(ChallengeA, Cookie),
+	    ChallengeB = ?u32(CB3,CB2,CB1,CB0),
+	    if SumB == SumA ->
+		    ChallengeB;
+	       true ->
+		    ?shutdown(bad_challenge_reply)
+	    end;
+	_ ->
+	    ?shutdown(no_node)
+    end.
+
+send_challenge_ack(Socket, Digest) ->
+    ?to_port(Socket, [$a,Digest]).
+
+recv_challenge_ack(Socket, ChallengeB, CookieA) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok,[$a | SumB]} when length(SumB) == 16 ->
+	    SumA = gen_digest(ChallengeB, CookieA),
+	    if SumB == SumA ->
+		    ok;
+	       true ->
+		    ?shutdown(bad_challenge_ack)
+	    end;
+	_ ->
+	    ?shutdown(bad_challenge_ack)
+    end.
+
+send_name(Socket, MyNode0, Version) ->
+    send_name(Socket, MyNode0, Version, ?COMPULSORY_DFLAGS).
+send_name(Socket, MyNode0, Version, Flags) ->
+    MyNode = atom_to_list(MyNode0),
+    ok = ?to_port(Socket, [<<$n,Version:16,Flags:32>>|MyNode]).
+
+%%
+%% recv_name is common for both old and new handshake.
+%%
+recv_name(Socket) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok,Data} ->
+	    get_name(Data);
+	Res ->
+	    ?shutdown({no_node,Res})
+    end.
+
+get_name([$m,VersionA,VersionB,_Ip1,_Ip2,_Ip3,_Ip4|OtherNode]) ->
+    {normal, list_to_atom(OtherNode), ?u16(VersionA,VersionB)};
+get_name([$h,VersionA,VersionB,_Ip1,_Ip2,_Ip3,_Ip4|OtherNode]) ->
+    {hidden, list_to_atom(OtherNode), ?u16(VersionA,VersionB)};
+get_name([$n,VersionA, VersionB, Flag1, Flag2, Flag3, Flag4 | OtherNode]) ->
+    Type = case ?u32(Flag1, Flag2, Flag3, Flag4) band ?DFLAG_PUBLISHED of
+	       0 ->
+		   hidden;
+	       _ -> 
+		   normal
+	   end,
+    {Type, list_to_atom(OtherNode), 
+     ?u16(VersionA,VersionB)};
+get_name(Data) ->
+    ?shutdown(Data).
+
+%%
+%% The communication with EPMD follows
+%%
+get_epmd_port() ->
+    case init:get_argument(epmd_port) of
+        {ok, [[PortStr|_]|_]} when is_list(PortStr) ->
+            list_to_integer(PortStr);
+        error ->
+            4369 % Default epmd port
+    end.
+
+do_register_node(NodeName, TcpPort, VLow, VHigh) ->    
+    case gen_tcp:connect({127,0,0,1}, get_epmd_port(), []) of
+	{ok, Socket} ->
+	    {N0,_} = split(NodeName),
+	    Name = atom_to_list(N0),
+	    Extra = "",
+	    Elen = length(Extra),
+	    Len = 1+2+1+1+2+2+2+length(Name)+2+Elen,
+	    gen_tcp:send(Socket, [?int16(Len), $x,
+				   ?int16(TcpPort),
+				   $M,
+				   0,
+				   ?int16(VHigh),
+				   ?int16(VLow),
+				   ?int16(length(Name)),
+				   Name,
+				   ?int16(Elen),
+				   Extra]),
+	    case wait_for_reg_reply(Socket, []) of
+		{error, epmd_close} ->
+		    exit(epmd_broken);
+		Other ->
+		    Other
+	    end;
+	Error ->
+	    Error
+    end.
+
+wait_for_reg_reply(Socket, SoFar) ->
+    receive
+	{tcp, Socket, Data0} ->
+	    case SoFar ++ Data0 of
+		[$y, Result, A, B] ->
+		    case Result of
+			0 ->
+			    {alive, Socket, ?u16(A, B)};
+			_ ->
+			    {error, duplicate_name}
+		    end;
+		Data when length(Data) < 4 ->
+		    wait_for_reg_reply(Socket, Data);
+		Garbage ->
+		    {error, {garbage_from_epmd, Garbage}}
+	    end;
+	{tcp_closed, Socket} ->
+	    {error, epmd_close}
+    after 10000 ->
+	    gen_tcp:close(Socket),
+	    {error, no_reg_reply_from_epmd}
+    end.
+
+
+register(NodeName, ListenSocket, VLow, VHigh) ->
+    {ok,{_,TcpPort}} = inet:sockname(ListenSocket),
+    case do_register_node(NodeName, TcpPort, VLow, VHigh) of
+	{alive, Socket, _Creation} ->
+	    Socket;
+	Other ->
+	    exit(Other)
+    end.
+
+
+%%
+%% Utilities
+%%
+
+%% Split a nodename
+split([$@|T],A) ->
+    {lists:reverse(A),T};
+split([H|T],A) ->
+    split(T,[H|A]).
+
+split(Atom) ->
+    {A,B} = split(atom_to_list(Atom),[]),
+    {list_to_atom(A),list_to_atom(B)}.
+
+%% Build a distribution message that will make rex answer
+build_rex_message(Cookie,OurName) ->
+    [$?,term_to_binary({6,self(),Cookie,rex}),
+     term_to_binary({'$gen_cast',
+		    {cast,
+		     rpc,
+		     cast,
+		     [OurName, hello, world, []],
+		     self()} })].
+
+%% Receive a distribution message    
+recv_message(Socket) ->
+    case gen_tcp:recv(Socket, 0) of
+	{ok,Data} ->
+	    B0 = list_to_binary(Data),
+	    {_,B1} = erlang:split_binary(B0,1),
+	    Header = binary_to_term(B1),
+	    Siz = byte_size(term_to_binary(Header)),
+	    {_,B2} = erlang:split_binary(B1,Siz),
+	    Message = case (catch binary_to_term(B2)) of
+			  {'EXIT', _} ->
+			      could_not_digest_message;
+			  Other ->
+			      Other
+		      end,
+	    {Header, Message};
+	Res ->
+	    exit({no_message,Res})
+    end. 
+
+%% Build a nodename
+join(Name,Host) ->
+    list_to_atom(atom_to_list(Name) ++ "@" ++ atom_to_list(Host)).
+
+%% start/stop slave.
+start_node(Name, Param) ->
+    ?t:start_node(Name, slave, [{args, Param}]).
+
+stop_node(Node) ->
+    ?t:stop_node(Node).
+
+
+get_nodenames(N, T) ->
+    get_nodenames(N, T, []).
+
+get_nodenames(0, _, Acc) ->
+    Acc;
+get_nodenames(N, T, Acc) ->
+    {A, B, C} = now(),
+    get_nodenames(N-1, T, [list_to_atom(atom_to_list(?MODULE)
+					++ "-"
+					++ atom_to_list(T)
+					++ "-"
+					++ integer_to_list(A)
+					++ "-"
+					++ integer_to_list(B)
+					++ "-"
+					++ integer_to_list(C)) | Acc]).