anchor.diff:      try 
           nklib_proc:try_call(Fun, {?MODULE, Ip, Port}, 100, 50)
       catch
  -        error:max_tries -> {error, max_tries}
  +        error:max_tries -> {error, {shared_failed, max_tries}}
       end.
   
   
   %% @private
  --spec do_start(nkpacket:nkport(), filter()) ->
  +-spec do_start(nkpacket:nkport(), user_filter()) ->
       {ok, pid()} | {error, term()}.
   
   do_start(#nkport{pid=Pid}=NkPort, Filter) when is_pid(Pid) ->
       #nkport{transp=Transp, listen_ip=Ip, listen_port=Port} = NkPort,
  -    case nklib_proc:values({?MODULE, Transp, Ip, Port}) of
  -        [{_Servers, Listen}|_] ->
  -            case nklib_util:call(Listen, {start, Pid, Filter}, 15000) of
  -                ok -> {ok, Listen};
  -                Error -> {error, {shared_failed, Error}}
  +    case nklib_proc:values({?MODULE, Ip, Port}) of
  +        [{_Filters, Listen}|_] ->
  +            case nklib_util:call(Listen, {start, Pid, Transp, Filter}, 15000) of
  +                ok -> 
  +                    {ok, Listen};
  +                {error, Error} -> 
  +                    {error, {shared_failed, Error}}
               end;
           [] ->
               gen_server:start(?MODULE, [NkPort, Filter], [])
  
positive.code:                 _ -> 
                      cowboy_req:set_resp_header(?WS_PROTO_HD, WsProto, Req)
              end,
              #{id:=Id, module:=Module} = Filter,
              case Module:cowboy_init(Id, Req1, Env) of
                  next -> 
                      execute(Rest, Req, Env);
  
negative.code: -spec handle_call(term(), {pid(), term()}, #state{}) ->
      {reply, term(), #state{}} | {noreply, term(), #state{}}.
  
  handle_call({start, ListenPid, Transp, Filter}, _From, State) ->
      #state{filters=Filters, nkport=#nkport{transp=BaseTransp}} = State,
      case secure(Transp)==secure(BaseTransp) of
          true ->
              Filter1 = make_filter(Filter, ListenPid, Transp),
              Filters1 = sort_filters([Filter1|Filters]),
              {reply, ok, register(State#state{filters=Filters1})};
          false ->
              {reply, {error, cannot_share_port}, State}
      end;
  
  handle_call({nkpacket_apply_nkport, Fun}, _From, #state{nkport=NkPort}=State) ->
      {reply, Fun(NkPort), State};
  