anchor.diff:  
   %% Called though BIF's
   
  -connect(Node) ->               do_connect(Node, normal, false).
  +connect(Node) ->               auto_connect(Node, normal, false).
   %%% Long timeout if blocked (== barred), only affects nodes with
   %%% {dist_auto_connect, once} set.
  -passive_cnct(Node) ->              do_connect(Node, normal, true).
  +passive_cnct(Node) ->          auto_connect(Node, normal, true).
   disconnect(Node) ->            request({disconnect, Node}).
   
   %% connect but not seen
  -hidden_connect(Node) ->        do_connect(Node, hidden, false).
  +hidden_connect(Node) ->        auto_connect(Node, hidden, false).
   
   %% Should this node publish itself on Node?
   publish_on_node(Node) when is_atom(Node) ->
  
positive.code:     end.
  
  
  %% ------------------------------------------------------------
  %% handle_call.
  %% ------------------------------------------------------------
  
  %%
  %% Set up a connection to Node.
  %% The response is delayed until the connection is up and
  %% running.
  %%
  handle_call({connect, _, Node}, From, State) when Node =:= node() ->
      async_reply({reply, true, State}, From);
  handle_call({connect, Type, Node}, From, State) ->
      verbose({connect, Type, Node}, 1, State),
      case ets:lookup(sys_dist, Node) of
  	[Conn] when Conn#connection.state =:= up ->
  	    async_reply({reply, true, State}, From);
  	[Conn] when Conn#connection.state =:= pending ->
  	    Waiting = Conn#connection.waiting,
  	    ets:insert(sys_dist, Conn#connection{waiting = [From|Waiting]}),
  	    {noreply, State};
  	[Conn] when Conn#connection.state =:= up_pending ->
  	    Waiting = Conn#connection.waiting,
  	    ets:insert(sys_dist, Conn#connection{waiting = [From|Waiting]}),
  	    {noreply, State};
  	_ ->
  	    case setup(Node,Type,From,State) of
  		{ok, SetupPid} ->
  		    Owners = [{SetupPid, Node} | State#state.conn_owners],
  		    {noreply,State#state{conn_owners=Owners}};
  		_Error  ->
  		    ?connect_failure(Node, {setup_call, failed, _Error}),
  		    async_reply({reply, false, State}, From)
  	    end
      end;
  
  %%
  %% Close the connection to Node.
  
negative.code: hidden_connect_node(Node) when is_atom(Node) ->
      request({connect, hidden, Node}).
  
  auto_connect(Node, Type, WaitForBarred) -> %% Type = normal | hidden
      case request({auto_connect, Type, Node, WaitForBarred}) of
          ignored -> false;
          Other -> Other
      end.
  
  passive_connect_monitor(From, Node) ->
      ok = monitor_nodes(true,[{node_type,all}]),
      Reply = case lists:member(Node,nodes([connected])) of
                  true ->
                      io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                      true;
                  _ ->
                      receive
                          {nodeup,Node,_} ->
                              io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                              true
                      after connecttime() ->
                              io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                              false
                      end
              end,
      ok = monitor_nodes(false,[{node_type,all}]),
      io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
      {Pid, Tag} = From,
      io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
      erlang:send(Pid, {Tag, Reply}),
      io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]).
  
  
  %% If the net_kernel isn't running we ignore all requests to the
  %% kernel, thus basically accepting them :-)
  