I disagree on grounds that it is possible to write software in Erlang without this vulnerability. Primarily I consider this a documentation defect; someone which knew about this problem would not have an issue.

However, I agree, this is an unacceptable current threat level. That’s why I wrote a library fix. ~

I think it is intolerable for such a robust system as Erlang to drop a few packets now and then.

Two other existing issues are: 1) closing the listening socket sends the accepting process into a tight CPU-eating loop because the closed condition is treated just as any other error, looping back to do another accept, and 2) it would be nice to be able to pass port 0 to the listener to have it open an ephemeral port and then have that port number returned to the caller (this helps make it easier to test, for one thing).

Find a patch for all these issues below.

Also, here’s a test program. Apply the patch, then comment out the call to gen_tcp:controlling_process/2 to simulate svn version 98 of your code. Then compile everything and run the test, like this:

t:test().

It will work for the first case (the {active, false} case) only. Restore the call to gen_tcp:controlling_process/2 and recompile, then retry the test. All cases will then work fine. This is why I think your original code never worked. Here’s the test code, feel free to use it as you like.

===================
-module(t).
-export([test/0, test/1]).
-author(“Steve Vinoski “).

test() ->
lists:map(fun test/1, [false, once, true]).

test(Active) ->
Self = self(),
{ok, Pid, Port} = scutil:standard_listener(
fun(S, Opts) ->
case proplists:get_value(active, Opts) of
false ->
Msg = gen_tcp:recv(S, 14, 2000),
io:format(“active(false) handler received ~p~n”, [Msg]);
A ->
receive
Msg ->
io:format(“active(~p) handler msg: ~p~n”, [A, Msg])
after 2000 ->
io:format(“active(~p) handler timed out~n”, [A])
end
end,
Self ! done,
exit(normal)
end, 0, [{packet, raw}, binary, {active, Active}]),
{ok, P} = gen_tcp:connect(“localhost”, Port, [{packet, raw}, binary]),
gen_tcp:send(P, <>),
receive
done -> Pid ! terminate
after 10000 -> timeout
end.
===================

And here’s the patch:

Index: scutil.erl
===================================================================
— scutil.erl (revision 100)
+++ scutil.erl (working copy)
@@ -2662,7 +2662,7 @@

-%% @spec standard_listener(Handler, Port, SocketOptions) -> { ok, WorkerPid } | { error, E }
+%% @spec standard_listener(Handler, Port, SocketOptions) -> { ok, WorkerPid, ListeningPort } | { error, E }

%% @doc {@section Network} Listens on a socket and manages the fast packet loss problem.
%%
@@ -2688,7 +2688,11 @@
case gen_tcp:listen(Port, FixedOptions) of

{ ok, ListeningSocket } ->
- { ok, spawn(?MODULE, standard_listener_controller, [Handler, Port, FixedOptions, ListeningSocket, ActiveStatus, 0]) };
+ ListeningPort = case Port of
+ 0 -> {ok, LP} = inet:port(ListeningSocket), LP;
+ _ -> Port
+ end,
+ { ok, spawn(?MODULE, standard_listener_controller, [Handler, Port, FixedOptions, ListeningSocket, ActiveStatus, 0]), ListeningPort };

{ error, E } ->
{ error, E }
@@ -2741,9 +2745,13 @@

{ ok, ConnectedSocket } ->
Controller ! serviced,
- spawn(?MODULE, standard_listener_shunt, [Handler, Port, FixedOptions, ConnectedSocket, ActiveStatus]),
+ Pid = spawn(?MODULE, standard_listener_shunt, [Handler, Port, FixedOptions, ConnectedSocket, ActiveStatus]),
+ gen_tcp:controlling_process(ConnectedSocket, Pid),
standard_listener_accept_loop(Handler, Port, FixedOptions, ListeningSocket, ActiveStatus, Controller);

+ { error, closed } ->
+ closed;
+
{ error, _E } ->
standard_listener_accept_loop(Handler, Port, FixedOptions, ListeningSocket, ActiveStatus, Controller)

@@ -2757,7 +2765,6 @@

standard_listener_shunt(Handler, Port, FixedOptions, ConnectedSocket, ActiveStatus) ->

- controlling_process(ConnectedSocket, self()),
CollectedOptions = proplists:delete(active, FixedOptions) ++ [{active, ActiveStatus}, {from_port, Port}],

case ActiveStatus of

Either way, fixed in Version 99. You’re added to the thanks table in Version 100.

The inet:setopts documentation says nothing about transferring socket ownership, and a quick look through the R12B-5 sources doesn’t seem to show any ownership transfer in inet:setopts or anything it calls.

However, for the sake of writing explicit code, I will update both the example and the library code.