anchor.diff:          case Res of
               ok -> {F, {net,
                   fun (Data) ->  
  -                    Attempt = get_attempt(),                  
                       case erlamsa_netutils:accept(Transport, ListenSock) of
                           {ok, ClientSock} ->
                               {ok, {IP, _}} = erlamsa_netutils:sockname(Transport, ClientSock), 
  
positive.code: -spec streamsock_writer(tcp | tls, inet:ip_address(), inet:port_number(), fun()) -> fun().
  streamsock_writer(Transport, Addr, Port, Maker) ->
      erlamsa_netutils:set_routing_ip(tcp, Addr, Port),
      fun F(_N, Meta) ->
          Attempt = get_attempt(),
          erlamsa_netutils:netserver_start(Transport, false),
          {Res, Sock} = erlamsa_netutils:connect(Transport, Addr, Port, [binary, {active, true}], ?TCP_TIMEOUT),
          case Res of
              ok -> {F, {net,
                  fun (Data) -> Packet = Maker(Data), 
                                erlamsa_netutils:send(Transport, Sock, Packet), 
                                receive 
                                   {_ProtoTransport, _ClientSocket, RecvData} -> erlamsa_logger:log_data(info, "reply [case = ~p] from target",
                                               [Attempt], RecvData),
                                   ok
                                after 
                                   25 -> ok  %% FIXME: AS PARAMATER!!!!
                                end
                          end,
                  %% TODO: ugly timeout before closing..., should be in another thread
                  fun () -> timer:sleep(25), erlamsa_netutils:close(Transport, Sock), ok end
                  }, [{output, Transport} | Meta]};
              _Else ->
                  Err = lists:flatten(io_lib:format("Error opening ~p socket to ~s:~p '~s'",
  
negative.code: -spec exec_writer(string()) -> fun().
  exec_writer(App) ->
      %%TODO: FIXME: select correct path
      exec:start([{portexe, erlamsa_utils:get_portsdir() ++ "exec-port"}]),  
      fun F(Attempt, Meta) ->
          Watcher = spawn(
                      fun W() -> 
                          receive 
                              {Stream, Pid, Data} -> 
                                  erlamsa_logger:log_data(info, "received [case = ~p] from ~p on ~p", [Attempt, Pid, Stream], Data);
                              Unknown -> 
                                  erlamsa_logger:log(info, "received [case = ~p]: ~p", [Attempt, Unknown])                                
                          end, W()
                      end),
          {ok, Pid, OsPid} = exec:run(App, [stdin, monitor, {stdout, Watcher}, {stderr, Watcher}]),
          erlamsa_logger:log(info, "new process is executed [OS Pid = ~p]", [OsPid]),
          erlamsa_monitor:send_pid(OsPid),
  