emqx / esockd / 354

Committed 14 Dec 2023 12:54PM UTC coverage: 71.491%. First build

Build # 354

Build Type

Pull #183

github

Committed by

web-flow

Commit Message

Merge 3297859f4 into 5cb22a8b1

Pull Request Pull Request #183: feat(listener): support changing options on the fly

Run Details

170 of 192 new or added lines in 10 files covered. (88.54%)

820 of 1147 relevant lines covered (71.49%)

60.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.52

/src/esockd_dtls_listener.erl

%%--------------------------------------------------------------------
%% Copyright (c) 2020 EMQ Technologies Co., Ltd. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%--------------------------------------------------------------------

-module(esockd_dtls_listener).

-behaviour(gen_server).

-include("esockd.hrl").

-export([ start_link/4
        , start_supervised/1
        ]).

-export([ options/1
        , get_port/1
        , get_state/1
        , set_options/2
        ]).

%% gen_server callbacks
-export([ init/1
        , handle_call/3
        , handle_cast/2
        , handle_info/2
        , terminate/2
        , code_change/3
        ]).

-record(state, {
          proto     :: atom(),
          listen_on :: esockd:listen_on(),
          options   :: [esockd:option()],
          lsock     :: ssl:sslsocket(),
          laddr     :: inet:ip_address(),
          lport     :: inet:port_number()
         }).

-type option() :: {dtls_options, [gen_tcp:option()]}.

-define(DEFAULT_DTLS_OPTIONS,
        [{protocol, dtls},
         {mode, binary},
         {reuseaddr, true}]).

-spec start_link(atom(), esockd:listen_on(), [esockd:option()], pid() | ignore)
      -> {ok, pid()} | ignore | {error, term()}.
start_link(Proto, ListenOn, Opts, AcceptorSup) ->
    gen_server:start_link(?MODULE, {Proto, ListenOn, Opts, AcceptorSup}, []).

-spec start_supervised(esockd:listener_ref())
      -> {ok, pid()} | ignore | {error, term()}.
start_supervised(ListenerRef = {Proto, ListenOn}) ->
    Opts = esockd_server:get_listener_prop(ListenerRef, options),
    case start_link(Proto, ListenOn, Opts, ignore) of
        {ok, Pid} ->
            _ = esockd_server:set_listener_prop(ListenerRef, listener, {?MODULE, Pid}),
            {ok, Pid};
        Error ->
            Error
    end.

-spec(options(pid()) -> [esockd:option()]).
options(Listener) ->
    gen_server:call(Listener, options).

-spec(get_port(pid()) -> inet:port_number()).
get_port(Listener) ->
    gen_server:call(Listener, get_port).

-spec get_state(pid())  -> proplists:proplist().
get_state(Listener) ->
    gen_server:call(Listener, get_state).

-spec set_options(pid(), [option()])  -> ok.
set_options(Listener, Opts) ->
    gen_server:call(Listener, {set_options, Opts}).
    
%%--------------------------------------------------------------------
%% gen_server callbacks
%%--------------------------------------------------------------------

init({Proto, ListenOn, Opts, _Ignore}) ->
    Port = port(ListenOn),
    process_flag(trap_exit, true),
    esockd_server:ensure_stats({Proto, ListenOn}),
    SockOpts = merge_addr(ListenOn, dltsopts(Opts)),
    %% Don't active the socket...
    case ssl:listen(Port, esockd:merge_opts(?DEFAULT_DTLS_OPTIONS, SockOpts)) of
    %%case ssl:listen(Port, [{active, false} | proplists:delete(active, SockOpts)]) of
        {ok, LSock} ->
            {ok, {LAddr, LPort}} = ssl:sockname(LSock),
            %%error_logger:info_msg("~s listen on ~s:~p with ~p acceptors.~n",
            %%                      [Proto, inet:ntoa(LAddr), LPort, AcceptorNum]),
            {ok, #state{proto = Proto, listen_on = ListenOn, options = Opts,
                        lsock = LSock, laddr = LAddr, lport = LPort}};
        {error, Reason} ->
            error_logger:error_msg("~s failed to listen on ~p - ~p (~s)",
                                   [Proto, Port, Reason, inet:format_error(Reason)]),
            {stop, Reason}
    end.

dltsopts(Opts) ->
    proplists:delete(
     handshake_timeout,
     proplists:get_value(dtls_options, Opts, [])
    ).

port(Port) when is_integer(Port) -> Port;
port({_Addr, Port}) -> Port.

merge_addr(Port, SockOpts) when is_integer(Port) ->
    SockOpts;
