View Source erldist_filter_otp_26_0_2_inet_tcp_dist (erldist_filter v1.1.0)

Link to this section Summary

Link to this section Functions

-spec accept(Listen) -> AcceptPid :: pid() when Listen :: gen_tcp:socket().
Link to this function

accept_connection(AcceptPid, Socket, MyNode, Allowed, SetupTime)

View Source
-spec accept_connection(AcceptPid, Socket, MyNode, Allowed, SetupTime) ->
                     ConnectionSupervisorPid :: pid()
                     when
                         AcceptPid :: pid(),
                         Socket :: gen_tcp:socket(),
                         MyNode :: node(),
                         Allowed :: list(),
                         SetupTime :: non_neg_integer().
Link to this function

accept_loop(Driver, Kernel, Listen)

View Source
-spec accept_loop(Driver, Kernel, Listen) -> no_return()
               when Driver :: module(), Kernel :: pid(), Listen :: gen_tcp:socket().
-spec address() -> Address :: #net_address{}.
-spec close(Socket) -> ok when Socket :: gen_tcp:socket().
Link to this function

do_accept(Driver, Kernel, AcceptPid, Socket, MyNode, Allowed, SetupTime)

View Source
-spec do_accept(Driver, Kernel, AcceptPid, Socket, MyNode, Allowed, SetupTime) -> no_return()
             when
                 Driver :: module(),
                 Kernel :: pid(),
                 AcceptPid :: pid(),
                 Socket :: gen_tcp:socket(),
                 MyNode :: node(),
                 Allowed :: [node()],
                 SetupTime :: non_neg_integer().
Link to this function

do_setup(Driver, Kernel, Node, Type, MyNode, LongOrShortNames, SetupTime)

View Source
-spec do_setup(Driver, Kernel, Node, Type, MyNode, LongOrShortNames, SetupTime) -> no_return()
            when
                Driver :: module(),
                Kernel :: pid(),
                Node :: node(),
                Type :: atom(),
                MyNode :: node(),
                LongOrShortNames :: shortnames | longnames,
                SetupTime :: non_neg_integer().
-spec fam_address(Family) -> Address when Family :: inet:address_family(), Address :: #net_address{}.
Link to this function

fam_listen(Family, Name, Host, ListenFun)

View Source
-spec fam_listen(Family, Name, Host, ListenFun) ->
              {ok, {ListeningSocket, Address, Creation}} | {error, Reason}
              when
                  Family :: inet:address_family(),
                  Name :: node(),
                  Host :: inet:hostname(),
                  ListeningSocket :: gen_tcp:socket(),
                  Address :: #net_address{},
                  Creation :: 1..4294967295,
                  Reason :: system_limit | inet:posix(),
                  ListenFun ::
                      fun((inet:port_number(), inet:port_number(), [gen_tcp:listen_option()]) ->
                              {ok, ListeningSocket} | {error, Reason}).
Link to this function

fam_select(Family, Node)

View Source
-spec fam_select(Family, Node) -> boolean() when Family :: inet:address_family(), Node :: node().
Link to this function

fam_setup(Family, Node, LongOrShortNames, ParseAddress)

View Source
-spec fam_setup(Family, Node, LongOrShortNames, ParseAddress) -> {NetAddress, ConnectOptions, Version}
             when
                 Family :: inet:address_family(),
                 Node :: node(),
                 LongOrShortNames :: shortnames | longnames,
                 ParseAddress :: fun((string()) -> inet:ip_address()),
                 NetAddress :: #net_address{},
                 ConnectOptions :: [gen_tcp:connect_option()],
                 Version :: non_neg_integer().
Link to this function

gen_accept(Driver, Listen)

View Source
-spec gen_accept(Driver, Listen) -> AcceptPid :: pid()
              when Driver :: module(), Listen :: gen_tcp:socket().
Link to this function

gen_accept_connection(Driver, AcceptPid, Socket, MyNode, Allowed, SetupTime)

View Source
-spec gen_accept_connection(Driver, AcceptPid, Socket, MyNode, Allowed, SetupTime) ->
                         ConnectionSupervisorPid :: pid()
                         when
                             Driver :: module(),
                             AcceptPid :: pid(),
                             Socket :: gen_tcp:socket(),
                             MyNode :: node(),
                             Allowed :: list(),
                             SetupTime :: non_neg_integer().
-spec gen_address(Driver) -> Address when Driver :: module(), Address :: #net_address{}.
Link to this function

