anchor.diff:              exit({accept, Reason})
       end.
   
  -
  -handle_accept_success(Sock) ->
  -    Self    = self(),
  -    Handler = spawn_link(fun() -> handler_init(Self, Sock) end),
  -    case socket:setopt(Sock, otp, controlling_process, Handler) of
  -        ok ->
  -            %% Normally we should have a msgs collection here
  -            %% (of messages we receive before the control was
  -            %% handled over to Handler), but since we don't 
  -            %% have active implemented yet...
  -            handler_continue(Handler),
  -            {ok, {Handler, Sock}};
  -       {error, _} = ERROR ->
  -            exit(Handler, kill),
  +acceptor_handle_accept_success(#acceptor{manager = Manager}, Sock) ->
  +    i("try start handler"),
  +    case manager_start_handler(Manager, Sock) of
  +        {ok, Pid} ->
  +            i("handler (~p) started - now change 'ownership'", [Pid]),
  +            case socket:setopt(Sock, otp, controlling_process, Pid) of
  +                ok ->
  +                    %% Normally we should have a msgs collection here
  +                    %% (of messages we receive before the control was
  +                    %% handled over to Handler), but since we don't 
  +                    %% have active implemented yet...
  +                    i("new handler (~p) now controlling process", [Pid]),
  +                    handler_continue(Pid),
  +                    ok;
  +                {error, _} = ERROR ->
  +                    exit(Pid, kill),
  +                    ERROR
  +            end;
  +        {error, Reason2} ->
  +            e("failed starting handler: "
  +              "~n   (new) Socket: ~p"
  +              "~n   Reason:       ~p", [Sock, Reason2]),
  +            exit({failed_starting_handler, Reason2})
  +    end.
  +
  +
  +
  +%% =========================================================================
  +
  +handler_start(ID, Sock) ->
  +    Self = self(),
  +    H = {Pid, _} = spawn_monitor(fun() -> handler_init(Self, ID, Sock) end),
  +    receive
  +        {handler, Pid, ok} ->
  +            {ok, H};
  +        {handler, Pid, {error, _} = ERROR} ->
  +            exit(Pid, kill), % Just in case
               ERROR
       end.
   
  -
  -handler_init(Parent, Socket) ->
  -    put(sname, "handler"),
  -    receive
  -        {handler, Parent, continue} ->
  -            socket:setopt(Socket, otp, debug, true),
  -            handler_loop(#handler{parent = Parent,
  -                                  socket = Socket})
  -    end.
  -
  -handler_continue(Handler) ->
  -    Handler ! {handler, self(), continue}.
  +handler_stop(Pid, _Reason) ->
  +    %% handler_request(Pid, {stop, Reason}).
  +    exit(Pid, kill).
  +
  +handler_continue(Pid) ->
  +    handler_request(Pid, continue).
  +
  +handler_request(Pid, Request) ->
  +    request(handler, Pid, Request).
  +
  +handler_reply(Pid, Ref, Reply) ->
  +    reply(handler, Pid, Ref, Reply).
  +
  +
  +handler_init(Manager, ID, Sock) ->
  +    put(sname, f("handler:~w", [ID])),
  +    i("starting"),
  +    Manager ! {handler, self(), ok},
  +    receive
  +        {handler, Pid, Ref, continue} ->
  +            i("continue"),
  +            handler_reply(Pid, Ref, ok),
  +            %% socket:setopt(Socket, otp, debug, true),
  +            handler_loop(#handler{manager = Manager,
  +                                  socket  = Sock})
  +    end.
   
   handler_loop(#handler{socket = Socket} = H) ->
  -    case socket:recv(Socket, 0) of
  -        {ok, Msg} when (size(Msg) =:= 0) ->
  -            i("received empty msg - hickup? - try again", []),
  -            handler_loop(H);
  +    case socket:recv(Socket) of
           {ok, Msg} ->
               i("received ~w bytes of data", [size(Msg)]),
               case dec_msg(Msg) of
  
positive.code:     {reply, N, Data}.
  
  
  %% ---
  
  formated_timestamp() ->
  
negative.code:               "~n   ~p"
                "~nwhen"
                "~n   ~p", [Sock, socket:info()]),
              case acceptor_handle_accept_success(A, Sock) of
                  ok ->
                      acceptor_loop(A);
                  {error, Reason} ->
                      e("Failed starting handler: "
                        "~n   ~p", [Reason]),
                      socket:close(Sock),
                      exit({failed_starting_handler, Reason})
              end;
          {error, Reason} ->
              e("accept failure: "
  