anchor.diff:  -define(REQ, 0).
   -define(REP, 1).
   
  --record(handler, {socket, parent}).
  +-record(manager, {acceptor, handler_id, handlers}).
  +-record(acceptor, {socket, manager}).
  +-record(handler, {socket, manager}).
   
   start() ->
       start_tcp().
  
positive.code:             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),
              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_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);
          {ok, Msg} ->
              i("received ~w bytes of data", [size(Msg)]),
              case dec_msg(Msg) of
  
negative.code:     which_addr2(Domain, IFO).
  
  
  acceptor_loop(#acceptor{socket = LSock} = A) ->
      i("try accept"),
      case socket:accept(LSock, infinity) of
          {ok, Sock} ->
  