gen_hs_data(Driver, Socket)

View Source
-spec gen_hs_data(Driver, Socket) -> HSData
               when Driver :: module(), Socket :: gen_tcp:socket(), HSData :: #hs_data{}.
Link to this function

gen_listen(Driver, Name, Host)

View Source
-spec gen_listen(Driver, Name, Host) -> {ok, {ListeningSocket, Address, Creation}} | {error, Reason}
              when
                  Driver :: module(),
                  Name :: node(),
                  Host :: inet:hostname(),
                  ListeningSocket :: gen_tcp:socket(),
                  Address :: #net_address{},
                  Creation :: 1..4294967295,
                  Reason :: system_limit | inet:posix().
Link to this function

gen_select(Driver, Node)

View Source
-spec gen_select(Driver, Node) -> boolean() when Driver :: module(), Node :: node().
Link to this function

gen_setup(Driver, Node, Type, MyNode, LongOrShortNames, SetupTime)

View Source
-spec gen_setup(Driver, Node, Type, MyNode, LongOrShortNames, SetupTime) ->
             ConnectionSupervisorPid :: pid()
             when
                 Driver :: module(),
                 Node :: node(),
                 Type :: atom(),
                 MyNode :: node(),
                 LongOrShortNames :: shortnames | longnames,
                 SetupTime :: non_neg_integer().
Link to this function

getopts(ListeningSocket, Options)

View Source
-spec getopts(ListeningSocket, Options) -> {ok, OptionValues} | {error, Error}
           when
               ListeningSocket :: gen_tcp:socket(),
               Options :: [inet:socket_getopt()],
               OptionValues :: [inet:socket_optval()],
               Error :: inet:posix().
-spec getstat(Socket) -> {ok, RecvCnt, SendCnt, SendPend} | {error, inet:posix()}
           when
               Socket :: gen_tcp:socket(),
               RecvCnt :: integer(),
               SendCnt :: integer(),
               SendPend :: integer().
-spec is_node_name(Node) -> boolean() when Node :: node().
-spec listen(Name) -> {ok, {ListeningSocket, Address, Creation}} | {error, Reason}
          when
              Name :: node(),
              ListeningSocket :: gen_tcp:socket(),
              Address :: #net_address{},
              Creation :: 1..4294967295,
              Reason :: system_limit | inet:posix().
-spec listen(Name, Host) -> {ok, {ListeningSocket, Address, Creation}} | {error, Reason}
          when
              Name :: node(),
              Host :: inet:hostname(),
              ListeningSocket :: gen_tcp:socket(),
              Address :: #net_address{},
              Creation :: 1..4294967295,
              Reason :: system_limit | inet:posix().
Link to this function

merge_options(Opts, ForcedOpts)

View Source
-spec merge_options(Opts, ForcedOpts) -> MergedOpts
                 when
                     Opts :: proplists:proplist(),
                     ForcedOpts :: proplists:proplist(),
                     MergedOpts :: proplists:proplist().
Link to this function

merge_options(Opts, ForcedOpts, DefaultOpts)

View Source
-spec merge_options(Opts, ForcedOpts, DefaultOpts) -> MergedOpts
                 when
                     Opts :: proplists:proplist(),
                     ForcedOpts :: proplists:proplist(),
                     DefaultOpts :: proplists:proplist(),
                     MergedOpts :: proplists:proplist().
-spec nodelay() -> {nodelay, boolean()}.
-spec receiver(Driver) -> no_return() when Driver :: module().
-spec select(Node) -> boolean() when Node :: node().
-spec sender(Driver) -> no_return() when Driver :: module().
Link to this function

setopts(ListeningSocket, Options)

View Source
-spec setopts(ListeningSocket, Options) -> ok | {error, Error}
           when
               ListeningSocket :: gen_tcp:socket(),
               Options :: [inet:socket_setopt()],
               Error :: inet:posix() | {badopts, Options}.
Link to this function

setup(Node, Type, MyNode, LongOrShortNames, SetupTime)

View Source
-spec setup(Node, Type, MyNode, LongOrShortNames, SetupTime) -> ConnectionSupervisorPid :: pid()
         when
             Node :: node(),
             Type :: atom(),
             MyNode :: node(),
             LongOrShortNames :: shortnames | longnames,
             SetupTime :: non_neg_integer().
-spec tick(Driver, Socket) -> ok | {error, closed | inet:posix()}
        when Driver :: module(), Socket :: gen_tcp:socket().