anchor.diff:                                  (hd(ConnLookup))#connection.state =:= up ->
                       ?connect_failure(Node,{barred_connection,
                                              ets:lookup(sys_dist, Node)}),
  +                    erts_internal:abort_connection(Node, ConnId),
                       {reply, false, State};
                   _ ->
  -                    case setup(ConnLookup, Node,ConnId,Type,From,State) of
  +                    case setup(ConnLookup, Node,ConnId,normal,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}),
  +                            erts_internal:abort_connection(Node, ConnId),
                               {reply, false, State}
                       end
               end
  
positive.code: 	    {stop, Error}
      end.
  
  
  do_auto_connect(Type, Node, ConnId, WaitForBarred, From, State) ->
      ConnLookup = ets:lookup(sys_dist, Node),
  
      case ConnLookup of
          [#barred_connection{}] ->
              case WaitForBarred of
                  false ->
                      {reply, false, State};
                  true ->
                      spawn(?MODULE,passive_connect_monitor,[From,Node]),
                      {noreply, State}
              end;
  
          [#connection{conn_id=ConnId, state = up}] ->
              {reply, true, State};
          [#connection{conn_id=ConnId, waiting=Waiting}=Conn] ->
  
negative.code:     verbose({auto_connect, Node, Nr, DHandle}, 1, State),
      ConnId = {Nr, DHandle},
      NewState =
          case do_auto_connect_1(Node, ConnId, noreply, State) of
              {noreply, S} ->           %% Pending connection
                  S;
  
  