anchor.diff:  				  [Proto]),
   	    start_protos(Name,Ps, Node, Ls);
   	{error, Reason} ->
  -	    error_logger:info_msg("Protocol: ~p: register/listen error: ~p~n", 
  +	    error_logger:info_msg("Protocol: ~p: register/listen error: ~p~n",
   				  [Proto, Reason]),
   	    start_protos(Name,Ps, Node, Ls)
       end;
  
positive.code:        true ->
  	    get_proto_mod(Family,Protocol,Ls)
      end;
  get_proto_mod(_Family, _Protocol, []) ->    
      error.
  
  %% -------- Initialisation functions ------------------------
  
negative.code: 		    {noreply,State#state{conn_owners=Owners}};
  		_  ->
  		    ?connect_failure(Node, {setup_call, failed}),
  		    async_reply({reply, false, State}, From)
  	    end
      end;
  
  %%
  %% Close the connection to Node.
  %%
  handle_call({disconnect, Node}, From, State) when Node =:= node() ->
      async_reply({reply, false, State}, From);
  handle_call({disconnect, Node}, From, State) ->
      verbose({disconnect, Node}, 1, State),
      {Reply, State1} = do_disconnect(Node, State),
      async_reply({reply, Reply, State1}, From);
  
  %%
  %% The spawn/4 BIF ends up here.
  %%
  handle_call({spawn,M,F,A,Gleader},{From,Tag},State) when is_pid(From) ->
      do_spawn([no_link,{From,Tag},M,F,A,Gleader],[],State);
  
  %%
  %% The spawn_link/4 BIF ends up here.
  %%
  handle_call({spawn_link,M,F,A,Gleader},{From,Tag},State) when is_pid(From) ->
      do_spawn([link,{From,Tag},M,F,A,Gleader],[],State);
  
  %%
  %% The spawn_opt/5 BIF ends up here.
  %%
  handle_call({spawn_opt,M,F,A,O,L,Gleader},{From,Tag},State) when is_pid(From) ->
      do_spawn([L,{From,Tag},M,F,A,Gleader],O,State);
  
  %%
  %% Only allow certain nodes.
  %%
  handle_call({allow, Nodes}, From, State) ->
      case all_atoms(Nodes) of
  	true ->
  	    Allowed = State#state.allowed,
              async_reply({reply,ok,State#state{allowed = Allowed ++ Nodes}},
                          From);
  	false ->
  	    async_reply({reply,error,State}, From)
      end;
  
  %%
  %% authentication, used by auth. Simply works as this:
  %% if the message comes through, the other node IS authorized.
  %%
  handle_call({is_auth, _Node}, From, State) ->
      async_reply({reply,yes,State}, From);
  
  %%
  %% Not applicable any longer !?
  %%
  handle_call({apply,_Mod,_Fun,_Args}, {From,Tag}, State)
    when is_pid(From), node(From) =:= node() ->
      async_gen_server_reply({From,Tag}, not_implemented),
  %    Port = State#state.port,
  %    catch apply(Mod,Fun,[Port|Args]),
      {noreply,State};
  
  handle_call(longnames, From, State) ->
      async_reply({reply, get(longnames), State}, From);
  
  handle_call({update_publish_nodes, Ns}, From, State) ->
      async_reply({reply, ok, State#state{publish_on_nodes = Ns}}, From);
  
  handle_call({publish_on_node, Node}, From, State) ->
      NewState = case State#state.publish_on_nodes of
  		   undefined ->
  		       State#state{publish_on_nodes =
  