acceptor_SUITE.erl 67 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852
  1. %% Copyright (c) 2011-2020, Loïc Hoguin <essen@ninenines.eu>
  2. %% Copyright (c) 2020, Jan Uhlig <j.uhlig@mailingwork.de>
  3. %%
  4. %% Permission to use, copy, modify, and/or distribute this software for any
  5. %% purpose with or without fee is hereby granted, provided that the above
  6. %% copyright notice and this permission notice appear in all copies.
  7. %%
  8. %% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  9. %% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10. %% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11. %% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12. %% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13. %% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14. %% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15. -module(acceptor_SUITE).
  16. -compile(export_all).
  17. -compile(nowarn_export_all).
  18. -dialyzer({nowarn_function, misc_wait_for_connections/1}).
  19. %% @todo Remove when specs in ssl are updated to accept local addresses.
  20. -dialyzer({nowarn_function, do_ssl_local_echo/0}).
  21. -import(ct_helper, [config/2]).
  22. -import(ct_helper, [doc/1]).
  23. -import(ct_helper, [name/0]).
  24. %% ct.
  25. all() ->
  26. [{group, tcp}, {group, tcp_socket}, {group, ssl}, {group, misc}, {group, supervisor}].
  27. groups() ->
  28. [{tcp, [
  29. tcp_active_echo,
  30. tcp_active_n_echo,
  31. tcp_echo,
  32. tcp_local_echo,
  33. tcp_graceful,
  34. tcp_inherit_options,
  35. tcp_max_connections,
  36. tcp_max_connections_and_beyond,
  37. tcp_max_connections_infinity,
  38. tcp_remove_connections,
  39. tcp_remove_connections_acceptor_wakeup,
  40. tcp_set_max_connections,
  41. tcp_set_max_connections_clean,
  42. tcp_getopts_capability,
  43. tcp_getstat_capability,
  44. tcp_upgrade,
  45. tcp_10_acceptors_10_listen_sockets,
  46. tcp_many_listen_sockets_no_reuseport,
  47. tcp_error_eaddrinuse,
  48. tcp_error_eacces
  49. ]}, {tcp_socket, [
  50. tcp_active_echo,
  51. tcp_active_n_echo,
  52. tcp_echo,
  53. tcp_graceful,
  54. tcp_inherit_options,
  55. tcp_max_connections,
  56. tcp_max_connections_and_beyond,
  57. tcp_max_connections_infinity,
  58. tcp_remove_connections,
  59. tcp_remove_connections_acceptor_wakeup,
  60. tcp_set_max_connections,
  61. tcp_set_max_connections_clean,
  62. tcp_getopts_capability,
  63. tcp_getstat_capability,
  64. tcp_upgrade,
  65. %% @TODO: Enable when https://github.com/erlang/otp/issues/5122
  66. %% is in an official release, probably 24.1.
  67. % tcp_10_acceptors_10_listen_sockets,
  68. % tcp_many_listen_sockets_no_reuseport,
  69. tcp_error_eaddrinuse
  70. %% @TODO: Not working in OTP/24.0 but fixed in current master.
  71. %% Enable when fixed in an official release, probably 24.1.
  72. % tcp_error_eacces
  73. ]}, {ssl, [
  74. ssl_accept_error,
  75. ssl_active_echo,
  76. ssl_active_n_echo,
  77. ssl_echo,
  78. ssl_local_echo,
  79. ssl_graceful,
  80. ssl_handshake,
  81. ssl_sni_echo,
  82. ssl_sni_fail,
  83. ssl_tls_psk,
  84. ssl_tls_psk_fail,
  85. ssl_upgrade_from_tcp,
  86. ssl_getopts_capability,
  87. ssl_getstat_capability,
  88. ssl_10_acceptors_10_listen_sockets,
  89. ssl_many_listen_sockets_no_reuseport,
  90. ssl_error_eaddrinuse,
  91. ssl_error_no_cert,
  92. ssl_error_eacces,
  93. ssl_unsupported_tlsv13_options
  94. ]}, {misc, [
  95. misc_bad_transport,
  96. misc_bad_transport_options,
  97. misc_repeated_remove,
  98. misc_info,
  99. misc_info_embedded,
  100. misc_metrics,
  101. misc_opts_logger,
  102. misc_post_listen_callback,
  103. misc_post_listen_callback_error,
  104. misc_set_transport_options,
  105. misc_wait_for_connections,
  106. misc_multiple_ip_local_socket_opts
  107. ]}, {supervisor, [
  108. connection_type_supervisor,
  109. connection_type_supervisor_separate_from_connection,
  110. supervisor_10_acceptors_1_conns_sup,
  111. supervisor_9_acceptors_4_conns_sups,
  112. supervisor_10_acceptors_10_conns_sups,
  113. supervisor_1_acceptor_10_conns_sups,
  114. supervisor_changed_options_restart,
  115. supervisor_clean_child_restart,
  116. supervisor_clean_restart,
  117. supervisor_conns_alive,
  118. supervisor_embedded_ranch_server_crash,
  119. supervisor_protocol_start_link_crash,
  120. supervisor_server_recover_state,
  121. supervisor_unexpected_message
  122. ]}].
  123. init_per_group(tcp_socket, Config) ->
  124. %% The socket backend for inet/gen_tcp was introduced as an experimental
  125. %% feature in OTP/23.0, and bugs https://bugs.erlang.org/browse/ERL-1284,
  126. %% 1287 and 1293 were solved in OTP/23.1. socket:use_registry/1 first
  127. %% appears in this release.
  128. %% Due to https://bugs.erlang.org/browse/ERL-1401, the socket backend
  129. %% is not working on Windows.
  130. case
  131. os:type() =/= {win32, nt} andalso
  132. code:ensure_loaded(socket) =:= {module, socket} andalso
  133. erlang:function_exported(socket, use_registry, 1)
  134. of
  135. true ->
  136. [{socket_opts, [{inet_backend, socket}]}|Config];
  137. false ->
  138. {skip, "No socket backend support"}
  139. end;
  140. init_per_group(_, Config) ->
  141. case
  142. code:ensure_loaded(socket) =:= {module, socket} andalso
  143. erlang:function_exported(socket, use_registry, 1)
  144. of
  145. true ->
  146. [{socket_opts, [{inet_backend, inet}]}|Config];
  147. false ->
  148. [{socket_opts, []}|Config]
  149. end.
  150. end_per_group(_, _) ->
  151. ok.
  152. %% misc.
  153. misc_bad_transport(_) ->
  154. doc("Reject invalid transport modules."),
  155. {error, {bad_transport, invalid_transport}} = ranch:start_listener(misc_bad_transport,
  156. invalid_transport, #{},
  157. echo_protocol, []),
  158. ok.
  159. misc_bad_transport_options(_) ->
  160. doc("Ignore invalid transport options."),
  161. {ok, _} = ranch:start_listener(misc_bad_transport_options,
  162. ranch_tcp, [binary, {packet, 4}, <<"garbage">>, raw, backlog],
  163. echo_protocol, []),
  164. ok.
  165. misc_info(_) ->
  166. doc("Information about listeners."),
  167. %% Open a listener with a few connections.
  168. {ok, Pid1} = ranch:start_listener({misc_info, tcp},
  169. ranch_tcp, #{num_acceptors => 1},
  170. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  171. Port1 = ranch:get_port({misc_info, tcp}),
  172. %% Open a few more listeners with different arguments.
  173. {ok, Pid2} = ranch:start_listener({misc_info, act},
  174. ranch_tcp, #{num_acceptors => 2},
  175. active_echo_protocol, {}),
  176. Port2 = ranch:get_port({misc_info, act}),
  177. ranch:set_max_connections({misc_info, act}, infinity),
  178. Opts = ct_helper:get_certs_from_ets(),
  179. {ok, Pid3} = ranch:start_listener({misc_info, ssl},
  180. ranch_ssl, #{num_acceptors => 3, socket_opts => Opts},
  181. echo_protocol, [{}]),
  182. Port3 = ranch:get_port({misc_info, ssl}),
  183. %% Open 5 connections, 3 removed from the count.
  184. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  185. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  186. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  187. receive after 250 -> ok end,
  188. ranch:set_protocol_options({misc_info, tcp}, [{remove, false, 2500}]),
  189. receive after 250 -> ok end,
  190. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  191. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  192. receive after 250 -> ok end,
  193. %% Confirm the info returned by Ranch is correct.
  194. #{
  195. {misc_info, act} := #{
  196. pid := Pid2,
  197. port := Port2,
  198. max_connections := infinity, %% Option was modified.
  199. active_connections := 0,
  200. all_connections := 0,
  201. transport := ranch_tcp,
  202. transport_options := #{num_acceptors := 2},
  203. protocol := active_echo_protocol,
  204. protocol_options := {}
  205. },
  206. {misc_info, ssl} := #{
  207. pid := Pid3,
  208. port := Port3,
  209. max_connections := 1024,
  210. active_connections := 0,
  211. all_connections := 0,
  212. transport := ranch_ssl,
  213. transport_options := #{num_acceptors := 3, socket_opts := Opts},
  214. protocol := echo_protocol,
  215. protocol_options := [{}]
  216. },
  217. {misc_info, tcp} := #{
  218. pid := Pid1,
  219. port := Port1,
  220. max_connections := 1024,
  221. active_connections := 2,
  222. all_connections := 5,
  223. transport := ranch_tcp,
  224. transport_options := #{num_acceptors := 1},
  225. protocol := remove_conn_and_wait_protocol,
  226. protocol_options := [{remove, false, 2500}] %% Option was modified.
  227. }
  228. } = ranch:info(),
  229. %% Get acceptors.
  230. [_] = ranch:procs({misc_info, tcp}, acceptors),
  231. [_, _] = ranch:procs({misc_info, act}, acceptors),
  232. [_, _, _] = ranch:procs({misc_info, ssl}, acceptors),
  233. %% Get connections.
  234. [_, _, _, _, _] = ranch:procs({misc_info, tcp}, connections),
  235. [] = ranch:procs({misc_info, act}, connections),
  236. [] = ranch:procs({misc_info, ssl}, connections),
  237. ok.
  238. misc_info_embedded(_) ->
  239. doc("Information about listeners in embedded mode."),
  240. {ok, SupPid} = embedded_sup:start_link(),
  241. %% Open a listener with a few connections.
  242. {ok, EmbeddedSupPid1} = embedded_sup:start_listener(SupPid, {misc_info_embedded, tcp},
  243. ranch_tcp, #{num_acceptors => 1},
  244. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  245. {_, Pid1, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, tcp}}, 1,
  246. supervisor:which_children(EmbeddedSupPid1)),
  247. Port1 = ranch:get_port({misc_info_embedded, tcp}),
  248. %% Open a few more listeners with different arguments.
  249. {ok, EmbeddedSupPid2} = embedded_sup:start_listener(SupPid, {misc_info_embedded, act},
  250. ranch_tcp, #{num_acceptors => 2},
  251. active_echo_protocol, {}),
  252. {_, Pid2, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, act}}, 1,
  253. supervisor:which_children(EmbeddedSupPid2)),
  254. Port2 = ranch:get_port({misc_info_embedded, act}),
  255. ranch:set_max_connections({misc_info_embedded, act}, infinity),
  256. Opts = ct_helper:get_certs_from_ets(),
  257. {ok, EmbeddedSupPid3} = embedded_sup:start_listener(SupPid, {misc_info_embedded, ssl},
  258. ranch_ssl, #{num_acceptors => 3, socket_opts => Opts},
  259. echo_protocol, [{}]),
  260. {_, Pid3, _, _} = lists:keyfind({ranch_listener_sup, {misc_info_embedded, ssl}}, 1,
  261. supervisor:which_children(EmbeddedSupPid3)),
  262. Port3 = ranch:get_port({misc_info_embedded, ssl}),
  263. %% Open 5 connections, 3 removed from the count.
  264. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  265. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  266. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  267. receive after 250 -> ok end,
  268. ranch:set_protocol_options({misc_info_embedded, tcp}, [{remove, false, 2500}]),
  269. receive after 250 -> ok end,
  270. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  271. {ok, _} = gen_tcp:connect("localhost", Port1, [binary, {active, false}, {packet, raw}]),
  272. receive after 250 -> ok end,
  273. %% Confirm the info returned by Ranch is correct.
  274. #{
  275. {misc_info_embedded, act} := #{
  276. pid := Pid2,
  277. port := Port2,
  278. max_connections := infinity, %% Option was modified.
  279. active_connections := 0,
  280. all_connections := 0,
  281. transport := ranch_tcp,
  282. transport_options := #{num_acceptors := 2},
  283. protocol := active_echo_protocol,
  284. protocol_options := {}
  285. },
  286. {misc_info_embedded, ssl} := #{
  287. pid := Pid3,
  288. port := Port3,
  289. max_connections := 1024,
  290. active_connections := 0,
  291. all_connections := 0,
  292. transport := ranch_ssl,
  293. transport_options := #{num_acceptors := 3, socket_opts := Opts},
  294. protocol := echo_protocol,
  295. protocol_options := [{}]
  296. },
  297. {misc_info_embedded, tcp} := #{
  298. pid := Pid1,
  299. port := Port1,
  300. max_connections := 1024,
  301. active_connections := 2,
  302. all_connections := 5,
  303. transport := ranch_tcp,
  304. transport_options := #{num_acceptors := 1},
  305. protocol := remove_conn_and_wait_protocol,
  306. protocol_options := [{remove, false, 2500}] %% Option was modified.
  307. }
  308. } = ranch:info(),
  309. %% Get acceptors.
  310. [_] = ranch:procs({misc_info_embedded, tcp}, acceptors),
  311. [_, _] = ranch:procs({misc_info_embedded, act}, acceptors),
  312. [_, _, _] = ranch:procs({misc_info_embedded, ssl}, acceptors),
  313. %% Get connections.
  314. [_, _, _, _, _] = ranch:procs({misc_info_embedded, tcp}, connections),
  315. [] = ranch:procs({misc_info_embedded, act}, connections),
  316. [] = ranch:procs({misc_info_embedded, ssl}, connections),
  317. %% Stop embedded tcp listener and ensure it is gone.
  318. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, tcp}),
  319. timer:sleep(500),
  320. false = maps:is_key({misc_info_embedded, tcp}, ranch:info()),
  321. %% Stop embedded act listener and ensure it is gone.
  322. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, act}),
  323. timer:sleep(500),
  324. false = maps:is_key({misc_info_embedded, act}, ranch:info()),
  325. %% Stop embedded ssl listener and ensure it is gone.
  326. ok = embedded_sup:stop_listener(SupPid, {misc_info_embedded, ssl}),
  327. timer:sleep(500),
  328. false = maps:is_key({misc_info_embedded, ssl}, ranch:info()),
  329. %% Stop embedded supervisor.
  330. embedded_sup:stop(SupPid),
  331. ok.
  332. misc_metrics(_) ->
  333. doc("Confirm accept/terminate metrics are correct."),
  334. Name = name(),
  335. {ok, _} = ranch:start_listener(Name, ranch_tcp, #{},
  336. notify_and_wait_protocol, #{pid => self()}),
  337. Port = ranch:get_port(Name),
  338. %% Start 10 connections.
  339. ok = connect_loop(Port, 10, 0),
  340. {10, ConnPids1} = receive_loop(connected, 400),
  341. #{metrics := Metrics1} = ranch:info(Name),
  342. {10, 0} = do_accumulate_metrics(Metrics1),
  343. %% Start 10 more connections.
  344. ok = connect_loop(Port, 10, 0),
  345. {10, ConnPids2} = receive_loop(connected, 400),
  346. #{metrics := Metrics2} = ranch:info(Name),
  347. {20, 0} = do_accumulate_metrics(Metrics2),
  348. %% Terminate 10 connections.
  349. ok = terminate_loop(stop, ConnPids2),
  350. timer:sleep(100),
  351. #{metrics := Metrics3} = ranch:info(Name),
  352. {20, 10} = do_accumulate_metrics(Metrics3),
  353. %% Terminate 10 more connections.
  354. ok = terminate_loop(stop, ConnPids1),
  355. timer:sleep(100),
  356. #{metrics := Metrics4} = ranch:info(Name),
  357. {20, 20} = do_accumulate_metrics(Metrics4),
  358. ok = ranch:stop_listener(Name),
  359. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  360. ok.
  361. do_accumulate_metrics(Metrics) ->
  362. maps:fold(
  363. fun
  364. ({conns_sup, _, accept}, N, {Accepts, Terminates}) ->
  365. {Accepts+N, Terminates};
  366. ({conns_sup, _, terminate}, N, {Accepts, Terminates}) ->
  367. {Accepts, Terminates+N}
  368. end,
  369. {0, 0},
  370. Metrics
  371. ).
  372. misc_opts_logger(_) ->
  373. doc("Confirm that messages are sent via the configured logger module."),
  374. register(misc_opts_logger, self()),
  375. {ok, _} = ranch:start_listener(name(),
  376. ranch_tcp, #{logger => ?MODULE, socket_opts => [<<"garbage">>]},
  377. echo_protocol, []),
  378. receive
  379. {warning, "Transport option " ++ _, [<<"garbage">>]} ->
  380. ok
  381. after 1000 ->
  382. error(timeout)
  383. end.
  384. warning(Format, Args) ->
  385. misc_opts_logger ! {warning, Format, Args}.
  386. misc_post_listen_callback(_) ->
  387. doc("Ensure that the post-listen callback works."),
  388. Name = name(),
  389. Self = self(),
  390. Ref = make_ref(),
  391. PostListenCb = fun (LSock) ->
  392. ok = ranch_tcp:setopts(LSock, [{send_timeout, 1000}]),
  393. Self ! {post_listen, Ref, LSock},
  394. ok
  395. end,
  396. {ok, _} = ranch:start_listener(Name,
  397. ranch_tcp, #{post_listen_callback => PostListenCb,
  398. socket_opts => [{send_timeout, infinity}]},
  399. echo_protocol, []),
  400. receive
  401. {post_listen, Ref, LSock} ->
  402. {ok, [{send_timeout, 1000}]} = ranch_tcp:getopts(LSock, [send_timeout]),
  403. ok
  404. after 1000 ->
  405. error(timeout)
  406. end,
  407. Port = ranch:get_port(Name),
  408. {ok, S} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  409. ok = gen_tcp:send(S, <<"Test">>),
  410. {ok, <<"Test">>} = gen_tcp:recv(S, 4, 1000),
  411. ok = ranch:stop_listener(Name),
  412. {error, closed} = gen_tcp:recv(S, 0, 1000),
  413. %% Make sure the listener stopped.
  414. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  415. ok.
  416. misc_post_listen_callback_error(_) ->
  417. doc("Ensure that starting a listener fails when the post-listen callback returns an error."),
  418. Name = name(),
  419. PostListenCb = fun (_) -> {error, test} end,
  420. {error, _} = ranch:start_listener(Name,
  421. ranch_tcp, #{post_listen_callback => PostListenCb},
  422. echo_protocol, []),
  423. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  424. ok.
  425. misc_repeated_remove(_) ->
  426. doc("Ensure repeated removal of connection does not crash the connection supervisor."),
  427. Name = name(),
  428. {ok, _} = ranch:start_listener(Name,
  429. ranch_tcp, #{},
  430. remove_conn_and_wait_protocol, [{remove, 5, 0}]),
  431. Port = ranch:get_port(Name),
  432. ConnsSups = lists:sort(ranch_server:get_connections_sups(Name)),
  433. {ok, _} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  434. timer:sleep(1000),
  435. ConnsSups = lists:sort(ranch_server:get_connections_sups(Name)),
  436. true = lists:all(fun ({_, ConnsSup}) -> erlang:is_process_alive(ConnsSup) end, ConnsSups),
  437. ok = ranch:stop_listener(Name).
  438. misc_set_transport_options(_) ->
  439. doc(""),
  440. Name = name(),
  441. {ok, ListenerSupPid} = ranch:start_listener(Name, ranch_tcp, #{max_connections => 10,
  442. handshake_timeout => 5000, shutdown => 1000, num_acceptors => 1,
  443. socket_opts => [{send_timeout, 5000}]}, echo_protocol, []),
  444. ok = ranch:set_transport_options(Name, #{max_connections => 20, handshake_timeout => 5001,
  445. num_acceptors => 2, shutdown => 1001, socket_opts => [{send_timeout, 5002}]}),
  446. ConnsSups = [ConnsSup || {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  447. _ = [begin
  448. {State, _, _, _} = sys:get_state(ConnsSup),
  449. 20 = element(11, State),
  450. 5001 = element(10, State),
  451. 1001 = element(6, State)
  452. end || ConnsSup <- ConnsSups],
  453. ok = ranch:suspend_listener(Name),
  454. ok = ranch:resume_listener(Name),
  455. 2 = length(ranch:procs(Name, acceptors)),
  456. LSocket = do_get_listener_socket(ListenerSupPid),
  457. {ok, [{send_timeout, 5002}]} = ranch_tcp:getopts(LSocket, [send_timeout]),
  458. ok = ranch:stop_listener(Name).
  459. misc_wait_for_connections(_) ->
  460. doc("Ensure wait for connections works."),
  461. Name = name(),
  462. Self = self(),
  463. %% Ensure invalid arguments are rejected.
  464. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, 'foo', 0) end,
  465. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '==', -1) end,
  466. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '==', 0, -1) end,
  467. {'EXIT', {badarg, _}} = begin catch ranch:wait_for_connections(Name, '<', 0) end,
  468. %% Create waiters for increasing number of connections.
  469. Pid1GT = do_create_waiter(Self, Name, '>', 0),
  470. Pid1GE = do_create_waiter(Self, Name, '>=', 1),
  471. Pid1EQ = do_create_waiter(Self, Name, '==', 1),
  472. Pid2GT = do_create_waiter(Self, Name, '>', 1),
  473. Pid2GE = do_create_waiter(Self, Name, '>=', 2),
  474. Pid2EQ = do_create_waiter(Self, Name, '==', 2),
  475. {ok, _} = ranch:start_listener(Name,
  476. ranch_tcp, #{num_acceptors => 1},
  477. echo_protocol, []),
  478. Port = ranch:get_port(Name),
  479. %% Create some connections, ensure that waiters respond.
  480. {ok, Sock1} = gen_tcp:connect("localhost", Port, []),
  481. ok = do_expect_waiter(Pid1GT),
  482. ok = do_expect_waiter(Pid1GE),
  483. ok = do_expect_waiter(Pid1EQ),
  484. ok = do_expect_waiter(undefined),
  485. {ok, Sock2} = gen_tcp:connect("localhost", Port, []),
  486. ok = do_expect_waiter(Pid2GT),
  487. ok = do_expect_waiter(Pid2GE),
  488. ok = do_expect_waiter(Pid2EQ),
  489. ok = do_expect_waiter(undefined),
  490. %% Create waiters for decreasing number of connections.
  491. Pid3LT = do_create_waiter(Self, Name, '<', 2),
  492. Pid3LE = do_create_waiter(Self, Name, '=<', 1),
  493. Pid3EQ = do_create_waiter(Self, Name, '==', 1),
  494. Pid4LT = do_create_waiter(Self, Name, '<', 1),
  495. Pid4LE = do_create_waiter(Self, Name, '=<', 0),
  496. Pid4EQ = do_create_waiter(Self, Name, '==', 0),
  497. %% Close connections, ensure that waiters respond.
  498. ok = gen_tcp:close(Sock1),
  499. ok = do_expect_waiter(Pid3LT),
  500. ok = do_expect_waiter(Pid3LE),
  501. ok = do_expect_waiter(Pid3EQ),
  502. ok = do_expect_waiter(undefined),
  503. ok = gen_tcp:close(Sock2),
  504. ok = do_expect_waiter(Pid4LT),
  505. ok = do_expect_waiter(Pid4LE),
  506. ok = do_expect_waiter(Pid4EQ),
  507. ok = do_expect_waiter(undefined),
  508. ok = ranch:stop_listener(Name),
  509. %% Make sure the listener stopped.
  510. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  511. ok.
  512. do_create_waiter(ReplyTo, Ref, Op, NumConns) ->
  513. spawn(fun () -> ok = ranch:wait_for_connections(Ref, Op, NumConns, 100),
  514. ReplyTo ! {wait_connections, self()} end).
  515. do_expect_waiter(WaiterPid) ->
  516. receive
  517. {wait_connections, _} when WaiterPid=:=undefined ->
  518. error;
  519. {wait_connections, Pid} when Pid=:=WaiterPid ->
  520. ok
  521. after 1000 ->
  522. case WaiterPid of
  523. undefined ->
  524. ok;
  525. _ ->
  526. timeout
  527. end
  528. end.
  529. misc_multiple_ip_local_socket_opts(_) ->
  530. case do_os_supports_local_sockets() of
  531. true ->
  532. do_misc_multiple_ip_local_socket_opts();
  533. false ->
  534. {skip, "No local socket support."}
  535. end.
  536. do_misc_multiple_ip_local_socket_opts() ->
  537. doc("Ensure that a listener uses the expected ip option if multiple are given."),
  538. Name = name(),
  539. SockFile1 = do_tempname(),
  540. SockFile2 = do_tempname(),
  541. Opts = [{ip, {local, SockFile1}}, {ip, {local, SockFile2}}],
  542. {ok, _} = ranch:start_listener(Name, ranch_tcp, #{socket_opts => Opts}, echo_protocol, []),
  543. {local, SockFile2} = ranch:get_addr(Name),
  544. %% Make sure the socket file from the ignored ip option
  545. %% has not been created.
  546. {error, enoent} = file:read_file_info(SockFile1),
  547. ok = ranch:stop_listener(Name),
  548. %% Make sure the socket file from the accepted ip option
  549. %% is removed.
  550. {error, enoent} = file:read_file_info(SockFile2),
  551. ok.
  552. %% ssl.
  553. ssl_accept_error(_) ->
  554. doc("Acceptor must not crash if client disconnects in the middle of SSL handshake."),
  555. Name = name(),
  556. Opts = ct_helper:get_certs_from_ets(),
  557. {ok, ListenerSup} = ranch:start_listener(Name,
  558. ranch_ssl, #{num_acceptors => 1, socket_opts => Opts},
  559. echo_protocol, []),
  560. Port = ranch:get_port(Name),
  561. ListenerSupChildren = supervisor:which_children(ListenerSup),
  562. {_, AcceptorsSup, _, _} = lists:keyfind(ranch_acceptors_sup, 1, ListenerSupChildren),
  563. [{{acceptor, _, _}, AcceptorPid, _, _}] = supervisor:which_children(AcceptorsSup),
  564. true = is_process_alive(AcceptorPid),
  565. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  566. ok = gen_tcp:close(Socket),
  567. receive after 500 -> ok end,
  568. true = is_process_alive(AcceptorPid),
  569. ok = ranch:stop_listener(Name).
  570. ssl_10_acceptors_10_listen_sockets(_) ->
  571. case do_os_supports_reuseport() of
  572. true ->
  573. ok = do_ssl_10_acceptors_10_listen_sockets();
  574. false ->
  575. {skip, "No SO_REUSEPORT support."}
  576. end.
  577. do_ssl_10_acceptors_10_listen_sockets() ->
  578. doc("Ensure that we can use 10 listen sockets across 10 acceptors with SSL."),
  579. Name = name(),
  580. Opts = ct_helper:get_certs_from_ets(),
  581. {ok, ListenerSupPid} = ranch:start_listener(Name,
  582. ranch_ssl, #{
  583. num_acceptors => 10,
  584. num_listen_sockets => 10,
  585. socket_opts => [{raw, 1, 15, <<1:32/native>>}|Opts]},
  586. echo_protocol, []),
  587. 10 = length(do_get_listener_sockets(ListenerSupPid)),
  588. ok = ranch:stop_listener(Name),
  589. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  590. ok.
  591. ssl_many_listen_sockets_no_reuseport(_) ->
  592. case do_os_supports_reuseport() of
  593. true ->
  594. ok = do_ssl_many_listen_sockets_no_reuseport();
  595. false ->
  596. {skip, "No SO_REUSEPORT support."}
  597. end.
  598. do_ssl_many_listen_sockets_no_reuseport() ->
  599. doc("Confirm that ranch:start_listener/5 fails when SO_REUSEPORT is not available with SSL."),
  600. Name = name(),
  601. Opts = ct_helper:get_certs_from_ets(),
  602. {error, eaddrinuse} = ranch:start_listener(Name,
  603. ranch_ssl, #{
  604. num_acceptors => 10,
  605. num_listen_sockets => 10,
  606. socket_opts => [{raw, 1, 15, <<0:32/native>>}|Opts]},
  607. echo_protocol, []),
  608. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  609. ok.
  610. ssl_active_echo(_) ->
  611. doc("Ensure that active mode works with SSL transport."),
  612. Name = name(),
  613. Opts = ct_helper:get_certs_from_ets(),
  614. {ok, _} = ranch:start_listener(Name,
  615. ranch_ssl, Opts,
  616. active_echo_protocol, []),
  617. Port = ranch:get_port(Name),
  618. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  619. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  620. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  621. ok = ranch:stop_listener(Name),
  622. {error, closed} = ssl:recv(Socket, 0, 1000),
  623. %% Make sure the listener stopped.
  624. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  625. ok.
  626. ssl_active_n_echo(_) ->
  627. case do_get_ssl_version() >= {9, 2, 0} of
  628. true ->
  629. do_ssl_active_n_echo();
  630. false ->
  631. {skip, "No Active N support."}
  632. end.
  633. do_ssl_active_n_echo() ->
  634. doc("Ensure that active N mode works with SSL transport."),
  635. Name = name(),
  636. Opts = ct_helper:get_certs_from_ets(),
  637. {ok, _} = ranch:start_listener(Name,
  638. ranch_ssl, Opts,
  639. batch_echo_protocol, [{batch_size, 3}]),
  640. Port = ranch:get_port(Name),
  641. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  642. ok = ssl:send(Socket, <<"One">>),
  643. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  644. ok = ssl:send(Socket, <<"Two">>),
  645. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  646. ok = ssl:send(Socket, <<"Three">>),
  647. {ok, <<"OK">>} = ssl:recv(Socket, 2, 1000),
  648. {ok, <<"OneTwoThree">>} = ssl:recv(Socket, 11, 1000),
  649. ok = ranch:stop_listener(Name),
  650. {error, closed} = ssl:recv(Socket, 0, 1000),
  651. %% Make sure the listener stopped.
  652. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  653. ok.
  654. ssl_echo(_) ->
  655. doc("Ensure that passive mode works with SSL transport."),
  656. Name = name(),
  657. Opts = ct_helper:get_certs_from_ets(),
  658. {ok, _} = ranch:start_listener(Name,
  659. ranch_ssl, Opts,
  660. echo_protocol, []),
  661. Port = ranch:get_port(Name),
  662. {ok, Socket} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  663. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  664. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  665. ok = ranch:stop_listener(Name),
  666. {error, closed} = ssl:recv(Socket, 0, 1000),
  667. %% Make sure the listener stopped.
  668. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  669. ok.
  670. ssl_handshake(_) ->
  671. doc("Ensure that multiple steps handshake works with SSL transport."),
  672. Name = name(),
  673. {CaCert1, Cert1, Key1} = ct_helper:make_certs(),
  674. {CaCert2, Cert2, Key2} = ct_helper:make_certs(),
  675. Opts1 = [{cert, Cert1}, {key, Key1}, {cacerts, [CaCert1]}, {verify, verify_peer}],
  676. Opts2 = [{cert, Cert2}, {key, Key2}, {cacerts, [CaCert2]}, {verify, verify_peer}],
  677. DefaultOpts = ct_helper:get_certs_from_ets(),
  678. {ok, _} = ranch:start_listener(Name,
  679. ranch_ssl, [{handshake, hello}|DefaultOpts],
  680. handshake_protocol, #{"ranch1" => Opts1, "ranch2" => Opts2}),
  681. Port = ranch:get_port(Name),
  682. {ok, Socket1} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw},
  683. {server_name_indication, "ranch1"}], 5000),
  684. {ok, Cert1} = ssl:peercert(Socket1),
  685. ok = ssl:send(Socket1, <<"SSL Ranch is working!">>),
  686. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket1, 21, 1000),
  687. {ok, Socket2} = ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw},
  688. {server_name_indication, "ranch2"}], 5000),
  689. {ok, Cert2} = ssl:peercert(Socket2),
  690. ok = ssl:send(Socket2, <<"SSL Ranch is working!">>),
  691. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket2, 21, 1000),
  692. ok = ranch:stop_listener(Name),
  693. {error, closed} = ssl:recv(Socket1, 0, 1000),
  694. {error, closed} = ssl:recv(Socket2, 0, 1000),
  695. %% Make sure the listener stopped.
  696. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  697. ok.
  698. ssl_local_echo(_) ->
  699. case do_os_supports_local_sockets() of
  700. true ->
  701. do_ssl_local_echo();
  702. false ->
  703. {skip, "No local socket support."}
  704. end.
  705. do_ssl_local_echo() ->
  706. doc("Ensure that listening on a local socket works with SSL transport."),
  707. SockFile = do_tempname(),
  708. try
  709. Name = name(),
  710. Opts = ct_helper:get_certs_from_ets(),
  711. {ok, _} = ranch:start_listener(Name,
  712. ranch_ssl, #{socket_opts => [{ip, {local, SockFile}}|Opts]},
  713. echo_protocol, []),
  714. undefined = ranch:get_port(Name),
  715. {ok, Socket} = ssl:connect({local, SockFile}, 0, [binary, {active, false}, {packet, raw}]),
  716. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  717. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  718. ok = ranch:stop_listener(Name),
  719. {error, closed} = ssl:recv(Socket, 0, 1000),
  720. %% Make sure the listener stopped.
  721. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  722. %% Make sure the socket file is removed.
  723. {error, enoent} = file:read_file_info(SockFile),
  724. ok
  725. after
  726. file:delete(SockFile)
  727. end.
  728. ssl_sni_echo(_) ->
  729. doc("Ensure that SNI works with SSL transport."),
  730. Name = name(),
  731. Opts = ct_helper:get_certs_from_ets(),
  732. {ok, _} = ranch:start_listener(Name,
  733. ranch_ssl, [{sni_hosts, [{"localhost", Opts}]}],
  734. echo_protocol, []),
  735. Port = ranch:get_port(Name),
  736. %% We stick to TLS 1.2 because there seems to be a bug in OTP-23.0rc2
  737. %% that leads to a malformed_handshake_data error.
  738. {ok, Socket} = ssl:connect("localhost", Port,
  739. [binary, {active, false}, {packet, raw}, {versions, ['tlsv1.2']}]),
  740. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  741. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  742. ok = ranch:stop_listener(Name),
  743. {error, closed} = ssl:recv(Socket, 0, 1000),
  744. %% Make sure the listener stopped.
  745. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  746. ok.
  747. ssl_sni_fail(_) ->
  748. doc("Ensure that connection fails when host is not in SNI list."),
  749. Name = name(),
  750. Opts = ct_helper:get_certs_from_ets(),
  751. {ok, _} = ranch:start_listener(Name,
  752. ranch_ssl, [{sni_hosts, [{"pouet", Opts}]}],
  753. echo_protocol, []),
  754. Port = ranch:get_port(Name),
  755. %% We stick to TLS 1.2 because there seems to be a bug in OTP-23.0rc2
  756. %% that leads to a malformed_handshake_data error.
  757. {error, _} = ssl:connect("localhost", Port,
  758. [binary, {active, false}, {packet, raw}, {versions, ['tlsv1.2']}]),
  759. ok = ranch:stop_listener(Name),
  760. %% Make sure the listener stopped.
  761. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  762. ok.
  763. ssl_tls_psk(_) ->
  764. doc("Ensure that TLS-PSK works without certificate."),
  765. Name = name(),
  766. Ciphers = [#{cipher => aes_256_gcm, key_exchange => psk, mac => aead, prf => sha384}],
  767. LookupFun = {fun psk_lookup_helper/3, <<"shared_secret">>},
  768. {ok, _} = ranch:start_listener(Name,
  769. ranch_ssl, [{ciphers, Ciphers}, {user_lookup_fun, LookupFun}, {versions, ['tlsv1.2']}],
  770. echo_protocol, []),
  771. Port = ranch:get_port(Name),
  772. {ok, Socket} = ssl:connect("localhost", Port, [
  773. binary, {active, false}, {ciphers, Ciphers},
  774. {user_lookup_fun, LookupFun}, {versions, ['tlsv1.2']}
  775. ]),
  776. ok = ssl:send(Socket, <<"SSL Ranch is working!">>),
  777. {ok, <<"SSL Ranch is working!">>} = ssl:recv(Socket, 21, 1000),
  778. ok = ranch:stop_listener(Name),
  779. {error, closed} = ssl:recv(Socket, 0, 1000),
  780. %% Make sure the listener stopped.
  781. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  782. ok.
  783. ssl_tls_psk_fail(_) ->
  784. doc("Ensure that TLS-PSK filed for different shared keys."),
  785. Name = name(),
  786. Ciphers = [#{cipher => aes_256_gcm, key_exchange => psk, mac => aead, prf => sha384}],
  787. ServerLookupFun = {fun psk_lookup_helper/3, <<"server_secret">>},
  788. ClientLookupFun = {fun psk_lookup_helper/3, <<"client_secret">>},
  789. {ok, _} = ranch:start_listener(Name,
  790. ranch_ssl, [{ciphers, Ciphers}, {user_lookup_fun, ServerLookupFun}, {versions, ['tlsv1.2']}],
  791. echo_protocol, []),
  792. Port = ranch:get_port(Name),
  793. {error, _} = ssl:connect("localhost", Port, [
  794. binary, {active, false}, {ciphers, Ciphers},
  795. {user_lookup_fun, ClientLookupFun}, {versions, ['tlsv1.2']}
  796. ]),
  797. ok = ranch:stop_listener(Name),
  798. %% Make sure the listener stopped.
  799. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  800. ok.
  801. psk_lookup_helper(psk, _PskIdentity, UserState) ->
  802. {ok, UserState}.
  803. ssl_upgrade_from_tcp(_) ->
  804. doc("Ensure a TCP socket can be upgraded to SSL"),
  805. Name = name(),
  806. {ok, _} = ranch:start_listener(Name,
  807. ranch_tcp, #{},
  808. ssl_upgrade_protocol, []),
  809. Port = ranch:get_port(Name),
  810. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  811. ok = gen_tcp:send(Socket, <<"ECHO Before upgrading to SSL">>),
  812. {ok, <<"Before upgrading to SSL">>} = gen_tcp:recv(Socket, 23, 1000),
  813. ok = gen_tcp:send(Socket, <<"UPGRADE">>),
  814. {ok, <<"READY">>} = gen_tcp:recv(Socket, 5, 1000),
  815. {ok, SslSocket} = ssl:connect(Socket, [{verify, verify_none}], 5000),
  816. ok = ssl:send(SslSocket, <<"ECHO After upgrading to SSL">>),
  817. {ok, <<"After upgrading to SSL">>} = ssl:recv(SslSocket, 22, 1000),
  818. ok = ranch:stop_listener(Name),
  819. {error, closed} = ssl:recv(SslSocket, 0, 1000),
  820. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  821. ok.
  822. ssl_graceful(_) ->
  823. doc("Ensure suspending and resuming of listeners does not kill active connections."),
  824. Name = name(),
  825. Opts = ct_helper:get_certs_from_ets(),
  826. {ok, _} = ranch:start_listener(Name,
  827. ranch_ssl, Opts,
  828. echo_protocol, []),
  829. Port = ranch:get_port(Name),
  830. %% Make sure connections with a fresh listener work.
  831. running = ranch:get_status(Name),
  832. {ok, Socket1} = ssl:connect("localhost", Port,
  833. [binary, {active, false}, {packet, raw}]),
  834. ok = ssl:send(Socket1, <<"SSL with fresh listener">>),
  835. {ok, <<"SSL with fresh listener">>} = ssl:recv(Socket1, 23, 1000),
  836. %% Suspend listener, make sure established connections keep running.
  837. ok = ranch:suspend_listener(Name),
  838. suspended = ranch:get_status(Name),
  839. ok = ssl:send(Socket1, <<"SSL with suspended listener">>),
  840. {ok, <<"SSL with suspended listener">>} = ssl:recv(Socket1, 27, 1000),
  841. %% Make sure new connections are refused on the suspended listener.
  842. {error, econnrefused} = ssl:connect("localhost", Port,
  843. [binary, {active, false}, {packet, raw}]),
  844. %% Make sure transport options can be changed when listener is suspended.
  845. ok = ranch:set_transport_options(Name, #{socket_opts => [{port, Port}|Opts]}),
  846. %% Resume listener, make sure connections can be established again.
  847. ok = ranch:resume_listener(Name),
  848. running = ranch:get_status(Name),
  849. {ok, Socket2} = ssl:connect("localhost", Port,
  850. [binary, {active, false}, {packet, raw}]),
  851. ok = ssl:send(Socket2, <<"SSL with resumed listener">>),
  852. {ok, <<"SSL with resumed listener">>} = ssl:recv(Socket2, 25, 1000),
  853. ok = ranch:stop_listener(Name),
  854. {error, closed} = ssl:recv(Socket1, 0, 1000),
  855. {error, closed} = ssl:recv(Socket2, 0, 1000),
  856. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  857. ok.
  858. ssl_getopts_capability(_) ->
  859. doc("Ensure getopts/2 capability."),
  860. Name=name(),
  861. Opts=ct_helper:get_certs_from_ets(),
  862. {ok, _} = ranch:start_listener(Name,
  863. ranch_ssl, Opts,
  864. transport_capabilities_protocol, []),
  865. Port=ranch:get_port(Name),
  866. {ok, Socket}=ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  867. ok=ssl:send(Socket, <<"getopts/2">>),
  868. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  869. ok=ranch:stop_listener(Name),
  870. {error, closed}=ssl:recv(Socket, 0, 1000),
  871. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  872. ok.
  873. ssl_getstat_capability(_) ->
  874. doc("Ensure getstat/1,2 capability."),
  875. Name=name(),
  876. Opts=ct_helper:get_certs_from_ets(),
  877. {ok, _} = ranch:start_listener(Name,
  878. ranch_ssl, Opts,
  879. transport_capabilities_protocol, []),
  880. Port=ranch:get_port(Name),
  881. {ok, Socket}=ssl:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  882. ok=ssl:send(Socket, <<"getstat/1">>),
  883. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  884. ok=ssl:send(Socket, <<"getstat/2">>),
  885. {ok, <<"OK">>}=ssl:recv(Socket, 0, 1000),
  886. ok=ranch:stop_listener(Name),
  887. {error, closed}=ssl:recv(Socket, 0, 1000),
  888. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  889. ok.
  890. ssl_error_eaddrinuse(_) ->
  891. doc("Ensure that failure due to an eaddrinuse returns a compact readable error."),
  892. Name = name(),
  893. Opts = ct_helper:get_certs_from_ets(),
  894. {ok, _} = ranch:start_listener(Name,
  895. ranch_ssl, Opts,
  896. active_echo_protocol, []),
  897. Port = ranch:get_port(Name),
  898. {error, eaddrinuse} = ranch:start_listener({Name, fails},
  899. ranch_ssl, [{port, Port}|Opts],
  900. active_echo_protocol, []),
  901. ok = ranch:stop_listener(Name),
  902. %% Make sure the listener stopped.
  903. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  904. ok.
  905. ssl_error_no_cert(_) ->
  906. doc("Ensure that failure due to missing certificate returns a compact readable error."),
  907. {error, no_cert} = ranch:start_listener(name(),
  908. ranch_ssl, #{},
  909. active_echo_protocol, []),
  910. ok.
  911. ssl_error_eacces(_) ->
  912. case os:type() of
  913. {win32, nt} ->
  914. {skip, "No privileged ports."};
  915. {unix, darwin} ->
  916. {skip, "No privileged ports."};
  917. _ ->
  918. doc("Ensure that failure due to an eacces returns a compact readable error."),
  919. Name = name(),
  920. Opts = ct_helper:get_certs_from_ets(),
  921. {error, eacces} = ranch:start_listener(Name,
  922. ranch_ssl, [{port, 283}|Opts],
  923. active_echo_protocol, []),
  924. ok
  925. end.
  926. ssl_unsupported_tlsv13_options(_) ->
  927. {available, Versions} = lists:keyfind(available, 1, ssl:versions()),
  928. case {lists:member('tlsv1.3', Versions), do_get_ssl_version() >= {10, 0, 0}} of
  929. {true, true} ->
  930. do_ssl_unsupported_tlsv13_options();
  931. {false, _} ->
  932. {skip, "No TLSv1.3 support."};
  933. {_, false} ->
  934. {skip, "No TLSv1.3 option dependency checking."}
  935. end.
  936. do_ssl_unsupported_tlsv13_options() ->
  937. doc("Ensure that a listener can be started when TLSv1.3 is "
  938. "the only protocol and unsupported options are present."),
  939. CheckOpts = [
  940. {beast_mitigation, one_n_minus_one},
  941. {client_renegotiation, true},
  942. {next_protocols_advertised, [<<"dummy">>]},
  943. {padding_check, true},
  944. {psk_identity, "dummy"},
  945. {secure_renegotiate, true},
  946. {reuse_session, fun (_, _, _, _) -> true end},
  947. {reuse_sessions, true},
  948. {user_lookup_fun, {fun (_, _, _) -> error end, <<"dummy">>}}
  949. ],
  950. Name = name(),
  951. Opts = ct_helper:get_certs_from_ets() ++ [{versions, ['tlsv1.3']}],
  952. ok = lists:foreach(
  953. fun (CheckOpt) ->
  954. Opts1 = Opts ++ [CheckOpt],
  955. {error, {options, dependency, _}} = ssl:listen(0, Opts1),
  956. {ok, _} = ranch:start_listener(Name,
  957. ranch_ssl, #{socket_opts => Opts1},
  958. echo_protocol, []),
  959. ok = ranch:stop_listener(Name)
  960. end,
  961. CheckOpts
  962. ),
  963. ok.
  964. %% tcp.
  965. tcp_10_acceptors_10_listen_sockets(Config) ->
  966. case do_os_supports_reuseport() of
  967. true ->
  968. ok = do_tcp_10_acceptors_10_listen_sockets(Config);
  969. false ->
  970. {skip, "No SO_REUSEPORT support."}
  971. end.
  972. do_tcp_10_acceptors_10_listen_sockets(Config) ->
  973. doc("Ensure that we can use 10 listen sockets across 10 acceptors with TCP."),
  974. Name = name(),
  975. SockOpts = config(socket_opts, Config),
  976. Self = self(),
  977. Tag = make_ref(),
  978. {ok, _} = ranch:start_listener(Name,
  979. ranch_tcp, #{
  980. num_acceptors => 10,
  981. num_listen_sockets => 10,
  982. socket_opts => SockOpts ++ [{raw, 1, 15, <<1:32/native>>}],
  983. post_listen_callback => fun (LSocket) -> Self ! {Tag, LSocket}, ok end},
  984. echo_protocol, []),
  985. LSockets = [receive {Tag, LSocket} -> LSocket after 1000 -> error(timeout) end
  986. || _ <- lists:seq(1, 10)],
  987. 10 = length(LSockets),
  988. 10 = length(lists:usort(LSockets)),
  989. ok = ranch:stop_listener(Name),
  990. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  991. ok.
  992. tcp_many_listen_sockets_no_reuseport(Config) ->
  993. case do_os_supports_reuseport() of
  994. true ->
  995. ok = do_tcp_many_listen_sockets_no_reuseport(Config);
  996. false ->
  997. {skip, "No SO_REUSEPORT support."}
  998. end.
  999. do_tcp_many_listen_sockets_no_reuseport(Config) ->
  1000. doc("Confirm that ranch:start_listener/5 fails when SO_REUSEPORT is not available with TCP."),
  1001. Name = name(),
  1002. SockOpts = config(socket_opts, Config),
  1003. {error, eaddrinuse} = ranch:start_listener(Name,
  1004. ranch_tcp, #{
  1005. num_acceptors => 10,
  1006. num_listen_sockets => 10,
  1007. socket_opts => SockOpts ++ [{raw, 1, 15, <<0:32/native>>}]},
  1008. echo_protocol, []),
  1009. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1010. ok.
  1011. tcp_active_echo(Config) ->
  1012. doc("Ensure that active mode works with TCP transport."),
  1013. Name = name(),
  1014. SockOpts = config(socket_opts, Config),
  1015. {ok, _} = ranch:start_listener(Name,
  1016. ranch_tcp, #{socket_opts => SockOpts},
  1017. active_echo_protocol, []),
  1018. Port = ranch:get_port(Name),
  1019. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1020. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1021. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1022. ok = ranch:stop_listener(Name),
  1023. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1024. %% Make sure the listener stopped.
  1025. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1026. ok.
  1027. tcp_active_n_echo(Config) ->
  1028. doc("Ensure that active N mode works with TCP transport."),
  1029. Name = name(),
  1030. SockOpts = config(socket_opts, Config),
  1031. {ok, _} = ranch:start_listener(Name,
  1032. ranch_tcp, #{socket_opts => SockOpts},
  1033. batch_echo_protocol, [{batch_size, 3}]),
  1034. Port = ranch:get_port(Name),
  1035. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1036. ok = gen_tcp:send(Socket, <<"One">>),
  1037. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  1038. ok = gen_tcp:send(Socket, <<"Two">>),
  1039. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  1040. ok = gen_tcp:send(Socket, <<"Three">>),
  1041. {ok, <<"OK">>} = gen_tcp:recv(Socket, 2, 1000),
  1042. {ok, <<"OneTwoThree">>} = gen_tcp:recv(Socket, 11, 1000),
  1043. ok = ranch:stop_listener(Name),
  1044. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1045. %% Make sure the listener stopped.
  1046. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1047. ok.
  1048. tcp_echo(Config) ->
  1049. doc("Ensure that passive mode works with TCP transport."),
  1050. Name = name(),
  1051. SockOpts = config(socket_opts, Config),
  1052. {ok, _} = ranch:start_listener(Name,
  1053. ranch_tcp, #{socket_opts => SockOpts},
  1054. echo_protocol, []),
  1055. Port = ranch:get_port(Name),
  1056. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1057. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1058. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1059. ok = ranch:stop_listener(Name),
  1060. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1061. %% Make sure the listener stopped.
  1062. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1063. ok.
  1064. tcp_local_echo(_) ->
  1065. case do_os_supports_local_sockets() of
  1066. true ->
  1067. do_tcp_local_echo();
  1068. false ->
  1069. {skip, "No local socket support."}
  1070. end.
  1071. do_tcp_local_echo() ->
  1072. doc("Ensure that listening on a local socket works with TCP transport."),
  1073. SockFile = do_tempname(),
  1074. try
  1075. Name = name(),
  1076. {ok, _} = ranch:start_listener(Name,
  1077. ranch_tcp, #{socket_opts => [{ip, {local, SockFile}}]},
  1078. echo_protocol, []),
  1079. undefined = ranch:get_port(Name),
  1080. {ok, Socket} = gen_tcp:connect({local, SockFile}, 0, [binary, {active, false}, {packet, raw}]),
  1081. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1082. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1083. ok = ranch:stop_listener(Name),
  1084. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1085. %% Make sure the listener stopped.
  1086. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1087. %% Make sure the socket file is removed.
  1088. {error, enoent} = file:read_file_info(SockFile),
  1089. ok
  1090. after
  1091. file:delete(SockFile)
  1092. end.
  1093. tcp_graceful(Config) ->
  1094. doc("Ensure suspending and resuming of listeners does not kill active connections."),
  1095. Name = name(),
  1096. SockOpts = config(socket_opts, Config),
  1097. {ok, _} = ranch:start_listener(Name,
  1098. ranch_tcp, #{socket_opts => SockOpts},
  1099. echo_protocol, []),
  1100. Port = ranch:get_port(Name),
  1101. %% Make sure connections with a fresh listener work.
  1102. running = ranch:get_status(Name),
  1103. {ok, Socket1} = gen_tcp:connect("localhost", Port,
  1104. [binary, {active, false}, {packet, raw}]),
  1105. ok = gen_tcp:send(Socket1, <<"TCP with fresh listener">>),
  1106. {ok, <<"TCP with fresh listener">>} = gen_tcp:recv(Socket1, 23, 1000),
  1107. %% Suspend listener, make sure established connections keep running.
  1108. ok = ranch:suspend_listener(Name),
  1109. suspended = ranch:get_status(Name),
  1110. ok = gen_tcp:send(Socket1, <<"TCP with suspended listener">>),
  1111. {ok, <<"TCP with suspended listener">>} = gen_tcp:recv(Socket1, 27, 1000),
  1112. %% Make sure new connections are refused on the suspended listener.
  1113. {error, econnrefused} = gen_tcp:connect("localhost", Port,
  1114. [binary, {active, false}, {packet, raw}]),
  1115. %% Make sure transport options can be changed when listener is suspended.
  1116. ok = ranch:set_transport_options(Name, [{port, Port}]),
  1117. %% Resume listener, make sure connections can be established again.
  1118. ok = ranch:resume_listener(Name),
  1119. running = ranch:get_status(Name),
  1120. {ok, Socket2} = gen_tcp:connect("localhost", Port,
  1121. [binary, {active, false}, {packet, raw}]),
  1122. ok = gen_tcp:send(Socket2, <<"TCP with resumed listener">>),
  1123. {ok, <<"TCP with resumed listener">>} = gen_tcp:recv(Socket2, 25, 1000),
  1124. ok = ranch:stop_listener(Name),
  1125. {error, closed} = gen_tcp:recv(Socket1, 0, 1000),
  1126. {error, closed} = gen_tcp:recv(Socket2, 0, 1000),
  1127. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1128. ok.
  1129. tcp_inherit_options(Config) ->
  1130. doc("Ensure TCP options are inherited in the protocol."),
  1131. Name = name(),
  1132. Opts0 = config(socket_opts, Config),
  1133. Opts1 = [{nodelay, false}, {send_timeout_close, false}],
  1134. {ok, _} = ranch:start_listener(Name,
  1135. ranch_tcp, #{socket_opts => Opts0 ++ Opts1},
  1136. check_tcp_options, [{pid, self()} | Opts1]),
  1137. Port = ranch:get_port(Name),
  1138. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, true}, {packet, raw}]),
  1139. receive checked -> ok after 1000 -> error(timeout) end,
  1140. ok = gen_tcp:close(Socket),
  1141. ok = ranch:stop_listener(Name).
  1142. tcp_max_connections(Config) ->
  1143. doc("Ensure the max_connections option actually limits connections."),
  1144. Name = name(),
  1145. SockOpts = config(socket_opts, Config),
  1146. {ok, _} = ranch:start_listener(Name,
  1147. ranch_tcp, #{max_connections => 10, num_acceptors => 1, socket_opts => SockOpts},
  1148. notify_and_wait_protocol, #{pid => self()}),
  1149. Port = ranch:get_port(Name),
  1150. ok = connect_loop(Port, 11, 150),
  1151. 10 = ranch_server:count_connections(Name),
  1152. {10, Pids1} = receive_loop(connected, 400),
  1153. ok = terminate_loop(stop, Pids1),
  1154. {1, Pids2} = receive_loop(connected, 1000),
  1155. ok = terminate_loop(stop, Pids2),
  1156. ok = ranch:stop_listener(Name).
  1157. tcp_max_connections_and_beyond(Config) ->
  1158. doc("Ensure the max_connections option works when connections are removed from the count."),
  1159. Name = name(),
  1160. SockOpts = config(socket_opts, Config),
  1161. {ok, _} = ranch:start_listener(Name,
  1162. ranch_tcp, #{max_connections => 10, num_acceptors => 1, socket_opts => SockOpts},
  1163. remove_conn_and_wait_protocol, [{remove, true, 2500}]),
  1164. Port = ranch:get_port(Name),
  1165. ok = connect_loop(Port, 10, 0),
  1166. receive after 250 -> ok end,
  1167. 0 = ranch_server:count_connections(Name),
  1168. 10 = length(do_conns_which_children(Name)),
  1169. Counts = do_conns_count_children(Name),
  1170. {_, 1} = lists:keyfind(specs, 1, Counts),
  1171. {_, 0} = lists:keyfind(supervisors, 1, Counts),
  1172. {_, 10} = lists:keyfind(active, 1, Counts),
  1173. {_, 10} = lists:keyfind(workers, 1, Counts),
  1174. ranch:set_protocol_options(Name, [{remove, false, 2500}]),
  1175. receive after 250 -> ok end,
  1176. ok = connect_loop(Port, 10, 0),
  1177. receive after 250 -> ok end,
  1178. 10 = ranch_server:count_connections(Name),
  1179. 20 = length(do_conns_which_children(Name)),
  1180. Counts2 = do_conns_count_children(Name),
  1181. {_, 20} = lists:keyfind(active, 1, Counts2),
  1182. {_, 20} = lists:keyfind(workers, 1, Counts2),
  1183. ok = ranch:stop_listener(Name).
  1184. tcp_max_connections_infinity(Config) ->
  1185. doc("Set the max_connections option from 10 to infinity and back to 10."),
  1186. Name = name(),
  1187. SockOpts = config(socket_opts, Config),
  1188. {ok, _} = ranch:start_listener(Name,
  1189. ranch_tcp, #{max_connections => 10, num_acceptors => 1, socket_opts => SockOpts},
  1190. notify_and_wait_protocol, #{pid => self()}),
  1191. Port = ranch:get_port(Name),
  1192. ok = connect_loop(Port, 20, 0),
  1193. 10 = ranch_server:count_connections(Name),
  1194. {10, Pids1} = receive_loop(connected, 1000),
  1195. 10 = ranch_server:count_connections(Name),
  1196. 10 = ranch:get_max_connections(Name),
  1197. ranch:set_max_connections(Name, infinity),
  1198. receive after 250 -> ok end,
  1199. 20 = ranch_server:count_connections(Name),
  1200. infinity = ranch:get_max_connections(Name),
  1201. ranch:set_max_connections(Name, 10),
  1202. 20 = ranch_server:count_connections(Name),
  1203. {10, Pids2} = receive_loop(connected, 1000),
  1204. ok = terminate_loop(stop, Pids1 ++ Pids2),
  1205. ok = ranch:stop_listener(Name).
  1206. tcp_remove_connections(Config) ->
  1207. doc("Ensure that removed connections are only removed once."),
  1208. Name = name(),
  1209. SockOpts = config(socket_opts, Config),
  1210. {ok, _} = ranch:start_listener(Name,
  1211. ranch_tcp, #{socket_opts => SockOpts},
  1212. remove_conn_and_wait_protocol, [{remove, true, 0}]),
  1213. Port = ranch:get_port(Name),
  1214. ok = connect_loop(Port, 10, 0),
  1215. receive after 250 -> ok end,
  1216. 0 = ranch_server:count_connections(Name),
  1217. ok = ranch:stop_listener(Name).
  1218. tcp_remove_connections_acceptor_wakeup(Config) ->
  1219. doc("Ensure that removed connections wake up acceptors."),
  1220. Name = name(),
  1221. SockOpts = config(socket_opts, Config),
  1222. {ok, _} = ranch:start_listener(Name,
  1223. ranch_tcp, #{max_connections => 1, num_acceptors => 1, socket_opts => SockOpts},
  1224. remove_conn_and_wait_protocol, [{remove, true, infinity}]),
  1225. Port = ranch:get_port(Name),
  1226. ConnectOptions = [binary, {active, false}],
  1227. Localhost = "localhost",
  1228. {ok, Socket1} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  1229. {ok, Socket2} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  1230. {ok, Socket3} = gen_tcp:connect(Localhost, Port, ConnectOptions),
  1231. ok = gen_tcp:send(Socket3, <<"bye">>),
  1232. true = maps:get(all_connections, ranch:info(Name)) >= 2,
  1233. ok = gen_tcp:send(Socket1, <<"bye">>),
  1234. ok = gen_tcp:send(Socket2, <<"bye">>),
  1235. ok = ranch:stop_listener(Name).
  1236. tcp_set_max_connections(Config) ->
  1237. doc("Ensure that changing the max_connections option to a larger value allows for more connections."),
  1238. Name = name(),
  1239. SockOpts = config(socket_opts, Config),
  1240. {ok, _} = ranch:start_listener(Name,
  1241. ranch_tcp, #{max_connections => 10, num_acceptors => 1, socket_opts => SockOpts},
  1242. notify_and_wait_protocol, #{pid => self()}),
  1243. Port = ranch:get_port(Name),
  1244. ok = connect_loop(Port, 20, 0),
  1245. 10 = ranch_server:count_connections(Name),
  1246. {10, Pids1} = receive_loop(connected, 1000),
  1247. 10 = ranch:get_max_connections(Name),
  1248. ranch:set_max_connections(Name, 20),
  1249. {10, Pids2} = receive_loop(connected, 1000),
  1250. 20 = ranch:get_max_connections(Name),
  1251. ok = terminate_loop(stop, Pids1 ++ Pids2),
  1252. ok = ranch:stop_listener(Name).
  1253. tcp_set_max_connections_clean(Config) ->
  1254. doc("Ensure that setting max_connections does not crash any process."),
  1255. Name = name(),
  1256. SockOpts = config(socket_opts, Config),
  1257. {ok, ListSupPid} = ranch:start_listener(Name,
  1258. ranch_tcp, #{max_connections => 4, socket_opts => SockOpts},
  1259. notify_and_wait_protocol, #{pid => self()}),
  1260. Children = supervisor:which_children(ListSupPid),
  1261. {_, AccSupPid, _, _} = lists:keyfind(ranch_acceptors_sup, 1, Children),
  1262. 1 = erlang:trace(ListSupPid, true, [procs]),
  1263. 1 = erlang:trace(AccSupPid, true, [procs]),
  1264. Port = ranch:get_port(Name),
  1265. N = 20,
  1266. ok = connect_loop(Port, N*5, 0),
  1267. %% Randomly set max_connections.
  1268. [spawn(ranch, set_max_connections, [Name, Max]) ||
  1269. Max <- lists:flatten(lists:duplicate(N, [6, 4, 8, infinity]))],
  1270. receive
  1271. {trace, _, spawn, _, _} ->
  1272. error(dirty_set_max_connections)
  1273. after
  1274. 2000 -> ok
  1275. end,
  1276. _ = erlang:trace(all, false, [all]),
  1277. ok = clean_traces(),
  1278. ok = ranch:stop_listener(Name).
  1279. tcp_getopts_capability(Config) ->
  1280. doc("Ensure getopts/2 capability."),
  1281. Name=name(),
  1282. SockOpts = config(socket_opts, Config),
  1283. {ok, _}=ranch:start_listener(Name,
  1284. ranch_tcp, #{socket_opts => SockOpts},
  1285. transport_capabilities_protocol, []),
  1286. Port=ranch:get_port(Name),
  1287. {ok, Socket}=gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1288. ok=gen_tcp:send(Socket, <<"getopts/2">>),
  1289. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1290. ok=ranch:stop_listener(Name),
  1291. {error, closed}=gen_tcp:recv(Socket, 0, 1000),
  1292. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  1293. ok.
  1294. tcp_getstat_capability(Config) ->
  1295. doc("Ensure getstat/1,2 capability."),
  1296. Name=name(),
  1297. SockOpts = config(socket_opts, Config),
  1298. {ok, _}=ranch:start_listener(Name,
  1299. ranch_tcp, #{socket_opts => SockOpts},
  1300. transport_capabilities_protocol, []),
  1301. Port=ranch:get_port(Name),
  1302. {ok, Socket}=gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1303. ok=gen_tcp:send(Socket, <<"getstat/1">>),
  1304. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1305. ok=gen_tcp:send(Socket, <<"getstat/2">>),
  1306. {ok, <<"OK">>}=gen_tcp:recv(Socket, 0, 1000),
  1307. ok=ranch:stop_listener(Name),
  1308. {error, closed}=gen_tcp:recv(Socket, 0, 1000),
  1309. {'EXIT', _}=begin catch ranch:get_port(Name) end,
  1310. ok.
  1311. tcp_upgrade(Config) ->
  1312. doc("Ensure that protocol options can be updated."),
  1313. Name = name(),
  1314. SockOpts = config(socket_opts, Config),
  1315. {ok, _} = ranch:start_listener(Name,
  1316. ranch_tcp, #{socket_opts => SockOpts},
  1317. notify_and_wait_protocol, #{pid => self()}),
  1318. Port = ranch:get_port(Name),
  1319. ok = connect_loop(Port, 1, 0),
  1320. {1, Pids1} = receive_loop(connected, 1000),
  1321. ranch:set_protocol_options(Name, #{msg => upgraded, pid => self()}),
  1322. ok = connect_loop(Port, 1, 0),
  1323. {1, Pids2} = receive_loop(upgraded, 1000),
  1324. ok = terminate_loop(stop, Pids1 ++ Pids2),
  1325. ok = ranch:stop_listener(Name).
  1326. tcp_error_eaddrinuse(Config) ->
  1327. doc("Ensure that failure due to an eaddrinuse returns a compact readable error."),
  1328. Name = name(),
  1329. SockOpts = config(socket_opts, Config),
  1330. {ok, _} = ranch:start_listener(Name,
  1331. ranch_tcp, #{socket_opts => SockOpts},
  1332. active_echo_protocol, []),
  1333. Port = ranch:get_port(Name),
  1334. {error, eaddrinuse} = ranch:start_listener({Name, fails},
  1335. ranch_tcp, [{port, Port}],
  1336. active_echo_protocol, []),
  1337. ok = ranch:stop_listener(Name),
  1338. %% Make sure the listener stopped.
  1339. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1340. ok.
  1341. tcp_error_eacces(Config) ->
  1342. case os:type() of
  1343. {win32, nt} ->
  1344. {skip, "No privileged ports."};
  1345. {unix, darwin} ->
  1346. {skip, "No privileged ports."};
  1347. _ ->
  1348. doc("Ensure that failure due to an eacces returns a compact readable error."),
  1349. Name = name(),
  1350. SockOpts = config(socket_opts, Config),
  1351. {error, eacces} = ranch:start_listener(Name,
  1352. ranch_tcp, #{socket_opts => SockOpts ++ [{port, 283}]},
  1353. active_echo_protocol, []),
  1354. ok
  1355. end.
  1356. %% Supervisor tests
  1357. connection_type_supervisor(_) ->
  1358. doc("The supervisor connection type must be reflected in the specifications."),
  1359. Name = name(),
  1360. {ok, _} = ranch:start_listener(Name,
  1361. ranch_tcp, #{connection_type => supervisor},
  1362. echo_protocol, []),
  1363. Port = ranch:get_port(Name),
  1364. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1365. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1366. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1367. [{echo_protocol, _, supervisor, [echo_protocol]}] = do_conns_which_children(Name),
  1368. ok = ranch:stop_listener(Name),
  1369. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1370. %% Make sure the listener stopped.
  1371. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1372. ok.
  1373. connection_type_supervisor_separate_from_connection(_) ->
  1374. doc("The supervisor connection type allows separate supervised and connection processes."),
  1375. Name = name(),
  1376. {ok, _} = ranch:start_listener(Name,
  1377. ranch_tcp, #{connection_type => supervisor},
  1378. supervisor_separate, []),
  1379. Port = ranch:get_port(Name),
  1380. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1381. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1382. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1383. [{supervisor_separate, _, supervisor, [supervisor_separate]}] = do_conns_which_children(Name),
  1384. ok = ranch:stop_listener(Name),
  1385. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1386. %% Make sure the listener stopped.
  1387. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1388. ok.
  1389. supervisor_10_acceptors_1_conns_sup(_) ->
  1390. doc("Ensure that using 10 acceptors and 1 connection supervisor works."),
  1391. ok = do_supervisor_n_acceptors_m_conns_sups(10, 1).
  1392. supervisor_9_acceptors_4_conns_sups(_) ->
  1393. doc("Ensure that using 9 acceptors and 4 connection supervisors works."),
  1394. ok = do_supervisor_n_acceptors_m_conns_sups(9, 4).
  1395. supervisor_10_acceptors_10_conns_sups(_) ->
  1396. doc("Ensure that using 10 acceptors and 10 connection supervisors works."),
  1397. ok = do_supervisor_n_acceptors_m_conns_sups(10, 10).
  1398. supervisor_1_acceptor_10_conns_sups(_) ->
  1399. doc("Ensure that using 1 acceptor and 10 connection supervisors works."),
  1400. ok = do_supervisor_n_acceptors_m_conns_sups(1, 10).
  1401. do_supervisor_n_acceptors_m_conns_sups(NumAcceptors, NumConnsSups) ->
  1402. Name = name(),
  1403. {ok, Pid} = ranch:start_listener(Name,
  1404. ranch_tcp, #{num_conns_sups => NumConnsSups, num_acceptors => NumAcceptors},
  1405. notify_and_wait_protocol, #{pid => self()}),
  1406. Port = ranch:get_port(Name),
  1407. ConnsSups = [ConnsSup || {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  1408. NumConnsSups = length(ConnsSups),
  1409. {ranch_acceptors_sup, AcceptorsSup, supervisor, _} =
  1410. lists:keyfind(ranch_acceptors_sup, 1, supervisor:which_children(Pid)),
  1411. AcceptorIds = [AcceptorId ||
  1412. {{acceptor, _, AcceptorId}, _, worker, _} <- supervisor:which_children(AcceptorsSup)],
  1413. NumAcceptors = length(AcceptorIds),
  1414. AcceptorConnsSups0 = [ranch_server:get_connections_sup(Name, AcceptorId) ||
  1415. AcceptorId <- AcceptorIds],
  1416. AcceptorConnsSups1 = lists:usort(AcceptorConnsSups0),
  1417. if
  1418. NumAcceptors > NumConnsSups ->
  1419. NumConnsSups = length(AcceptorConnsSups1),
  1420. [] = ConnsSups -- AcceptorConnsSups1;
  1421. NumAcceptors < NumConnsSups ->
  1422. NumAcceptors = length(AcceptorConnsSups1),
  1423. [] = AcceptorConnsSups1 -- ConnsSups;
  1424. NumAcceptors =:= NumConnsSups ->
  1425. NumConnsSups = length(AcceptorConnsSups1),
  1426. NumAcceptors = length(AcceptorConnsSups1),
  1427. [] = ConnsSups -- AcceptorConnsSups1,
  1428. [] = AcceptorConnsSups1 -- ConnsSups
  1429. end,
  1430. ok = connect_loop(Port, 100, 0),
  1431. {100, Pids} = receive_loop(connected, 1000),
  1432. 100 = ranch_server:count_connections(Name),
  1433. ok = terminate_loop(stop, Pids),
  1434. ok = ranch:stop_listener(Name),
  1435. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1436. ok.
  1437. supervisor_changed_options_restart(_) ->
  1438. doc("Ensure that a listener is restarted with changed transport options."),
  1439. Name = name(),
  1440. %% Start a listener using send_timeout as option change marker.
  1441. {ok, ListenerSupPid1} = ranch:start_listener(Name,
  1442. ranch_tcp, [{send_timeout, 300000}],
  1443. echo_protocol, []),
  1444. %% Ensure send_timeout is really set to initial value.
  1445. {ok, [{send_timeout, 300000}]}
  1446. = inet:getopts(do_get_listener_socket(ListenerSupPid1), [send_timeout]),
  1447. %% Change send_timeout option.
  1448. ok = ranch:suspend_listener(Name),
  1449. ok = ranch:set_transport_options(Name, [{send_timeout, 300001}]),
  1450. ok = ranch:resume_listener(Name),
  1451. %% Ensure send_timeout is really set to the changed value.
  1452. {ok, [{send_timeout, 300001}]}
  1453. = inet:getopts(do_get_listener_socket(ListenerSupPid1), [send_timeout]),
  1454. %% Crash the listener_sup process, allow a short time for restart to succeed.
  1455. %% We silence the expected log events coming from the relevant supervisors.
  1456. ListenerChilds = [ChildPid || {_, ChildPid, _, _} <- supervisor:which_children(ListenerSupPid1)],
  1457. FilterFun = fun (#{meta := #{pid := EventPid}}, _) ->
  1458. case lists:member(EventPid, ListenerChilds) of
  1459. true -> stop;
  1460. false -> ignore
  1461. end
  1462. end,
  1463. ok = logger:add_primary_filter(?MODULE, {FilterFun, undefined}),
  1464. try
  1465. exit(ListenerSupPid1, kill),
  1466. timer:sleep(1000)
  1467. after
  1468. ok = logger:remove_primary_filter(?MODULE)
  1469. end,
  1470. %% Obtain pid of restarted listener_sup process.
  1471. [ListenerSupPid2] = [Pid || {{ranch_listener_sup, Ref}, Pid, supervisor, _}
  1472. <- supervisor:which_children(ranch_sup), Ref =:= Name],
  1473. %% Ensure send_timeout is still set to the changed value.
  1474. {ok, [{send_timeout, 300001}]}
  1475. = inet:getopts(do_get_listener_socket(ListenerSupPid2), [send_timeout]),
  1476. ok = ranch:stop_listener(Name),
  1477. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1478. ok.
  1479. supervisor_clean_child_restart(_) ->
  1480. doc("Verify that only the relevant parts of the supervision tree restarted "
  1481. "when the listening socket is closed."),
  1482. Name = name(),
  1483. %% Trace socket allocations.
  1484. {module, ranch_tcp} = code:ensure_loaded(ranch_tcp),
  1485. _ = erlang:trace(new, true, [call]),
  1486. 1 = erlang:trace_pattern({ranch_tcp, listen, 1},
  1487. [{'_', [], [{return_trace}]}], [global]),
  1488. {ok, Pid} = ranch:start_listener(Name,
  1489. ranch_tcp, #{num_acceptors => 1},
  1490. echo_protocol, []),
  1491. %% Trace supervisor spawns.
  1492. 1 = erlang:trace(Pid, true, [procs, set_on_spawn]),
  1493. ConnsSups = ranch_server:get_connections_sups(Name),
  1494. %% Manually shut the listening socket down.
  1495. LSocket = receive
  1496. {trace, _, return_from, {ranch_tcp, listen, 1}, {ok, Socket}} ->
  1497. Socket
  1498. after 0 ->
  1499. error(lsocket_unknown)
  1500. end,
  1501. ok = gen_tcp:close(LSocket),
  1502. receive after 1000 -> ok end,
  1503. %% Verify that supervisor and its first two children are alive.
  1504. true = is_process_alive(Pid),
  1505. true = lists:all(fun erlang:is_process_alive/1, [ConnsSup || {_, ConnsSup} <- ConnsSups]),
  1506. %% Check that acceptors_sup is restarted properly.
  1507. AccSupPid = receive {trace, Pid, spawn, Pid1, _} -> Pid1 end,
  1508. receive {trace, AccSupPid, spawn, _, _} -> ok end,
  1509. %% No more traces then.
  1510. receive
  1511. {trace, _, spawn, _, _} -> error(invalid_restart)
  1512. after 1000 -> ok end,
  1513. %% Verify that children still registered right.
  1514. ConnsSups = ranch_server:get_connections_sups(Name),
  1515. _ = erlang:trace_pattern({ranch_tcp, listen, 1}, false, []),
  1516. _ = erlang:trace(all, false, [all]),
  1517. ok = clean_traces(),
  1518. ok = ranch:stop_listener(Name).
  1519. supervisor_clean_restart(_) ->
  1520. doc("Verify that killing ranch_conns_sup does not crash everything "
  1521. "and that it restarts properly."),
  1522. Name = name(),
  1523. NumAcc = 4,
  1524. {ok, Pid} = ranch:start_listener(Name,
  1525. ranch_tcp, #{num_acceptors => NumAcc},
  1526. echo_protocol, []),
  1527. %% Trace supervisor spawns.
  1528. 1 = erlang:trace(Pid, true, [procs, set_on_spawn]),
  1529. {_, ConnsSupSup0, _, _} = lists:keyfind(ranch_conns_sup_sup, 1, supervisor:which_children(Pid)),
  1530. exit(ConnsSupSup0, kill),
  1531. receive after 1000 -> ok end,
  1532. %% Verify that supervisor is alive
  1533. true = is_process_alive(Pid),
  1534. %% ...but children are dead.
  1535. false = is_process_alive(ConnsSupSup0),
  1536. %% Receive traces from newly started children
  1537. ConnsSupSup = receive {trace, Pid, spawn, Pid2, _} -> Pid2 end,
  1538. [receive {trace, ConnsSupSup, spawn, _Pid, _} -> ok end ||
  1539. _ <- lists:seq(1, NumAcc)],
  1540. AccSupPid = receive {trace, Pid, spawn, Pid3, _} -> Pid3 end,
  1541. %% ...and its acceptors.
  1542. [receive {trace, AccSupPid, spawn, _Pid, _} -> ok end ||
  1543. _ <- lists:seq(1, NumAcc)],
  1544. %% No more traces then.
  1545. receive
  1546. {trace, EPid, spawn, _, _} when EPid == Pid; EPid == AccSupPid ->
  1547. error(invalid_restart)
  1548. after 1000 -> ok end,
  1549. %% Verify that new children registered themselves properly.
  1550. _ = erlang:trace(all, false, [all]),
  1551. ok = clean_traces(),
  1552. ok = ranch:stop_listener(Name).
  1553. supervisor_conns_alive(_) ->
  1554. doc("Ensure that active connections stay open when the listening socket gets closed."),
  1555. Name = name(),
  1556. {module, ranch_tcp} = code:ensure_loaded(ranch_tcp),
  1557. _ = erlang:trace(new, true, [call]),
  1558. 1 = erlang:trace_pattern({ranch_tcp, listen, 1},
  1559. [{'_', [], [{return_trace}]}], [global]),
  1560. {ok, _} = ranch:start_listener(Name,
  1561. ranch_tcp, #{},
  1562. remove_conn_and_wait_protocol, [{remove, false, 2500}]),
  1563. %% Get the listener socket
  1564. LSocket = receive
  1565. {trace, _, return_from, {ranch_tcp, listen, 1}, {ok, S}} ->
  1566. S
  1567. after 500 ->
  1568. error(lsocket_unknown)
  1569. end,
  1570. TcpPort = ranch:get_port(Name),
  1571. {ok, Socket} = gen_tcp:connect("localhost", TcpPort,
  1572. [binary, {active, true}, {packet, raw}]),
  1573. receive after 500 -> ok end,
  1574. %% Shut the socket down
  1575. ok = gen_tcp:close(LSocket),
  1576. %% Assert that client is still viable.
  1577. receive {tcp_closed, _} -> error(closed) after 1500 -> ok end,
  1578. ok = gen_tcp:send(Socket, <<"poke">>),
  1579. receive {tcp_closed, _} -> ok end,
  1580. _ = erlang:trace(all, false, [all]),
  1581. ok = clean_traces(),
  1582. ok = ranch:stop_listener(Name).
  1583. supervisor_embedded_ranch_server_crash(_) ->
  1584. doc("Ensure that restarting ranch_server also restarts embedded listeners."),
  1585. Name = name(),
  1586. {ok, SupPid} = embedded_sup:start_link(),
  1587. {ok, EmbeddedSupPid} = embedded_sup:start_listener(SupPid, Name,
  1588. ranch_tcp, #{},
  1589. echo_protocol, []),
  1590. [{{ranch_listener_sup, Name}, ListenerPid, supervisor, _},
  1591. {ranch_server_proxy, ProxyPid, worker, _}] = supervisor:which_children(EmbeddedSupPid),
  1592. ProxyMonitor = monitor(process, ProxyPid),
  1593. ListenerMonitor = monitor(process, ListenerPid),
  1594. ok = supervisor:terminate_child(ranch_sup, ranch_server),
  1595. receive {'DOWN', ProxyMonitor, process, ProxyPid, shutdown} -> ok after 1000 -> exit(timeout) end,
  1596. receive {'DOWN', ListenerMonitor, process, ListenerPid, shutdown} -> ok after 1000 -> exit(timeout) end,
  1597. {ok, _} = supervisor:restart_child(ranch_sup, ranch_server),
  1598. receive after 1000 -> ok end,
  1599. [{{ranch_listener_sup, Name}, _, supervisor, _},
  1600. {ranch_server_proxy, _, worker, _}] = supervisor:which_children(EmbeddedSupPid),
  1601. embedded_sup:stop_listener(SupPid, Name),
  1602. embedded_sup:stop(SupPid),
  1603. ok.
  1604. supervisor_protocol_start_link_crash(_) ->
  1605. doc("Ensure a protocol start crash does not kill all connections."),
  1606. Name = name(),
  1607. {ok, _} = ranch:start_listener(Name,
  1608. ranch_tcp, #{},
  1609. crash_protocol, []),
  1610. ConnsSups = ranch_server:get_connections_sups(Name),
  1611. Port = ranch:get_port(Name),
  1612. {ok, _} = gen_tcp:connect("localhost", Port, [binary, {active, true}, {packet, raw}]),
  1613. receive after 500 -> ok end,
  1614. ConnsSups = ranch_server:get_connections_sups(Name),
  1615. ok = ranch:stop_listener(Name).
  1616. supervisor_server_recover_state(_) ->
  1617. doc("Ensure that when ranch_server crashes and restarts, it recovers "
  1618. "its state and continues monitoring the same processes."),
  1619. Name = name(),
  1620. _ = erlang:trace(new, true, [call]),
  1621. 1 = erlang:trace_pattern({ranch_server, init, 1},
  1622. [{'_', [], [{return_trace}]}], [global]),
  1623. {ok, _} = ranch:start_listener(Name,
  1624. ranch_tcp, #{},
  1625. echo_protocol, []),
  1626. ConnsSups = ranch_server:get_connections_sups(Name),
  1627. ServerPid = erlang:whereis(ranch_server),
  1628. {monitors, Monitors} = erlang:process_info(ServerPid, monitors),
  1629. erlang:exit(ServerPid, kill),
  1630. receive
  1631. {trace, ServerPid2, return_from, {ranch_server, init, 1}, _Result} ->
  1632. {monitors, Monitors2} = erlang:process_info(ServerPid2, monitors),
  1633. %% Check that ranch_server is monitoring the same processes.
  1634. true = (lists:usort(Monitors) == lists:usort(Monitors2))
  1635. after
  1636. 1000 ->
  1637. error(timeout)
  1638. end,
  1639. ConnsSups = ranch_server:get_connections_sups(Name),
  1640. ok = ranch:stop_listener(Name),
  1641. %% Check ranch_server has removed the ranch_conns_sup.
  1642. [] = (catch ranch_server:get_connections_sups(Name)),
  1643. _ = erlang:trace(all, false, [all]),
  1644. ok = clean_traces().
  1645. supervisor_unexpected_message(_) ->
  1646. doc("Ensure the connections supervisor stays alive when it receives "
  1647. "an unexpected message."),
  1648. Name = name(),
  1649. {ok, _} = ranch:start_listener(Name,
  1650. ranch_tcp, #{},
  1651. echo_protocol, []),
  1652. Port = ranch:get_port(Name),
  1653. {ok, Socket} = gen_tcp:connect("localhost", Port, [binary, {active, false}, {packet, raw}]),
  1654. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1655. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1656. %% Send the unexpected message to all ranch_conns_sups.
  1657. _ = [ConnSup ! hello || {_, ConnSup} <- ranch_server:get_connections_sups(Name)],
  1658. %% Connection is still up.
  1659. ok = gen_tcp:send(Socket, <<"TCP Ranch is working!">>),
  1660. {ok, <<"TCP Ranch is working!">>} = gen_tcp:recv(Socket, 21, 1000),
  1661. ok = ranch:stop_listener(Name),
  1662. {error, closed} = gen_tcp:recv(Socket, 0, 1000),
  1663. %% Make sure the listener stopped.
  1664. {'EXIT', _} = begin catch ranch:get_port(Name) end,
  1665. ok.
  1666. %% Utility functions.
  1667. connect_loop(_, 0, _) ->
  1668. ok;
  1669. connect_loop(Port, N, Sleep) ->
  1670. {ok, _} = gen_tcp:connect("localhost", Port,
  1671. [binary, {active, false}, {packet, raw}]),
  1672. receive after Sleep -> ok end,
  1673. connect_loop(Port, N - 1, Sleep).
  1674. receive_loop(Message, Timeout) ->
  1675. receive_loop(Message, Timeout, 0, []).
  1676. receive_loop(Message, Timeout, N, Acc) ->
  1677. receive {Pid, Message} ->
  1678. receive_loop(Message, Timeout, N + 1, [Pid|Acc])
  1679. after Timeout ->
  1680. {N, Acc}
  1681. end.
  1682. terminate_loop(_, []) ->
  1683. ok;
  1684. terminate_loop(Message, [Pid|Pids]) ->
  1685. Pid ! Message,
  1686. terminate_loop(Message, Pids).
  1687. clean_traces() ->
  1688. receive
  1689. {trace, _, _, _} ->
  1690. clean_traces();
  1691. {trace, _, _, _, _} ->
  1692. clean_traces()
  1693. after 0 ->
  1694. ok
  1695. end.
  1696. do_get_listener_socket(ListenerSupPid) ->
  1697. [LSocket] = do_get_listener_sockets(ListenerSupPid),
  1698. LSocket.
  1699. do_get_listener_sockets(ListenerSupPid) ->
  1700. [AcceptorsSupPid] = [Pid || {ranch_acceptors_sup, Pid, supervisor, _}
  1701. <- supervisor:which_children(ListenerSupPid)],
  1702. {links, Links} = erlang:process_info(AcceptorsSupPid, links),
  1703. [P || P <- Links, is_port(P)].
  1704. do_conns_which_children(Name) ->
  1705. Conns = [supervisor:which_children(ConnsSup) ||
  1706. {_, ConnsSup} <- ranch_server:get_connections_sups(Name)],
  1707. lists:flatten(Conns).
  1708. do_conns_count_children(Name) ->
  1709. lists:foldl(
  1710. fun
  1711. (Stats, undefined) ->
  1712. Stats;
  1713. (Stats, Acc) ->
  1714. lists:zipwith(
  1715. fun ({K, V1}, {K, V2}) -> {K, V1+V2} end,
  1716. Acc,
  1717. Stats
  1718. )
  1719. end,
  1720. undefined,
  1721. [supervisor:count_children(ConnsSup) ||
  1722. {_, ConnsSup} <- ranch_server:get_connections_sups(Name)]
  1723. ).
  1724. do_os_supports_reuseport() ->
  1725. case {os:type(), os:version()} of
  1726. {{unix, linux}, {Major, _, _}} when Major > 3 -> true;
  1727. {{unix, linux}, {3, Minor, _}} when Minor >= 9 -> true;
  1728. _ -> false
  1729. end.
  1730. do_os_supports_local_sockets() ->
  1731. case os:type() of
  1732. {unix, _} -> true;
  1733. _ -> false
  1734. end.
  1735. do_tempname() ->
  1736. list_to_binary(lists:droplast(os:cmd("mktemp -u"))).
  1737. do_get_ssl_version() ->
  1738. {ok, Vsn} = application:get_key(ssl, vsn),
  1739. Vsns0 = re:split(Vsn, "\\D+", [{return, list}]),
  1740. Vsns1 = lists:map(fun list_to_integer/1, Vsns0),
  1741. case Vsns1 of
  1742. [] -> {0, 0, 0};
  1743. [Major] -> {Major, 0, 0};
  1744. [Major, Minor] -> {Major, Minor, 0};
  1745. [Major, Minor, Patch|_] -> {Major, Minor, Patch}
  1746. end.