merge_addr({Addr, _Port}, SockOpts) ->
    lists:keystore(ip, 1, SockOpts, {ip, Addr}).

handle_call(options, _From, State = #state{options = Opts}) ->
    {reply, Opts, State};

handle_call(get_port, _From, State = #state{lport = LPort}) ->
    {reply, LPort, State};

handle_call(get_state, _From, State = #state{lsock = LSock, lport = LPort}) ->
    Reply = [ {listen_sock, LSock}
            , {listen_port, LPort}
            ],
    {reply, Reply, State};

handle_call({set_options, Opts}, _From, State = #state{lsock = LSock}) ->
    case ssl:setopts(LSock, dltsopts(Opts)) of
        ok ->
            {reply, ok, State#state{options = Opts}};
        Error = {error, _} ->
            %% Setting dTLS options on listening socket always succeeds,
            %% even if the options are invalid.
            {reply, Error, State}
    end;

handle_call(Req, _From, State) ->
    error_logger:error_msg("[~s] Unexpected call: ~p", [?MODULE, Req]),
    {noreply, State}.

handle_cast(Msg, State) ->
    error_logger:error_msg("[~s] Unexpected cast: ~p", [?MODULE, Msg]),
    {noreply, State}.

handle_info(Info, State) ->
    error_logger:error_msg("[~s] Unexpected info: ~p", [?MODULE, Info]),
    {noreply, State}.

terminate(_Reason, #state{proto = Proto, listen_on = ListenOn,
                          lsock = LSock, laddr = Addr, lport = Port}) ->
    error_logger:info_msg("~s stopped on ~s~n", [Proto, esockd:format({Addr, Port})]),
    esockd_limiter:delete({listener, Proto, ListenOn}),
    esockd_server:del_stats({Proto, ListenOn}),
    esockd_transport:fast_close(LSock).

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.


1	%%--------------------------------------------------------------------
2	%% Copyright (c) 2020 EMQ Technologies Co., Ltd. All Rights Reserved.
3	%%
4	%% Licensed under the Apache License, Version 2.0 (the "License");
5	%% you may not use this file except in compliance with the License.
6	%% You may obtain a copy of the License at
7	%%
8	%% http://www.apache.org/licenses/LICENSE-2.0
9	%%
10	%% Unless required by applicable law or agreed to in writing, software
11	%% distributed under the License is distributed on an "AS IS" BASIS,
12	%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	%% See the License for the specific language governing permissions and
14	%% limitations under the License.
15	%%--------------------------------------------------------------------
16
17	-module(esockd_dtls_listener).
18
19	-behaviour(gen_server).
20
21	-include("esockd.hrl").
22
23	-export([ start_link/4
24	, start_supervised/1
25	]).
26
27	-export([ options/1
28	, get_port/1
29	, get_state/1
30	, set_options/2
31	]).
32
33	%% gen_server callbacks
34	-export([ init/1
35	, handle_call/3
36	, handle_cast/2
37	, handle_info/2
38	, terminate/2
39	, code_change/3
40	]).
41
42	-record(state, {
43	proto :: atom(),
44	listen_on :: esockd:listen_on(),
45	options :: [esockd:option()],
46	lsock :: ssl:sslsocket(),
47	laddr :: inet:ip_address(),
48	lport :: inet:port_number()
49	}).
50
51	-type option() :: {dtls_options, [gen_tcp:option()]}.
52
53	-define(DEFAULT_DTLS_OPTIONS,
54	[{protocol, dtls},
55	{mode, binary},
56	{reuseaddr, true}]).
57
58	-spec start_link(atom(), esockd:listen_on(), [esockd:option()], pid() \| ignore)
59	-> {ok, pid()} \| ignore \| {error, term()}.
60	start_link(Proto, ListenOn, Opts, AcceptorSup) ->
61	gen_server:start_link(?MODULE, {Proto, ListenOn, Opts, AcceptorSup}, []).	10✔
62
63	-spec start_supervised(esockd:listener_ref())
64	-> {ok, pid()} \| ignore \| {error, term()}.
65	start_supervised(ListenerRef = {Proto, ListenOn}) ->
66	Opts = esockd_server:get_listener_prop(ListenerRef, options),	10✔
67	case start_link(Proto, ListenOn, Opts, ignore) of	10✔
68	{ok, Pid} ->
69	_ = esockd_server:set_listener_prop(ListenerRef, listener, {?MODULE, Pid}),	10✔
70	{ok, Pid};	10✔
71	Error ->
NEW 72	Error	×
73	end.
74
75	-spec(options(pid()) -> [esockd:option()]).
76	options(Listener) ->
77	gen_server:call(Listener, options).	×
78
79	-spec(get_port(pid()) -> inet:port_number()).
80	get_port(Listener) ->
81	gen_server:call(Listener, get_port).	×
82
83	-spec get_state(pid()) -> proplists:proplist().
84	get_state(Listener) ->
85	gen_server:call(Listener, get_state).	12✔
86
87	-spec set_options(pid(), [option()]) -> ok.
88	set_options(Listener, Opts) ->
89	gen_server:call(Listener, {set_options, Opts}).	2✔
90
91	%%--------------------------------------------------------------------
92	%% gen_server callbacks
93	%%--------------------------------------------------------------------
94
95	init({Proto, ListenOn, Opts, _Ignore}) ->
96	Port = port(ListenOn),	10✔
97	process_flag(trap_exit, true),	10✔
98	esockd_server:ensure_stats({Proto, ListenOn}),	10✔
99	SockOpts = merge_addr(ListenOn, dltsopts(Opts)),	10✔
100	%% Don't active the socket...
101	case ssl:listen(Port, esockd:merge_opts(?DEFAULT_DTLS_OPTIONS, SockOpts)) of	10✔
102	%%case ssl:listen(Port, [{active, false} \| proplists:delete(active, SockOpts)]) of
103	{ok, LSock} ->
104	{ok, {LAddr, LPort}} = ssl:sockname(LSock),	10✔
105	%%error_logger:info_msg("~s listen on ~s:~p with ~p acceptors.~n",
106	%% [Proto, inet:ntoa(LAddr), LPort, AcceptorNum]),
107	{ok, #state{proto = Proto, listen_on = ListenOn, options = Opts,	10✔
108	lsock = LSock, laddr = LAddr, lport = LPort}};
109	{error, Reason} ->
110	error_logger:error_msg("~s failed to listen on ~p - ~p (~s)",	×
111	[Proto, Port, Reason, inet:format_error(Reason)]),
112	{stop, Reason}	×
113	end.
114
115	dltsopts(Opts) ->
116	proplists:delete(	12✔
117	handshake_timeout,
118	proplists:get_value(dtls_options, Opts, [])
119	).
120
121	port(Port) when is_integer(Port) -> Port;	10✔
122	port({_Addr, Port}) -> Port.	×
123
124	merge_addr(Port, SockOpts) when is_integer(Port) ->
125	SockOpts;	10✔
126	merge_addr({Addr, _Port}, SockOpts) ->
127	lists:keystore(ip, 1, SockOpts, {ip, Addr}).	×
128
129	handle_call(options, _From, State = #state{options = Opts}) ->
130	{reply, Opts, State};	×
131
132	handle_call(get_port, _From, State = #state{lport = LPort}) ->
133	{reply, LPort, State};	×
134
135	handle_call(get_state, _From, State = #state{lsock = LSock, lport = LPort}) ->
136	Reply = [ {listen_sock, LSock}	12✔
137	, {listen_port, LPort}
138	],
139	{reply, Reply, State};	12✔
140
141	handle_call({set_options, Opts}, _From, State = #state{lsock = LSock}) ->
142	case ssl:setopts(LSock, dltsopts(Opts)) of	2✔
143	ok ->
144	{reply, ok, State#state{options = Opts}};	2✔
145	Error = {error, _} ->
146	%% Setting dTLS options on listening socket always succeeds,
147	%% even if the options are invalid.
NEW 148	{reply, Error, State}	×
149	end;
150
151	handle_call(Req, _From, State) ->
152	error_logger:error_msg("[~s] Unexpected call: ~p", [?MODULE, Req]),	×
153	{noreply, State}.	×
154
155	handle_cast(Msg, State) ->
156	error_logger:error_msg("[~s] Unexpected cast: ~p", [?MODULE, Msg]),	×
157	{noreply, State}.	×
158
159	handle_info(Info, State) ->
160	error_logger:error_msg("[~s] Unexpected info: ~p", [?MODULE, Info]),	×
161	{noreply, State}.	×
162
163	terminate(_Reason, #state{proto = Proto, listen_on = ListenOn,
164	lsock = LSock, laddr = Addr, lport = Port}) ->
165	error_logger:info_msg("~s stopped on ~s~n", [Proto, esockd:format({Addr, Port})]),	10✔
166	esockd_limiter:delete({listener, Proto, ListenOn}),	10✔
167	esockd_server:del_stats({Proto, ListenOn}),	10✔
168	esockd_transport:fast_close(LSock).	10✔
169
170	code_change(_OldVsn, State, _Extra) ->
171	{ok, State}.	×
172

emqx / esockd / 354

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous