File 1401-kernel-gen-udp-socket-Add-socket-based-gen... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1401-kernel-gen-udp-socket-Add-socket-based-gen_udp.patch of Package erlang (Revision e6fae69e60dcc1918fd2bc4ae52e9ff8)

Currently displaying revision e6fae69e60dcc1918fd2bc4ae52e9ff8 , Show latest

From c2915a365fcded89895f0a93ca890dd08d3ec694 Mon Sep 17 00:00:00 2001
From: Micael Karlberg <bmk@erlang.org>
Date: Fri, 11 Jun 2021 17:04:02 +0200
Subject: [PATCH 01/12] [kernel|gen-udp-socket] Add socket based gen_udp

First stage of the 'socket' based gen_udp.

OTP-17410
---
 lib/kernel/src/Makefile             |    1 +
 lib/kernel/src/gen_udp.erl          |  105 +-
 lib/kernel/src/gen_udp_socket.erl   | 2414 +++++++++++++++++++++++++++
 lib/kernel/src/inet.erl             |   31 +-
 lib/kernel/src/inet_int.hrl         |    2 +-
 lib/kernel/test/gen_udp_SUITE.erl   |  498 ++++--
 lib/kernel/test/kernel_test_lib.erl |   10 +
 lib/kernel/test/kernel_test_lib.hrl |    4 +
 8 files changed, 2890 insertions(+), 175 deletions(-)
 create mode 100644 lib/kernel/src/gen_udp_socket.erl

diff --git a/lib/kernel/src/Makefile b/lib/kernel/src/Makefile
index 1bf8459602..c3d71742d7 100644
--- a/lib/kernel/src/Makefile
+++ b/lib/kernel/src/Makefile
@@ -84,6 +84,7 @@ MODULES = \
 	gen_tcp \
 	gen_tcp_socket \
 	gen_udp \
+	gen_udp_socket \
 	gen_sctp \
 	global \
 	global_group \
diff --git a/lib/kernel/src/gen_udp.erl b/lib/kernel/src/gen_udp.erl
index 8468dc6232..06f92f1ba0 100644
--- a/lib/kernel/src/gen_udp.erl
+++ b/lib/kernel/src/gen_udp.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1997-2020. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2021. 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.
@@ -26,6 +26,9 @@
 
 -include("inet_int.hrl").
 
+-define(module_socket(Handler, Handle),
+        {'$inet', (Handler), (Handle)}).
+
 -type option() ::
         {active,          true | false | once | -32768..32767} |
         {add_membership,  {inet:ip_address(), inet:ip_address()}} |
@@ -88,10 +91,14 @@
         recvttl |
         pktoptions |
 	ipv6_v6only.
--type socket() :: port().
+
+-type socket() :: inet:socket().
 
 -export_type([option/0, option_name/0, socket/0]).
 
+
+%% -- open ------------------------------------------------------------------
+
 -spec open(Port) -> {ok, Socket} | {error, Reason} when
       Port :: inet:port_number(),
       Socket :: socket(),
@@ -115,23 +122,60 @@ open(Port) ->
       Reason :: system_limit | inet:posix().
 
 open(Port, Opts0) ->
+    case inet:gen_udp_module(Opts0) of
+	{?MODULE, Opts} ->
+	    open1(Port, Opts);
+	{GenUdpMod, Opts} ->
+	    GenUdpMod:open(Port, Opts)
+    end.
+
+open1(Port, Opts0) ->
     {Mod, Opts} = inet:udp_module(Opts0),
     {ok, UP} = Mod:getserv(Port),
     Mod:open(UP, Opts).
+    
+
+%% -- close -----------------------------------------------------------------
 
 -spec close(Socket) -> ok when
       Socket :: socket().
 
+close(?module_socket(GenUdpMod, _) = S) when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S);
 close(S) ->
     inet:udp_close(S).
 
+
+%% -- send ------------------------------------------------------------------
+
+%% Connected send
+
+-spec send(Socket, Packet) -> ok | {error, Reason} when
+      Socket :: socket(),
+      Packet :: iodata(),
+      Reason :: not_owner | inet:posix().
+
+send(?module_socket(GenUdpMod, _) = S, Packet)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Packet);
+send(S, Packet) when is_port(S) ->
+    case inet_db:lookup_socket(S) of
+	{ok, Mod} ->
+	    Mod:send(S, Packet);
+	Error ->
+	    Error
+    end.
+
 -spec send(Socket, Destination, Packet) -> ok | {error, Reason} when
       Socket :: socket(),
       Destination :: {inet:ip_address(), inet:port_number()} |
-                     inet:family_address(),
+		     inet:family_address(),
       Packet :: iodata(),
       Reason :: not_owner | inet:posix().
-%%%
+
+send(?module_socket(GenUdpMod, _) = S, Destination, Packet)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Destination, Packet);
 send(Socket, Destination, Packet) ->
     send(Socket, Destination, [], Packet).
 
@@ -157,7 +201,11 @@ send(Socket, Destination, Packet) ->
       PortZero :: inet:port_number(),
       Packet :: iodata(),
       Reason :: not_owner | inet:posix().
-%%%
+
+send(?module_socket(GenUdpMod, _) = S, Arg2, Arg3, Packet)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Arg2, Arg3, Packet);
+
 send(S, {_,_} = Destination, PortZero = AncData, Packet) when is_port(S) ->
     %% Destination is {Family,Addr} | {IP,Port},
     %% so it is complete - argument PortZero is redundant
@@ -190,7 +238,11 @@ send(S, Host, Port, Packet) when is_port(S) ->
       AncData :: inet:ancillary_data(),
       Packet :: iodata(),
       Reason :: not_owner | inet:posix().
-%%%
+
+send(?module_socket(GenUdpMod, _) = S, Host, Port, AncData, Packet)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Host, Port, AncData, Packet);
+
 send(S, Host, Port, AncData, Packet)
   when is_port(S), is_list(AncData) ->
     case inet_db:lookup_socket(S) of
@@ -209,14 +261,8 @@ send(S, Host, Port, AncData, Packet)
 	    Error
     end.
 
-%% Connected send
-send(S, Packet) when is_port(S) ->
-    case inet_db:lookup_socket(S) of
-	{ok, Mod} ->
-	    Mod:send(S, Packet);
-	Error ->
-	    Error
-    end.
+
+%% -- recv ------------------------------------------------------------------
 
 -spec recv(Socket, Length) ->
                   {ok, RecvData} | {error, Reason} when
@@ -229,7 +275,10 @@ send(S, Packet) when is_port(S) ->
       Packet :: string() | binary(),
       Reason :: not_owner | inet:posix().
 
-recv(S,Len) when is_port(S), is_integer(Len) ->
+recv(?module_socket(GenUdpMod, _) = S, Len)
+  when is_atom(GenUdpMod) andalso is_integer(Len) ->
+    GenUdpMod:?FUNCTION_NAME(S, Len);
+recv(S, Len) when is_port(S) andalso is_integer(Len) ->
     case inet_db:lookup_socket(S) of
 	{ok, Mod} ->
 	    Mod:recv(S, Len);
@@ -249,14 +298,24 @@ recv(S,Len) when is_port(S), is_integer(Len) ->
       Packet :: string() | binary(),
       Reason :: not_owner | timeout | inet:posix().
 
-recv(S,Len,Time) when is_port(S) ->
+recv(?module_socket(GenUdpMod, _) = S, Len, Time)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Len, Time);
+recv(S, Len, Time) when is_port(S) ->
     case inet_db:lookup_socket(S) of
 	{ok, Mod} ->
-	    Mod:recv(S, Len,Time);
+	    Mod:recv(S, Len, Time);
 	Error ->
 	    Error
     end.
 
+
+%% -- connect ---------------------------------------------------------------
+
+connect(?module_socket(GenUdpMod, _) = S, Address, Port)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, Address, Port);
+
 connect(S, Address, Port) when is_port(S) ->
     case inet_db:lookup_socket(S) of
 	{ok, Mod} ->
@@ -270,16 +329,26 @@ connect(S, Address, Port) when is_port(S) ->
 	    Error
     end.
 
+
+%% -- controlling_process ---------------------------------------------------
+
 -spec controlling_process(Socket, Pid) -> ok | {error, Reason} when
       Socket :: socket(),
       Pid :: pid(),
       Reason :: closed | not_owner | badarg | inet:posix().
 
+controlling_process(?module_socket(GenUdpMod, _) = S, NewOwner)
+  when is_atom(GenUdpMod) ->
+    GenUdpMod:?FUNCTION_NAME(S, NewOwner);
+
 controlling_process(S, NewOwner) ->
     inet:udp_controlling_process(S, NewOwner).
 
+
+%% -- fdopen ----------------------------------------------------------------
+
 %%
-%% Create a port/socket from a file descriptor 
+%% Create a port/socket from a file descriptor
 %%
 fdopen(Fd, Opts0) ->
     {Mod,Opts} = inet:udp_module(Opts0),
diff --git a/lib/kernel/src/gen_udp_socket.erl b/lib/kernel/src/gen_udp_socket.erl
new file mode 100644
index 0000000000..6fb2b0ba4f
--- /dev/null
+++ b/lib/kernel/src/gen_udp_socket.erl
@@ -0,0 +1,2414 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2021-2021. 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.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(gen_udp_socket).
+-behaviour(gen_statem).
+
+-compile({no_auto_import, [monitor/1]}).
+
+%% gen_udp
+-export([
+	 open/2,
+	 close/1,
+	 connect/3,
+	 controlling_process/2,
+	 recv/2,recv/3,
+         send/2, send/3, send/4, send/5
+	]).
+
+%% inet
+-export([
+         monitor/1, cancel_monitor/1,
+         setopts/2, getopts/2,
+         sockname/1, peername/1,
+         getstat/2
+        ]).
+
+%% Utility
+-export([info/1, which_sockets/0, socket_to_list/1]).
+
+-ifdef(undefined).
+-export([fdopen/2]).
+-endif.
+
+%% gen_statem callbacks
+-export([init/1, callback_mode/0, terminate/3]).
+-export([handle_event/4]).
+
+-include("inet_int.hrl").
+
+-define(DBG(T), erlang:display({{self(), ?MODULE, ?LINE, ?FUNCTION_NAME}, T})).
+-define(RECBUF, 65536).
+
+
+%% -------------------------------------------------------------------------
+
+%% Construct a "socket" as in this module's API
+-define(MODULE_socket(Server, Socket),
+        {'$inet', ?MODULE, {Server, Socket}}).
+
+%% %% Standard length before data header for packet,1|2|4
+%% -define(header(Packet, Size),
+%%         (Size):(Packet)/unit:8-integer-big-unsigned).
+
+-define(badarg_exit(Error),
+        case begin Error end of
+            {error, badarg} -> exit(badarg);
+            OTHER__ -> OTHER__
+        end).
+
+-define(badarg_einval_exit(Error),
+        case begin Error end of
+            {error, badarg} -> exit(badarg);
+            {error, einval} -> exit(badarg);
+            OTHER__ -> OTHER__
+        end).
+
+-define(socket_abort(Socket, SelectRef, Reason),
+        {'$socket', (Socket), abort, {(SelectRef), (Reason)}}).
+-define(socket_select(Socket, SelectRef),
+        {'$socket', (Socket), select, (SelectRef)}).
+-define(socket_counter_wrap(Socket, Counter),
+        {'$socket', (Socket), counter_wrap, (Counter)}).
+-define(select_info(SelectRef),
+        {select_info, _, (SelectRef)}).
+
+
+%%% ========================================================================
+%%% API
+%%%
+
+%% -- close ----------------------------------------------------------------
+
+close(?MODULE_socket(Server, _Socket)) ->
+    ?badarg_exit(close_server(Server)).
+
+
+%% Helpers -------
+
+close_server(Server) ->
+    Result = call(Server, close),
+    stop_server(Server),
+    Result.
+
+
+%% -- connect ----------------------------------------------------------------
+
+connect(?MODULE_socket(_Server, Socket), Address, Port) ->
+    socket:connect(Socket, dest2sockaddr({Address, Port})).
+
+
+%% -- open -----------------------------------------------------------------
+
+%% -spec open(Service, Opts) -> {ok, Socket} | {error, Reason} when
+%%       Socket  :: socket(),
+%%       Service :: inet:port_number() | atom(),
+%%       Opts    :: list(),
+%%       Reason  :: inet:posix().
+
+open(Service, Opts) ->
+    open_lookup(Service, Opts).
+
+
+%% Helpers -------
+
+open_lookup(Service, Opts0) ->
+    ?DBG(['open lookup', {service, Service}, {opts, Opts0}]),
+    {EinvalOpts, Opts_1} = setopts_split(einval, Opts0),
+    EinvalOpts =:= [] orelse exit(badarg),
+    {Mod, Opts_2} = inet:udp_module(Opts_1),
+    Domain = domain(Mod),
+    {StartOpts, Opts_3} = setopts_split(start, Opts_2),
+    ErrRef = make_ref(),
+    try
+	begin
+	    %% IPs    = val(ErrRef, Mod:getaddrs(Address, Domain)),
+	    Port   = val(ErrRef, Mod:getserv(Service)),
+	    Opts_4 = [{port, Port}, {buffer, ?RECBUF} | Opts_3],
+	    % Opts_4 = [{port, Port},  | Opts_3],
+	    #udp_opts{fd     = Fd,
+		      ifaddr = BindIP,
+		      port   = BindPort,
+		      opts   = OpenOpts} =
+		val(ErrRef, inet:udp_options(Opts_4, Mod)),
+            ?DBG([{fd, Fd}, {bind_ip, BindIP}, {bind_port, BindPort}, {opts, OpenOpts}]),
+            BindAddr = bind_addr(Domain, BindIP, BindPort, Fd),
+            ExtraOpts = extra_opts(Fd),
+            do_open(Mod, BindAddr, Domain, OpenOpts, StartOpts, ExtraOpts)
+	end
+    catch
+        throw : {ErrRef, Reason} ->
+            ?badarg_exit({error, Reason})
+    end.
+
+do_open(Mod, BindAddr, Domain, OpenOpts, Opts, ExtraOpts) ->
+
+    ?DBG([{mod, Mod}, {bind_addr, BindAddr}, {domain, Domain}, {open_opts, OpenOpts}, {opts, Opts}, {extra_opts, ExtraOpts}]),
+
+    %%
+    %% The {netns, File} option is passed in Fd by inet:connect_options/2,
+    %% and then over to ExtraOpts.
+    %% The {debug, Bool} option is passed in Opts since it is
+    %% subversively classified as both start and socket option.
+    %%
+
+    {SocketOpts, StartOpts} = setopts_split(socket, Opts),
+    ?DBG(['try start server', {socket, SocketOpts}, {start, StartOpts}]),
+    case start_server(Mod, Domain, start_opts(StartOpts), ExtraOpts) of
+        {ok, Server} ->
+            {SetOpts0, _} = setopts_split(#{socket       => [],
+                                            server_read  => [],
+                                            server_write => []},
+                                          OpenOpts),
+            SetOpts =
+                default_active_true(
+                  [{start_opts, StartOpts}] ++ SocketOpts ++ SetOpts0),
+
+            ErrRef = make_ref(),
+            try
+                ?DBG(['try setopts',
+                      {socket_opts, SocketOpts}, {set_opts, SetOpts}]),
+                ok(ErrRef, call(Server, {setopts, SocketOpts ++ SetOpts})),
+
+                ?DBG(['maybe try bind', {bind_addr, BindAddr}]),
+                ok(ErrRef, call_bind(Server,
+                                     default_any(Domain, ExtraOpts, BindAddr))),
+
+                ?DBG(['try get-socket']),
+                Socket = val(ErrRef, call(Server, get_socket)),
+
+                {ok, ?MODULE_socket(Server, Socket)}
+            catch
+                throw : {ErrRef, Reason} ->
+                    close_server(Server),
+                    ?badarg_exit({error, Reason})
+            end;
+        {error, _} = Error ->
+            ?badarg_exit(Error)
+    end.
+
+    
+extra_opts(Fd) when is_integer(Fd) ->
+    if
+        Fd < 0 ->
+            #{};
+        true ->
+            #{fd => Fd}
+    end;
+extra_opts(OpenOpts) when is_list(OpenOpts) ->
+    %% This is an **ugly** hack.
+    %% inet:{connect,listen,udp,sctp}_options/2 has the bad taste
+    %% to use this for [{netns,BinNS}] if that option is used...
+   maps:from_list(OpenOpts).
+
+
+default_any(_Domain, #{fd := _}, _BindAddr) ->
+    undefined;
+default_any(Domain, _ExtraOpts, undefined = Undefined) ->
+    if
+        ((Domain =:= inet) orelse (Domain =:= inet6)) ->
+            #{family => Domain,
+              addr   => any,
+              port   => 0};
+        true ->
+            Undefined
+    end;
+default_any(_Domain, _ExtraOpts, BindAddr) ->
+    BindAddr.
+
+bind_addr(_Domain, BindIP, _BindPort, Fd)
+  when (BindIP =:= undefined) orelse (is_integer(Fd) andalso (0 =< Fd)) ->
+    %% Do not bind!
+    undefined;
+bind_addr(local = Domain, BindIP, _BindPort, _Fd) ->
+    case BindIP of
+	any ->
+	    undefined;
+	{local, Path} ->
+	    #{family => Domain,
+	      path   => Path}
+    end;
+bind_addr(Domain, BindIP, BindPort, _Fd)
+  when (Domain =:= inet) orelse (Domain =:= inet6) ->
+    #{family => Domain,
+      addr   => BindIP,
+      port   => BindPort}.
+
+call_bind(_Server, undefined) ->
+    ok;
+call_bind(Server, BindAddr) ->
+    call(Server, {bind, BindAddr}).
+
+
+default_active_true(Opts) ->
+    case lists:keyfind(active, 1, Opts) of
+        {active,_} ->
+            Opts;
+        _ ->
+            [{active, true} | Opts]
+    end.
+
+
+%% -------------------------------------------------------------------------
+
+%% Connected send
+
+send(?MODULE_socket(_Server, Socket), Data) ->
+    socket_send(Socket, Data);
+send(_Socket, _Data) ->
+    %% erlang:error(badarg, [_Socket, _Data]).
+    exit(badarg).
+
+
+
+-compile({inline, [make_iov/1]}).
+make_iov(Bin) when is_binary(Bin) -> [Bin];
+make_iov(IOV) when is_list(IOV)   -> IOV.
+    
+-compile({inline, [dest2sockaddr/1]}).
+dest2sockaddr({Addr, Port})
+  when is_tuple(Addr) andalso (size(Addr) =:= 4) andalso is_integer(Port) ->
+    #{family => inet,
+      port   => Port,
+      addr   => Addr};
+dest2sockaddr({Addr, Port})
+  when is_tuple(Addr) andalso (size(Addr) =:= 8) andalso is_integer(Port) ->
+    #{family => inet6,
+      port   => Port,
+      addr   => Addr};
+dest2sockaddr({Fam, {Addr, Port}})
+  when is_atom(Fam) andalso is_integer(Port) ->
+    #{family => Fam,
+      port   => Port,
+      addr   => Addr};
+dest2sockaddr(_) ->
+    exit(badarg).
+
+-compile({inline, [make_cmsghdrs/1]}).
+make_cmsghdrs(AncData) when is_list(AncData) ->
+    [make_cmsghdr(AD) || AD <- AncData];
+make_cmsghdrs(_) ->
+    exit(badarg).
+
+make_cmsghdr({tos = Type, Byte}) ->
+    #{level => ip, type => Type, data => Byte};
+make_cmsghdr({tclass = Type, Byte}) ->
+    #{level => ipv6, type => Type, data => Byte};
+make_cmsghdr({ttl = Type, Byte}) ->
+    #{level => ip, type => Type, data => Byte};
+make_cmsghdr(_) ->
+    exit(badarg).
+    
+
+send(Socket, Destination, Data) ->
+    do_sendto(Socket, dest2sockaddr(Destination), Data).
+
+send(Socket, {_, _} = Destination, PortZero, Data)
+  when (PortZero =:= 0) ->
+    send(Socket, Destination, Data);
+send(_Socket, {_,_} = _Destination, PortZero, _Data)
+  when is_integer(PortZero) ->
+    {error, einval};
+send(Socket, {_,_} = Destination, AncData, Data) ->
+    do_sendmsg(Socket,
+	       dest2sockaddr(Destination),
+	       make_iov(Data),
+	       make_cmsghdrs(AncData));
+send(Socket, Addr, Port, Data)
+  when is_tuple(Addr) andalso
+       ((size(Addr) =:= 4) orelse (size(Addr) =:= 8)) andalso
+       is_integer(Port) ->
+    send(Socket, {Addr, Port}, Data);
+send(?MODULE_socket(_, ESock) = Socket,
+     Host, Service, Data) when is_list(Host) orelse is_atom(Host) ->
+    case socket:getopt(ESock, {otp, domain}) of
+	{ok, Domain} ->
+	    case inet:getaddr(Host, Domain) of
+		{ok, Addr} ->
+                    {ok, #{mod := Mod}} = socket:getopt(ESock, {otp, meta}),
+		    case Mod:getserv(Service) of
+			{ok, Port} ->
+			    send(Socket, {Addr, Port}, Data);
+			{error, einval} ->
+			    exit(badarg);
+			{error, _} = ERROR ->
+			    ERROR
+		    end;
+		{error, einval} ->
+		    exit(badarg);
+		{error, _} = ERROR ->
+		    ERROR
+	    end;
+	ERROR ->
+	    ERROR
+    end;
+send(_Socket, _Arg1, _Arg2, _Arg3) ->
+    %% erlang:error(badarg, [_Socket, _Arg1, _Arg2, _Arg3]).
+    exit(badarg).
+
+
+send(?MODULE_socket(_, ESock) = Socket,
+     Host, Service, AncData, Data) when is_list(Host) orelse is_atom(Host) ->
+    case socket:getopt(ESock, {otp, domain}) of
+	{ok, Domain} ->
+	    case inet:getaddr(Host, Domain) of
+		{ok, Addr} ->
+                    {ok, #{mod := Mod}} = socket:getopt(ESock, {otp, meta}),
+		    case Mod:getserv(Service) of
+			{ok, Port} ->
+			    send(Socket, {Addr, Port}, AncData, Data);
+			{error, einval} ->
+			    exit(badarg);
+			{error, _} = ERROR ->
+			    ERROR
+		    end;
+		{error, einval} ->
+		    exit(badarg);
+		{error, _} = ERROR ->
+		    ERROR
+	    end;
+	ERROR ->
+	    ERROR
+    end;
+send(_Socket, _Arg1, _Arg2, _Arg3, _Arg4) ->
+    %% erlang:error(badarg, [_Socket, _Arg1, _Arg2, _Arg3, _Arg4]).
+    exit(badarg).
+
+
+
+do_sendto(?MODULE_socket(_Server, Socket), Dest, Data) ->
+    case socket_sendto(Socket, Dest, Data) of
+        {error, {invalid, _}} ->
+            exit(badarg);
+        Any ->
+            Any
+    end.
+
+do_sendmsg(?MODULE_socket(_Server, Socket), SockAddr, IOV, Ctrl)
+  when is_list(IOV) andalso is_list(Ctrl) ->
+    MsgHdr = #{addr => SockAddr,
+	       iov  => IOV,
+	       ctrl => Ctrl},
+    case socket_sendmsg(Socket, MsgHdr) of
+        {error, {invalid, _}} ->
+            exit(badarg);
+        Any ->
+            Any
+    end.
+
+    
+%% -------------------------------------------------------------------------
+
+recv(Socket, Length) ->
+    recv(Socket, Length, infinity).
+
+%% This is a bit wierd. If two calls to recv is made with short intervalls
+%% from different processes, with say timeout 10s and then 5s. The second
+%% call will be postponed until the first has been processed, which can
+%% take up to 10s. If the first times out (after 10s) the second is 
+%% supposed to have been timed out already by the time it gets processed.
+%% Can we postpone? And can we make conditional postpone?
+
+recv(?MODULE_socket(Server, _Socket), Length, Timeout) ->
+    ?badarg_exit(call(Server, {recv, Length, Timeout})).
+
+
+%% -------------------------------------------------------------------------
+
+controlling_process(?MODULE_socket(Server, _Socket) = S, NewOwner)
+  when is_pid(NewOwner) ->
+    case call(Server, {controlling_process, NewOwner}) of
+        ok -> ok;
+        transfer -> controlling_process(S, NewOwner, Server);
+        {error, _} = Error -> Error
+    end.
+
+%%
+%% Helpers -------
+%%
+%% Transfer all queued socket messages to new owner
+controlling_process(S, NewOwner, Server) ->
+    receive
+        {udp, S, _Data} = Msg ->
+            controlling_process(S, NewOwner, Server, Msg);
+        {udp_closed, S} = Msg ->
+            controlling_process(S, NewOwner, Server, Msg);
+        {S, {data, _Data}} = Msg ->
+            controlling_process(S, NewOwner, Server, Msg)
+    after 0 ->
+            call(Server, controlling_process)
+    end.
+
+%% Loop
+controlling_process(S, NewOwner, Server, Msg) ->
+    NewOwner ! Msg,
+    controlling_process(S, NewOwner, Server).
+
+
+%% -------------------------------------------------------------------------
+%% Module inet backends
+%% -------------------------------------------------------------------------
+
+monitor(?MODULE_socket(_Server, ESock) = Socket) ->
+    %% The socket that is part of the down message:
+    case socket_registry:monitor(ESock, #{msocket => Socket}) of
+	{error, Reason} ->
+	    erlang:error({invalid, Reason});
+	MRef when is_reference(MRef) ->
+	    MRef
+    end;
+monitor(Socket) ->
+    erlang:error(badarg, [Socket]).
+
+cancel_monitor(MRef) when is_reference(MRef) ->
+    socket:cancel_monitor(MRef);
+cancel_monitor(MRef) ->
+    erlang:error(badarg, [MRef]).
+
+
+%% -------------------------------------------------------------------------
+
+setopts(?MODULE_socket(Server, _Socket), Opts) when is_list(Opts) ->
+    call(Server, {setopts, Opts}).
+
+
+%% -------------------------------------------------------------------------
+
+getopts(?MODULE_socket(Server, _Socket), Opts) when is_list(Opts) ->
+    call(Server, {getopts, Opts}).
+
+
+%% -------------------------------------------------------------------------
+
+sockname(?MODULE_socket(_Server, Socket)) ->
+    case socket:sockname(Socket) of
+        {ok, SockAddr} -> {ok, address(SockAddr)};
+        {error, _} = Error -> Error
+    end.
+
+
+%% -------------------------------------------------------------------------
+
+peername(?MODULE_socket(_Server, Socket)) ->
+    case socket:peername(Socket) of
+        {ok, SockAddr} -> {ok, address(SockAddr)};
+        {error, _} = Error -> Error
+    end.
+
+%% -------------------------------------------------------------------------
+
+getstat(?MODULE_socket(Server, _Socket), What) when is_list(What) ->
+    call(Server, {getstat, What}).
+
+
+%% -------------------------------------------------------------------------
+
+info(?MODULE_socket(Server, _Socket)) ->
+    call(Server, info).
+
+
+%% -------------------------------------------------------------------------
+
+socket_to_list(?MODULE_socket(_Server, Socket)) ->
+    "#Socket" ++ Id = socket:to_list(Socket),
+    "#InetSocket" ++ Id;
+socket_to_list(Socket) ->
+    erlang:error(badarg, [Socket]).
+
+
+which_sockets() ->
+    which_sockets(socket:which_sockets(udp)).
+
+which_sockets(Socks) ->
+    which_sockets(Socks, []).
+
+which_sockets([], Acc) ->
+    Acc;
+which_sockets([Sock|Socks], Acc) ->
+    case socket:getopt(Sock, {otp, meta}) of
+	{ok, undefined} ->
+	    which_sockets(Socks, Acc);
+	{ok, _Meta} ->
+	    %% One of ours - try to recreate the compat socket.
+	    %% Currently we don't have the 'owner' in meta,
+	    %% so we need to look it up...
+	    #{owner := Owner} = socket:info(Sock),
+	    MSock = ?MODULE_socket(Owner, Sock),
+	    which_sockets(Socks, [MSock|Acc]);
+	_ ->
+	    which_sockets(Socks, Acc)
+    end.
+
+
+%%% ========================================================================
+%%% Socket glue code
+%%%
+
+%% -compile({inline, [socket_recv_peek/2]}).
+%% socket_recv_peek(Socket, Length) ->
+%%     Options = [peek],
+%%     Result = socket:recv(Socket, Length, Options, nowait),
+%%     Result.
+
+%% -compile({inline, [socket_recv/2]}).
+%% socket_recv(Socket, Length) ->
+%%     socket:recv(Socket, Length, 0, nowait).
+
+-compile({inline, [socket_recvfrom/2]}).
+socket_recvfrom(Socket, Length) ->
+    socket:recvfrom(Socket, Length, nowait).
+
+-compile({inline, [socket_recvmsg/2]}).
+socket_recvmsg(Socket, Length) ->
+    socket:recvmsg(Socket, Length, 0, nowait).
+
+
+-compile({inline, [socket_send/2]}).
+socket_send(Socket, Data) ->
+    socket:send(Socket, Data).
+
+-compile({inline, [socket_sendto/3]}).
+socket_sendto(Socket, Dest, Data) ->
+    %% <OBSERVE>
+    %%
+    %% Argument swap!
+    %%
+    %% </OBSERVE>
+    %% socket:setopt(Socket, otp, debug, true),
+    Res = socket:sendto(Socket, Data, Dest),
+    %% socket:setopt(Socket, otp, debug, false),
+    Res.
+
+-compile({inline, [socket_sendmsg/2]}).
+socket_sendmsg(Socket, MsgHdr) ->
+    socket:send(Socket, MsgHdr).
+
+
+-compile({inline, [socket_close/1]}).
+socket_close(Socket) ->
+    %% XXX Should we set the meta option to closed here,
+    %% for the send operation to detect without calling
+    %% the NIF???
+    case socket:close(Socket) of
+        ok -> ok;
+        {error, closed} -> ok
+    end.
+
+
+-compile({inline, [socket_cancel/2]}).
+socket_cancel(Socket, SelectInfo) ->
+    case socket:cancel(Socket, SelectInfo) of
+        ok -> ok;
+        {error, closed} -> ok
+    end.
+
+
+
+%%% ========================================================================
+%%% API Helpers
+%%%
+
+%% Deep return helpers
+
+ok(_ErrRef, ok) -> ok;
+ok(ErrRef, {error, Reason}) -> throw({ErrRef, Reason}).
+
+val(_ErrRef, {ok, Val}) -> Val;
+val(ErrRef, {error, Reason}) -> throw({ErrRef, Reason}).
+
+
+-ifdef(undefined).
+chain([F | Fs], Fail) ->
+    chain(Fs, Fail, [], F()).
+%%
+chain([F | Fs], Fail, Values) ->
+    chain(Fs, Fail, Values, F(Values)).
+%%
+chain([], _Fail, _Values, Ret) -> Ret;
+chain(Fs, Fail, Values, Ret) ->
+    case Ret of
+        {error, _} -> Fail(Ret);
+        ok -> chain(Fs, Fail, Values);
+        {ok, Value} -> chain(Fs, Fail, [Value | Values])
+    end.
+-endif.
+
+%% -------------------------------------------------------------------------
+
+-compile({inline, [domain/1]}).
+domain(Mod) ->
+    case Mod of
+        inet_udp  -> inet;
+        inet6_udp -> inet6;
+        local_udp -> local
+    end.
+
+%% -------------------------------------------------------------------------
+
+%% sockaddr2addr(#{family := Family, addr := IP, port := Port})
+%%   when (Family =:= inet) orelse (Family =:= inet6) ->
+%%     {IP, Port};
+%% sockaddr2addr(#{family := local, path := Path}) ->
+%%     {local, Path}.
+
+address(SockAddr) ->
+    case SockAddr of
+        #{family := Family, addr := IP, port := Port}
+	when (Family =:= inet) orelse (Family =:= inet6) ->
+            {IP, Port};
+        #{family := local, path := Path} ->
+            {local, Path}
+    end.
+
+%% -------------------------------------------------------------------------
+
+%% sockaddrs([], _Port, _Domain) -> [];
+%% sockaddrs([{local, Path} | IPs], Port, Domain) when (Domain =:= local) ->
+%%     [#{family => Domain, path => Path}
+%%      | sockaddrs(IPs, Port, Domain)];
+%% sockaddrs([IP | IPs], Port, Domain) ->
+%%     [#{family => Domain, addr => IP, port => Port}
+%%      | sockaddrs(IPs, Port, Domain)].
+
+%% -------------------------------------------------------------------------
+
+setopts_split(FilterTags, Opts) ->
+    setopts_split(FilterTags, Opts, [], []).
+%%
+setopts_split(_FilterTags, [], True, False) ->
+    ?DBG(['done', {true, True}, {false, False}]),
+    {reverse(True), reverse(False)};
+setopts_split(FilterTags, [Opt | Opts], True, False) ->
+    ?DBG([{ftags, FilterTags}, {opt, Opt}]),
+    Opt_1 = conv_setopt(Opt),
+    case member(FilterTags, setopt_categories(Opt_1)) of
+        true ->
+            setopts_split(FilterTags, Opts, [Opt_1 | True], False);
+        false ->
+            setopts_split(FilterTags, Opts, True, [Opt_1 | False])
+    end.
+
+
+%% Set operation on atom sets that are atoms or maps with atom tags.
+%% Returns true if sets have at least one common member, false otherwise.
+%% X is atom() or map(), Y is map().
+member(X, Y) when is_atom(X) andalso is_map(Y) ->
+    case Y of
+        #{X := _} -> true;
+        #{} -> false
+    end;
+member(X, Y) when is_map(X) andalso is_map(Y) ->
+    maps:fold(
+      fun (_, _, true) -> true;
+          (Key, _, false) -> maps:is_key(Key, Y)
+      end, false, X).
+
+
+conv_setopt(binary) -> {mode, binary};
+conv_setopt(list)   -> {mode, list};
+conv_setopt(inet)   -> {udp_module, inet_udp};
+conv_setopt(inet6)  -> {udp_module, inet6_udp};
+conv_setopt(local)  -> {udp_module, local_udp};
+conv_setopt(Other)  -> Other.
+
+%% Socket options
+
+socket_setopt(Socket, {raw, Level, Key, Value}) ->
+    socket:setopt_native(Socket, {Level,Key}, Value);
+socket_setopt(Socket, {raw, {Level, Key, Value}}) ->
+    socket:setopt_native(Socket, {Level,Key}, Value);
+socket_setopt(Socket, {Tag, Value}) ->
+    ?DBG({Tag, Value}),
+    case socket_opt() of
+        #{Tag := {Domain, _} = Opt} when is_atom(Domain) ->
+            ?DBG(Opt),
+            socket:setopt(Socket, otp, debug, true),
+            Val = socket_setopt_value(Tag, Value),
+            ?DBG(Val),
+            Res = socket:setopt(Socket, Opt, Val),
+            ?DBG(Res),
+            socket:setopt(Socket, otp, debug, false),
+            Res;
+
+        #{Tag := DomainProps} when is_list(DomainProps) ->
+            %% We need to lookup the domain of the socket,
+            %% so we can select which one to use.                            
+            ?DBG(DomainProps),
+            case socket:getopt(Socket, otp, domain) of
+                {ok, Domain} ->
+                    case lists:keysearch(Domain, 1, DomainProps) of
+                        {value, {Domain, Level, OptKey}} ->
+                            Opt = {Level, OptKey},
+                            _ = socket:setopt(Socket, otp, debug, true),
+                            Res = socket:setopt(Socket,
+                                                Opt,
+                                                socket_setopt_value(Tag,
+                                                                    Value)),
+                            _ = socket:setopt(Socket, otp, debug, false),
+                            Res;
+                        false ->
+                            {error, einval}
+                    end;
+                {error, _} ->
+                    {error, einval}
+            end;
+
+        #{} ->
+            {error, einval}
+    end.
+
+%% socket_setopt_value(linger, {OnOff, Linger}) ->
+%%     #{onoff => OnOff, linger => Linger};
+socket_setopt_value(_Tag, Value) -> Value.
+
+socket_getopt(Socket, {raw, Level, Key, ValueSpec}) ->
+    socket:getopt_native(Socket, {Level,Key}, ValueSpec);
+socket_getopt(Socket, {raw, {Level, Key, ValueSpec}}) ->
+    socket:getopt_native(Socket, {Level,Key}, ValueSpec);
+socket_getopt(Socket, Tag) when is_atom(Tag) ->
+    case socket_opt() of
+        #{Tag := {Domain, _} = Opt} when is_atom(Domain) ->
+            ?DBG({'socket_getopt - match', Tag}),
+            %% _ = socket:setopt(Socket, otp, debug, true),
+            Res = socket:getopt(Socket, Opt),
+            ?DBG({'socket_getopt - result', Res}),
+            %% _ = socket:setopt(Socket, otp, debug, false),
+            socket_getopt_value(Tag, Res);
+
+        #{Tag := DomainProps} when is_list(DomainProps) ->
+            %% We need to lookup the domain of the socket,
+            %% so we can select which one to use.                            
+            ?DBG({'socket_getopt - match', Tag, DomainProps}),
+            case socket:getopt(Socket, otp, domain) of
+                {ok, Domain} ->
+                    ?DBG({'socket_getopt - domain', Tag, Domain}),
+                    case lists:keysearch(Domain, 1, DomainProps) of
+                        {value, {Domain, Level, OptKey}} ->
+                            ?DBG({'socket_getopt - ok domain', Tag, Level, OptKey}),
+                            Opt  = {Level, OptKey},
+                            %% _ = socket:setopt(Socket, otp, debug, true),
+                            Res = socket:getopt(Socket, Opt),
+                            %% _ = socket:setopt(Socket, otp, debug, false),
+                            ?DBG({'socket_getopt - result', Res}),
+                            socket_getopt_value(Tag, Res);
+                        false ->
+                            ?DBG({'socket_getopt - invalid domain', Tag, Domain, DomainProps}),
+                            {error, einval}
+                    end;
+                {error, _DReason} ->
+                    ?DBG({'socket_getopt - unknown domain', Tag, _DReason}),
+                    {error, einval}
+            end;
+
+        #{} = __X__ ->
+            ?DBG({'socket_getopt - no match - 2', Tag, __X__}),
+            {error, einval}
+    end.
+
+%% socket_getopt_value(linger, {ok, #{onoff := OnOff, linger := Linger}}) ->
+%%     {ok, {OnOff, Linger}};
+%% socket_getopt_value(pktoptions, {ok, PktOpts0}) when is_list(PktOpts0) ->
+%%     PktOpts = [{Type, Value} || #{type := Type, value := Value} <- PktOpts0],
+%%     {ok, PktOpts};
+socket_getopt_value(_Tag, {ok, _Value} = Ok) -> Ok;
+socket_getopt_value(_Tag, {error, _} = Error) -> Error.
+
+%% socket_copy_opt(Socket, Tag, TargetSocket) when is_atom(Tag) ->
+%%     case socket_opt() of
+%%         #{Tag := Opt} ->
+%% 	    case socket:is_supported(options, Opt) of
+%% 		true ->
+%% 		    case socket:getopt(Socket, Opt) of
+%% 			{ok, Value} ->
+%% 			    socket:setopt(TargetSocket, Opt, Value);
+%% 			{error, _Reason} = Error ->
+%% 			    Error
+%% 		    end;
+%% 		false ->
+%% 		    ok
+%% 	    end;
+%%         #{} = _X ->
+%% 	    {error, einval}
+%%     end.
+
+start_opts([{sys_debug, D} | Opts]) ->
+    [{debug, D} | start_opts(Opts)];
+start_opts([Opt | Opts]) ->
+    [Opt | start_opts(Opts)];
+start_opts([]) -> [].
+
+
+%% Categories: socket, ignore, start, server_read, server_write, einval
+%% returns a maps set
+
+setopt_categories(Opt) ->
+    case Opt of
+        {raw, _, _, _}   -> #{socket => []};
+        {raw, {_, _, _}} -> #{socket => []};
+        {Tag, _}         -> opt_categories(Tag);
+        _                -> ignore
+    end.
+
+getopt_categories(Opt) ->
+    case Opt of
+        {raw, _, _, _}   -> #{socket => []};
+        {raw, {_, _, _}} -> #{socket => []};
+        _                -> opt_categories(Opt)
+    end.
+
+%% setopt and getopt category
+opt_categories(Tag) when is_atom(Tag) ->
+    case Tag of
+        sys_debug -> #{start => []};
+        debug     -> #{socket => [], start => []};
+
+        %% Some options may trigger us to choose recvmsg (instead of recvfrom)
+        %% Or trigger us to choose recvfrom *if* was previously selected
+        
+        _ when (Tag =:= recvtos) orelse
+               (Tag =:= recvttl) orelse
+               (Tag =:= recvtclass) ->
+            #{socket => [], recv_method => []};
+
+        _ ->
+            case maps:is_key(Tag, socket_opt()) of
+                true -> #{socket => []};
+                false ->
+                    case maps:is_key(Tag, ignore_opt()) of
+                        true ->
+                            #{ignore => []};
+                        false ->
+                            maps:merge(
+                              case maps:is_key(Tag, server_read_opts()) of
+                                  true ->
+                                      #{server_read => []};
+                                  false ->
+                                      #{}
+                              end,
+                              case maps:is_key(Tag, server_write_opts()) of
+                                  true ->
+                                      #{server_write => []};
+                                  false ->
+                                      #{}
+                              end)
+                    end
+            end
+    end.
+
+-compile({inline, [ignore_opt/0]}).
+ignore_opt() ->
+    #{
+      %% Handled by inet:udp_module/2
+      udp_module => [],
+      %% Handled by inet:udp_options/2
+      ip => [],
+      %% XXX Some of these must probably be handled one day...
+      %% These are options for the 'port', which we don't have, so...
+      high_msgq_watermark => [],
+      low_msgq_watermark  => []
+     }.
+
+%% Category 'socket'
+%%
+%% Translation to 'level' and 'opt'
+-compile({inline, [socket_opt/0]}).
+%% What about: read_packets
+socket_opt() ->
+    #{
+      %% Level: otp
+      buffer => {otp, rcvbuf},
+      debug  => {otp, debug},
+      fd     => {otp, fd},
+
+      %%
+      %% Level: socket
+      broadcast      => {socket, broadcast},
+      bind_to_device => {socket, bindtodevice},
+      dontroute      => {socket, dontroute},
+      keepalive      => {socket, keepalive},
+      %% linger         => {socket, linger},
+      %% low_watermark  => {socket, rcvlowat},
+      priority       => {socket, priority},
+      recbuf         => {socket, rcvbuf},
+      reuseaddr      => {socket, reuseaddr},
+      sndbuf         => {socket, sndbuf},
+
+      %%
+      %% Level: udp
+      %% nodelay => {udp, nodelay},
+
+      %%
+      %% Level: ip
+      recvtos         => {ip, recvtos},
+      recvttl         => {ip, recvttl},
+      tos             => {ip, tos},
+      ttl             => {ip, ttl},
+      add_membership  => {ip, add_membership},
+      drop_membership => {ip, drop_membership},
+      multicast_if    => {ip, multicast_if},
+      multicast_ttl   => {ip, multicast_ttl},
+      multicast_loop  => {ip, multicast_loop},
+
+      %%
+      %% Level: ipv6
+      recvtclass  => {ipv6, recvtclass},
+      ipv6_v6only => {ipv6, v6only},
+      tclass      => {ipv6, tclass}
+
+      %%
+      %% Special cases
+      %% These are options that cannot be mapped as above,
+      %% as they, for instance, "belong to" several domains.
+      %% So, we select which level to use based on the domain
+      %% of the socket.
+
+      %% This is a special case.
+      %% Only supported on Linux and then only actually for IPv6,
+      %% but unofficially also for ip...barf...
+      %% In both cases this is *no longer valid* as the RFC which 
+      %% introduced this, RFC 2292, is *obsoleted* by RFC 3542, where
+      %% this "feature" *does not exist*...
+      %%pktoptions  => [{inet, ip, pktoptions}, {inet6, ipv6, pktoptions}]
+      }.
+
+%% -compile({inline, [socket_inherit_opts/0]}).
+%% socket_inherit_opts() ->
+%%     [priority].
+
+-compile({inline, [server_read_write_opts/0]}).
+server_read_write_opts() ->
+    %% Common for read and write side
+    %% mod is unknown at this time, but will be properly "initiated"
+    %% before 'meta' is written...
+    #{mod => undefined}.
+-compile({inline, [server_read_opts/0]}).
+server_read_opts() ->
+    %% Read side only opts
+    maps:merge(
+      #{active => false, % inet_drv also has this default
+        mode => list,
+        header => 0,
+        deliver => term,
+	read_packets => 5, %% WHAT DO WE DO ABOUT THIS!!!
+        start_opts => [], % Just to make it settable
+        %% XXX not implemented yet
+        exit_on_close => true},
+      server_read_write_opts()).
+-compile({inline, [server_write_opts/0]}).
+server_write_opts() ->
+    %% Write side only opts
+    maps:merge(#{}, server_read_write_opts()).
+%% Category 'server'
+%%
+%% Default values
+-compile({inline, [server_opts/0]}).
+server_opts() ->
+    maps:merge(server_read_opts(), server_write_opts()).
+
+-compile({inline, [meta/1]}).
+meta(D) -> maps:with(maps:keys(server_write_opts()), D).
+
+
+%%% ========================================================================
+%%% State Machine
+%%%
+
+%% State Machine Engine Call Interface
+
+%% Start for open - create a socket
+start_server(Mod, Domain, StartOpts, ExtraOpts) ->
+    Owner = self(),
+    Arg   = {Mod, Domain, ExtraOpts, Owner},
+    case gen_statem:start(?MODULE, Arg, StartOpts) of
+        {ok, _} = OK                -> OK;
+        {error, {shutdown, Reason}} -> {error, Reason};
+        {error, _} = Error          -> Error
+    end.
+
+
+call(Server, Call) ->
+    try gen_statem:call(Server, Call)
+    catch exit:{noproc, {gen_statem, call, _Args}} -> {error, closed}
+    end.
+
+stop_server(Server) ->
+    try gen_statem:stop(Server) of
+        _ -> ok
+    catch
+        _:_ -> ok
+    end.
+
+%% reply(From, Reply) ->
+%%     gen_statem:reply(From, Reply).
+
+%% -------------------------------------------------------------------------
+%% Statem Machine Engine Callbacks
+
+callback_mode() -> handle_event_function.
+
+%% States:
+
+%% 'controlling_process'
+%% A super state that encapsulates any other state and
+%% postpones all events but get_socket, get_server_opts/0
+%% and Owner 'DOWN'.
+%% Handling of controlling_process is divided up into two
+%% parts. One part is handled by the state machine and the
+%% other by the function controlling_process/2.
+-record(controlling_process,
+        {owner :: pid(),
+         state :: term()}).
+
+
+%% 'open'
+
+%% 'reading'
+-record(recv,
+        {info :: socket:select_info()}).
+
+%% 'closed_read' | 'closed_read_write'
+%% 'closed' % Socket is closed or not created
+
+-record(params,
+        {socket        :: undefined | socket:socket(),
+         owner         :: pid(),
+         owner_mon     :: reference(),
+         %% This comes from the options recvtos | recvttl | recvtclass
+         %% If any of them are set then the method will change to msg
+         %%    RecvMethod =:= [] => recvfrom
+         %%    RecvMethod =/= [] => recvmsg
+         recv_method = []}).
+
+
+init({Mod, Domain, ExtraOpts, Owner}) ->
+
+    ?DBG([{init, open},
+          {domain, Domain}, {extraopts, ExtraOpts}, {owner, Owner}]),
+
+    process_flag(trap_exit, true),
+    OwnerMon  = erlang:monitor(process, Owner),
+    Proto     = if (Domain =:= local) -> default; true -> udp end,
+    Extra     = #{}, % #{debug => true},
+    case socket_open(Domain, Proto, ExtraOpts, Extra) of
+        {ok, Socket} ->
+            D0  = server_opts(),
+            D   = D0#{mod => Mod},
+            ok = socket:setopt(Socket, {otp,iow},  true),
+            ok = socket:setopt(Socket, {otp,meta}, meta(D)),
+            P  = #params{socket    = Socket,
+                         owner     = Owner,
+                         owner_mon = OwnerMon},
+            State = open,
+            Data  = {P, D},
+            {ok, State, Data};
+        {error, Reason} ->
+	    %% ?DBG({open_failed, Reason}),
+	    {stop, {shutdown, Reason}}
+    end;
+init(Arg) ->
+    error_logger:error_report([{badarg, {?MODULE, init, [Arg]}}]),
+    error(badarg, [Arg]).
+
+
+socket_open(Domain, Proto, #{fd := FD} = ExtraOpts, Extra) ->
+    Opts =
+        (maps:merge(Extra, maps:remove(fd, ExtraOpts)))
+        #{dup      => false,
+          domain   => Domain,
+          type     => dgram,
+          protocol => Proto},
+    ?DBG([{fd, FD}, {opts, Opts}]),
+    case socket:open(FD, Opts) of
+        {ok, Socket} = OK ->
+            case socket:info(Socket) of
+                #{ctype    := fromfd,
+                  domain   := Domain,
+                  type     := dgram,
+                  protocol := Proto} ->
+                    OK;
+                _ ->
+                    (catch socket:close(Socket)),
+                    {error, einval}
+            end;
+        {error, _} = ERROR ->
+            ERROR
+    end;
+socket_open(Domain, Proto, ExtraOpts, Extra) ->
+    Opts = maps:merge(Extra, ExtraOpts),
+    socket:open(Domain, dgram, Proto, Opts).
+
+
+terminate(_Reason, State, {_P, _} = P_D) ->
+    %% ?DBG({_P#params.socket, State, _Reason}),
+    case State of
+        #controlling_process{state = OldState} ->
+            terminate(OldState, P_D);
+        _ ->
+            terminate(State, P_D)
+    end.
+%%
+terminate(State, {#params{socket = Socket} = P, D}) ->
+    ?DBG(['terminate', {socket, Socket}, {state, State}]),
+    case State of
+        'closed' ->
+	    ok;
+        'closed_read' ->
+            _ = socket_close(Socket),
+            ok;
+        'closed_read_write' ->
+            _ = socket_close(Socket),
+            ok;
+        _ ->
+	    _ = socket_close(Socket),
+            {_D_1, ActionsR} =
+                case State of
+                    #controlling_process{state = OldState} ->
+                        cleanup_close_read(P, D, OldState, closed);
+                    _ ->
+                        cleanup_close_read(P, D, State, closed)
+                end,
+            [gen_statem:reply(Reply)
+             || {reply, _From, _Msg} = Reply <- reverse(ActionsR)],
+            ok
+    end,
+    void.
+
+
+%% -------------------------------------------------------------------------
+%% Helpers
+
+%% Construct a "socket" as in this module's API
+module_socket(#params{socket = Socket}) ->
+    ?MODULE_socket(self(), Socket).
+
+
+%% -------------------------------------------------------------------------
+%% Event Handler (callback)
+
+%% Any state:
+
+%% Call: get_socket/0 - internal
+handle_event({call, From}, get_socket, _State,
+             {#params{socket = Socket}, _D}) ->
+    {keep_state_and_data,
+     [{reply, From, {ok, Socket}}]};
+
+%% Call: get_server_opts/0
+handle_event({call, From}, get_server_opts, _State, {_P, D}) ->
+    ServerOpts = maps:with(maps:keys(server_opts()), D),
+    {keep_state_and_data,
+     [{reply, From, {ok, ServerOpts}}]};
+
+%% Event: Owner 'DOWN'
+handle_event(info,
+	     {'DOWN', OwnerMon, _, _, Reason} = DOWN,
+	     _State,
+	     {#params{owner_mon = OwnerMon} = _P, _D} = P_D) ->
+    ?DBG([{event, info}, {down, DOWN}, {state, _State}]),
+    {stop, {shutdown, Reason}, P_D};
+
+%% Event: ?socket_counter_wrap/2
+handle_event(info,
+	     ?socket_counter_wrap(Socket, Counter),
+	     'open' = _State,
+	     {#params{socket = Socket} = P, D}) ->
+    ?DBG([{state, _State}, {counter, Counter}]),
+    {keep_state, {P, wrap_counter(Counter, D)}};
+
+handle_event(info,
+	     ?socket_counter_wrap(Socket, Counter),
+	     #recv{} = _State,
+	     {#params{socket = Socket} = P, D}) ->
+    ?DBG([{state, _State}, {counter, Counter}]),
+    {keep_state, {P, wrap_counter(Counter, D)}};
+
+handle_event(info,
+	     ?socket_counter_wrap(_Socket, _Counter),
+	     _State,
+	     _P_D) ->
+    ?DBG([{state, _State}, {counter, _Counter}]),
+    {keep_state_and_data, [postpone]};
+
+%% Call: controlling_process/1
+handle_event({call, {Caller, _} = From},
+	     {controlling_process, NewOwner},
+	     State,
+	     {P, _D} = P_D) ->
+    case P of
+        #params{owner = NewOwner} ->
+            {keep_state_and_data,
+             [{reply, From, ok}]};
+        #params{owner = Caller} ->
+            {next_state,
+             #controlling_process{owner = NewOwner, state = State},
+             P_D,
+             [{reply, From, transfer}]};
+        #params{} ->
+            {keep_state_and_data,
+             [{reply, From, {error, not_owner}}]}
+    end;
+
+%%
+%% State: #controlling_process{}
+%%
+%% Call: controlling_process/0
+handle_event({call, {Owner, _} = From},
+	     controlling_process,
+	     #controlling_process{owner = NewOwner, state = State},
+	     {#params{owner = Owner, owner_mon = OwnerMon} = P, D}) ->
+    NewOwnerMon = erlang:monitor(process, NewOwner),
+    true = erlang:demonitor(OwnerMon, [flush]),
+    {next_state, State,
+     {P#params{owner = NewOwner, owner_mon = NewOwnerMon}, D},
+     [{reply, From, ok}]};
+
+%%
+%% Postpone all events but the ones above controlling_process/1
+%% until the controlling process has been changed
+handle_event(_Type,
+	     _Content,
+	     #controlling_process{},
+	     _StateData) ->
+    {keep_state_and_data, [postpone]};
+%% Handled state: #controlling_process{}
+
+%% Call: close/0
+handle_event({call, From},
+	     close,
+	     State,
+	     {P, D} = P_D) ->
+    ?DBG([{socket, P#params.socket}, {state, State}]),
+    case State of
+        'closed_read' ->
+            {next_state, 'closed', P_D,
+             [{reply, From, socket_close(P#params.socket)}]};
+        'closed_read_write' ->
+            {next_state, 'closed', P_D,
+             [{reply, From, socket_close(P#params.socket)}]};
+        'closed' ->
+            {keep_state_and_data,
+             [{reply, From, ok}]};
+        _ ->
+            next_state(P,
+		       cleanup_close_read(P,
+					  D#{active := false},
+					  State,
+					  closed),
+		       'closed',
+		       [{reply, From, socket_close(P#params.socket)}])
+    end;
+
+%% Call: getopts/1
+handle_event({call, From},
+	     {getopts, Opts},
+	     State,
+	     {P, D}) ->
+    ?DBG({call, getopts, Opts, State, D}),
+    Result = state_getopts(P, D, State, Opts),
+    ?DBG({call, getopts_result, Result}),
+    {keep_state_and_data,
+     [{reply, From, Result}]};
+
+%% Call: setopts/1
+handle_event({call, From},
+	     {setopts, Opts},
+	     State,
+	     {P, D}) ->
+    ?DBG([{setopts, Opts}, {state, State}, {d, D}]),
+    {Result, {P_1, D_1}} = state_setopts(P, D, State, Opts),
+    ?DBG([{result, Result}, {p1, P_1}, {d1, D_1}]),
+    case Result of
+	{error, einval} ->
+	    %% If we get this error, either the options where crap or
+	    %% the socket is in a "bad state" (maybe its closed).
+	    %% So, if that is the case we accept that we may not be
+	    %% able to update the meta data.
+	    _ = socket:setopt(P_1#params.socket, {otp,meta}, meta(D_1)),
+	    ok;
+	_ ->
+	    %% We should really handle this better. stop_and_reply?
+	    ok = socket:setopt(P_1#params.socket, {otp,meta}, meta(D_1))
+    end,
+    Reply = {reply, From, Result},
+    case State of
+        'open' ->
+            handle_reading(P_1, D_1, [Reply]);
+        _ ->
+            {keep_state, {P_1, D_1}, [Reply]}
+    end;
+    
+
+
+%% Call: getstat/2
+handle_event({call, From},
+	     {getstat, What},
+	     State,
+	     {P, D}) ->
+    case State of
+        'closed' ->
+            {keep_state_and_data, [{reply, From, {error, closed}}]};
+        _ ->
+            {D_1, Result} = getstat(P#params.socket, D, What),
+            {keep_state, {P, D_1}, [{reply, From, {ok, Result}}]}
+    end;
+
+%% Call: info/1
+handle_event({call, From},
+	     info,
+	     State,
+	     {P, D}) ->
+    case State of
+        'closed' ->
+            {keep_state_and_data, [{reply, From, #{}}]};
+        _ ->
+            {D_1, Result} = handle_info(P#params.socket, P#params.owner, D),
+            {keep_state, {P, D_1}, [{reply, From, Result}]}
+    end;
+
+%% State: 'closed' - what is not handled above
+handle_event(Type, Content, 'closed' = State, P_D) ->
+    handle_closed(Type, Content, State, P_D);
+%% Handled state: 'closed'
+
+%% Call: shutdown/1
+handle_event({call, From}, {shutdown, How} = _SHUTDOWN, State, {P, D}) ->
+    ?DBG({P#params.socket, _SHUTDOWN, State}),
+    case State of
+        'closed_read' when (How =:= read) ->
+            ?DBG('already closed-read'),
+            {keep_state_and_data, [{reply, From, ok}]};
+        'closed_read_write' when (How =:= read_write) ->
+            ?DBG('already closed-read-write'),
+            {keep_state_and_data, [{reply, From, ok}]};
+        _ ->
+            ?DBG({'handle shutdown', How, State}),
+            case handle_shutdown(P, State, How) of
+                {keep, SRes} ->
+                    ?DBG({'shutdown result', SRes, keep}),
+                    {keep_state_and_data, [{reply, From, SRes}]};
+                {NextState, SRes} ->
+                    ?DBG({P#params.socket, 'shutdown result', SRes, NextState}),
+                    next_state(P,
+			       cleanup_close_read(P,
+						  D#{active := false},
+						  State,
+						  closed),
+			       NextState,
+			       [{reply, From, SRes}])
+            end
+    end;
+
+%% State: 'closed_read' | 'closed_read_write' - what is not handled in
+%%        close/0 and shutdown/1 above
+handle_event(Type, Content, State, P_D)
+  when (State =:= 'closed_read') orelse (State =:= 'closed_read_write') ->
+    handle_closed(Type, Content, State, P_D);
+
+
+%% ------- Socket is defined from here on -----------------------------------
+
+%% Call: bind/1
+handle_event({call, From}, {bind, BindAddr} = _BIND, _State, {P, _D}) ->
+    ?DBG(['try bind',
+          {handle_event, call}, {bind_addr, BindAddr}, {state, _State}]),
+    Result = socket:bind(P#params.socket, BindAddr),
+    ?DBG([{bind_result, Result}]),
+    {keep_state_and_data, [{reply, From, Result}]};
+
+
+%% Call: recv/2,3 - active socket
+handle_event({call, From},
+	     {recv, _Length, _Timeout},
+	     _State,
+	     {_P, #{active := Active} = _D})
+  when (Active =/= false) ->
+    {keep_state_and_data, [{reply, From, {error, einval}}]};
+
+
+%% 'open' | #recv{}
+
+%% Call: recv/2,3
+handle_event(
+  {call, From}, {recv, Length, Timeout}, State, {P, D}) ->
+    ?DBG([recv, {length, Length}, {timeout, Timeout}, {state, State}]),
+    case State of
+        'open' -> % idle
+            handle_recv_start(P, D, From, Length, Timeout);
+        #recv{} ->
+            %% Receive already in progress
+            {keep_state_and_data, [postpone]}
+    end;
+
+%% State: #recv{}
+%%
+%% Handle select done - try recv again
+handle_event(
+  info, ?socket_select(Socket, SelectRef),
+  #recv{info = ?select_info(SelectRef)},
+  {#params{socket = Socket} = P, D}) ->
+    %%
+    %% ?DBG([info, {socket, Socket}, {ref, SelectRef}]),
+    handle_recv(P, D, []);
+
+%%
+handle_event(
+  info, ?socket_abort(Socket, SelectRef, Reason),
+  #recv{info = ?select_info(SelectRef)},
+  {#params{socket = Socket} = P, D}) ->
+    %%
+    %% ?DBG({abort, Reason}),
+    handle_reading(P, cleanup_recv_reply(P, D, [], Reason));
+
+%%
+%% Timeout on recv in non-active mode
+handle_event(
+  {timeout, recv}, recv, #recv{} = State, {P, D}) ->
+    %%
+    %% ?DBG({timeout, recv}),
+    handle_reading(P, cleanup_recv(P, D, State, timeout));
+
+%% Catch-all
+handle_event(Type, Content, State, P_D) ->
+    handle_unexpected(Type, Content, State, P_D).
+
+%% End of event handler
+%% -------------------------------------------------------------------------
+%% Event handler helpers
+
+
+%% We only accept/perform shutdown when socket is 'connected'.
+%% This is done to be "compatible" with the inet-driver!
+
+handle_shutdown(#params{socket = Socket},
+                connected = _State,
+                write = How) ->
+    {keep, socket:shutdown(Socket, How)};
+handle_shutdown(#params{socket = Socket},
+                #recv{} = _State,
+                write = How) ->
+    {keep, socket:shutdown(Socket, How)};
+handle_shutdown(#params{socket = Socket},
+                connected = _State,
+                read = How) ->
+    handle_shutdown2(Socket, closed_read, How);
+handle_shutdown(#params{socket = Socket},
+                #recv{} = _State,
+                read = How) ->
+    handle_shutdown2(Socket, closed_read, How);
+handle_shutdown(#params{socket = Socket},
+                connected = _State,
+                read_write = How) ->
+    handle_shutdown2(Socket, closed_read_write, How);
+handle_shutdown(#params{socket = Socket},
+                #recv{} = _State,
+                read_write = How) ->
+    handle_shutdown2(Socket, closed_read_write, How);
+handle_shutdown(_Params, _State, _How) ->
+    {keep, {error, enotconn}}.
+
+handle_shutdown2(Socket, NextState, How) ->
+    case socket:shutdown(Socket, How) of
+        ok ->
+            {NextState, ok};
+        Error ->
+            {keep, Error}
+    end.
+
+
+handle_unexpected(Type, Content, State, {P, _D}) ->
+    error_logger:warning_report(
+      [{module, ?MODULE}, {socket, P#params.socket},
+       {unknown_event, {Type, Content}}, {state, State}]),
+    case Type of
+        {call, From} ->
+            {keep_state_and_data,
+             [{reply, From, {error, einval}}]};
+        _ ->
+            keep_state_and_data
+    end.
+
+handle_closed(Type, Content, State, {P, _D}) ->
+    case Type of
+        {call, From} ->
+            {keep_state_and_data,
+             [{reply, From, {error, closed}}]};
+        _ ->
+            error_logger:warning_report(
+              [{module, ?MODULE}, {socket, P#params.socket},
+               {unknown_event, {Type, Content}}, {state, State}]),
+            keep_state_and_data
+    end.
+
+%% State transition helpers -------
+
+%% handle_connect(
+%%   #params{socket = Socket} = P, D, From, Addr, Timeout) ->
+%%     %%
+%%     %% ?DBG([{d, D}, {addr, Addr}]),
+%%     case socket:connect(Socket, Addr, nowait) of
+%%         ok ->
+%%             handle_connected(
+%%               P, D#{type => connect},
+%%               [{{timeout, connect}, cancel},
+%%                {reply, From, {ok, Socket}}]);
+%%         {select, ?select_info(_) = SelectInfo} ->
+%%             {next_state,
+%%              #connect{info = SelectInfo, from = From, addr = Addr},
+%%              {P, D#{type => connect}},
+%%              [{{timeout, connect}, Timeout, connect}]};
+%%         {error, _} = Error ->
+%%             {next_state,
+%%              'connect', {P, D},
+%%              [{{timeout, connect}, cancel},
+%%               {reply, From, Error}]}
+%%     end.
+
+%% handle_accept(P, D, From, ListenSocket, Timeout) ->
+%%     %% ?DBG({try_accept, D}),
+%%     case socket:accept(ListenSocket, nowait) of
+%%         {ok, Socket} ->
+%%             %% ?DBG(accept_success),
+%%             ok = socket:setopt(Socket, {otp,iow}, true),
+%%             ok = socket:setopt(Socket, {otp,meta}, meta(D)),
+%%             [ok = socket_copy_opt(ListenSocket, Opt, Socket)
+%%              || Opt <- socket_inherit_opts()],
+%%             handle_connected(
+%%               P#params{socket = Socket}, D#{type => accept},
+%%               [{{timeout, accept}, cancel},
+%%                {reply, From, {ok, Socket}}]);
+%%         {select, ?select_info(_) = SelectInfo} ->
+%%             %% ?DBG({accept_select, SelectInfo}),
+%%             {next_state,
+%%              #accept{
+%%                 info = SelectInfo, from = From,
+%%                 listen_socket = ListenSocket},
+%%              {P, D#{type => accept}},
+%%              [{{timeout, accept}, Timeout, accept}]};
+%%         {error, _Reason} = Error ->
+%%             %% ?DBG({accept_failure, _Reason}),
+%%             {next_state,
+%%              'accept', {P, D},
+%%              [{{timeout, accept}, cancel},
+%%               {reply, From, Error}]}
+%%     end.
+
+handle_reading(P, {D, ActionsR}) ->
+    handle_reading(P, D, ActionsR).
+
+handle_reading(P, D, ActionsR) ->
+    %% ?DBG([{p, P}, {d, D}, {actions_r, ActionsR}]),
+    case D of
+        #{active := false} ->
+            {next_state, 'open', {P, D}, reverse(ActionsR)};
+        #{active := _} ->
+            handle_recv(P, recv_start(D), ActionsR)
+    end.
+
+handle_recv_start(P, D, From, Length, Timeout) ->
+    handle_recv(P,
+                D#{recv_length => Length, recv_from => From},
+                [{{timeout, recv}, Timeout, recv}]).
+
+%% handle_recv(P, #{recv_length := Length} = D, ActionsR) ->
+%%     if
+%%         0 < Length ->
+%%             handle_recv_length(P, D, ActionsR, Length);
+%%         true ->
+%%             handle_recv_packet(P, D, ActionsR)
+%%     end.
+handle_recv(#params{socket = Socket, recv_method = []} = P,
+            #{recv_length := Length} = D, ActionsR) ->
+    case socket_recvfrom(Socket, Length) of
+        {ok, {Source, <<Data/binary>>}} ->
+            handle_recv_deliver(P, D, ActionsR, {Source, Data});
+        {select, ?select_info(_) = SelectInfo} ->
+            {next_state,
+             #recv{info = SelectInfo},
+             {P, D},
+             reverse(ActionsR)};
+        {error, Reason} ->
+            %% ?DBG({'recv error wo rest-data', Reason}),
+            handle_recv_error(P, D, ActionsR, Reason)
+    end;
+handle_recv(#params{socket = Socket} = P,
+            #{recv_length := Length} = D, ActionsR) ->
+    case socket_recvmsg(Socket, Length) of
+        {ok, MsgHdr} ->
+            handle_recv_deliver(P, D, ActionsR, MsgHdr);
+        {select, ?select_info(_) = SelectInfo} ->
+            {next_state,
+             #recv{info = SelectInfo},
+             {P, D},
+             reverse(ActionsR)};
+        {error, Reason} ->
+            %% ?DBG({'recv error wo rest-data', Reason}),
+            handle_recv_error(P, D, ActionsR, Reason)
+    end.
+
+%% handle_recv_peek(P, D, ActionsR, Packet) ->
+%%     %% Peek Packet bytes
+%%     %% ?DBG({packet, Packet}),
+%%     case D of
+%%         #{buffer := Buffer} when is_list(Buffer) ->
+%% 	    %% ?DBG('buffer is list - condence'),
+%%             Data = condense_buffer(Buffer),
+%%             handle_recv_peek(P, D#{buffer := Data}, ActionsR, Packet);
+%%         #{buffer := <<Data:Packet/binary, _Rest/binary>>} ->
+%% 	    %% ?DBG('buffer contains header'),
+%%             handle_recv_peek(P, D, ActionsR, Packet, Data);
+%%         #{buffer := <<ShortData/binary>>} ->
+%%             N = Packet - byte_size(ShortData),
+%% 	    %% ?DBG({'buffer does not contain complete header',
+%% 	    %% 	  Packet, N, byte_size(ShortData)}),
+%%             case socket_recv_peek(P#params.socket, N) of
+%%                 {ok, <<FinalData/binary>>} ->
+%%                     handle_recv_peek(
+%%                       P, D, ActionsR, Packet,
+%%                       <<ShortData/binary, FinalData/binary>>);
+%%                 {select, Select} ->
+%%                     {next_state,
+%%                      #recv{
+%%                         info =
+%%                             case Select of
+%%                                 {?select_info(_) = SelectInfo, _Data} ->
+%%                                     SelectInfo;
+%%                                 ?select_info(_) = SelectInfo ->
+%%                                     SelectInfo
+%%                             end},
+%%                      {P, D},
+%%                      reverse(ActionsR)};
+%%                 {error, {Reason, <<_Data/binary>>}} ->
+%%                     handle_recv_error(P, D, ActionsR, Reason);
+%%                 {error, Reason} ->
+%%                     handle_recv_error(P, D, ActionsR, Reason)
+%%             end
+%%     end.
+
+%% handle_recv_peek(P, D, ActionsR, Packet, Data) ->
+%%     <<?header(Packet, N)>> = Data,
+%%     #{packet_size := PacketSize} = D,
+%%     %% ?DBG({'packet size', Packet, N, PacketSize}),
+%%     if
+%%         0 < PacketSize, PacketSize < N ->
+%% 	    %% ?DBG({emsgsize}),
+%%             handle_recv_error(P, D, ActionsR, emsgsize);
+%%         true ->
+%% 	    %% ?DBG({'read a message'}),
+%%             handle_recv_length(P, D, ActionsR, Packet + N)
+%%     end.
+
+%% handle_recv_packet(P, D, ActionsR) ->
+%%     case D of
+%%         #{buffer := Buffer} when is_list(Buffer) ->
+%%             Data = condense_buffer(Buffer),
+%%             handle_recv_decode(P, D, ActionsR, Data);
+%%         #{buffer := Data} when is_binary(Data) ->
+%%             handle_recv_more(P, D, ActionsR, Data)
+%%     end.
+
+%% handle_recv_length(#params{socket = Socket, recv_method = []} = P,
+%%                    D, ActionsR, Length) ->
+%%     case socket_recvfrom(Socket, Length) of
+%%         {ok, {Source, <<Data/binary>>}} ->
+%%             handle_recv_deliver(P, D, ActionsR, {Source, Data});
+%%         {select, ?select_info(_) = SelectInfo} ->
+%%             {next_state,
+%%              #recv{info = SelectInfo},
+%%              {P, D},
+%%              reverse(ActionsR)};
+%%         {error, Reason} ->
+%%             %% ?DBG({'recv error wo rest-data', Reason}),
+%%             handle_recv_error(P, D, ActionsR, Reason)
+%%     end;
+%% handle_recv_length(#params{socket = Socket} = P,
+%%                    D, ActionsR, Length) ->
+%%     case socket_recvmsg(Socket, Length) of
+%%         {ok, MsgHdr}} ->
+%%             handle_recv_deliver(P, D, ActionsR, MsgHdr);
+%%         {select, ?select_info(_) = SelectInfo} ->
+%%             {next_state,
+%%              #recv{info = SelectInfo},
+%%              {P, D},
+%%              reverse(ActionsR)};
+%%         {error, Reason} ->
+%%             %% ?DBG({'recv error wo rest-data', Reason}),
+%%             handle_recv_error(P, D, ActionsR, Reason)
+%%     end.
+
+%% handle_recv_decode(P,
+%% 		   #{packet         := line,
+%% 		     line_delimiter := LineDelimiter,
+%% 		     packet_size    := PacketSize} = D,
+%% 		   ActionsR, Data) ->
+%%     DecodeOpts = [{line_delimiter, LineDelimiter},
+%% 		  {line_length,    PacketSize}],
+%%     handle_recv_decode(P, D,
+%% 		       ActionsR, Data, DecodeOpts);
+%% handle_recv_decode(P, D, ActionsR, Data) ->
+%%     handle_recv_decode(P, D, ActionsR, Data, []).
+
+%% handle_recv_decode(P, #{packet_size := PacketSize} = D,
+%% 		   ActionsR, Data, DecocdeOpts0) ->
+%%     %% ?DBG([{packet_sz, PacketSize}, {decode_opts0, DecocdeOpts0}]),
+%%     DecodeOpts = [{packet_size, PacketSize}|DecocdeOpts0], 
+%%     case erlang:decode_packet(decode_packet(D), Data, DecodeOpts) of
+%%         {ok, Decoded, Rest} ->
+%%             %% is_list(Buffer) -> try to decode first
+%%             %% is_binary(Buffer) -> get more data first
+%%             Buffer =
+%%                 case Rest of
+%%                     <<>> -> Rest;
+%%                     <<_/binary>> -> [Rest]
+%%                 end,
+%%             handle_recv_deliver(P, D#{buffer := Buffer}, ActionsR, Decoded);
+%%         {more, undefined} ->
+%%             handle_recv_more(P, D, ActionsR, Data);
+%%         {more, Length} ->
+%%             N = Length - byte_size(Data),
+%%             handle_recv_length(P, D, ActionsR, N, Data);
+%%         {error, Reason} ->
+%%             handle_recv_error(
+%%               P, D#{buffer := Data}, ActionsR,
+%%               case Reason of
+%%                   invalid -> emsgsize;
+%%                   _ -> Reason
+%%               end)
+%%     end.
+
+%% handle_recv_error_decode(
+%%   P, #{packet_size := PacketSize} = D, ActionsR, Reason, Data) ->
+%%     %%
+%%     case
+%%         erlang:decode_packet(
+%%           decode_packet(D), Data,
+%%           [{packet_size, PacketSize},
+%%            {line_length, PacketSize}])
+%%     of
+%%         {ok, Decoded, Rest} ->
+%%             %% is_list(Buffer) -> try to decode first
+%%             %% is_binary(Buffer) -> get more data first
+%%             Buffer =
+%%                 case Rest of
+%%                     <<>> -> Rest;
+%%                     <<_/binary>> -> [Rest]
+%%                 end,
+%%             handle_recv_error(
+%%               P, D#{buffer := Buffer}, ActionsR, Reason, Decoded);
+%%         {more, _} ->
+%%             handle_recv_error(P, D#{buffer := Data}, ActionsR, Reason);
+%%         {error, Reason} ->
+%%             handle_recv_error(
+%%               P, D#{buffer := Data}, ActionsR,
+%%               case Reason of
+%%                   invalid -> emsgsize;
+%%                   _ -> Reason
+%%               end)
+%%     end.
+
+%% handle_recv_more(P, D, ActionsR, BufferedData) ->
+%%     case socket_recv(P#params.socket, 0) of
+%%         {ok, <<MoreData/binary>>} ->
+%% 	    %% ?DBG([{more_data_sz, byte_size(MoreData)}]), 
+%% 	    Data = catbin(BufferedData, MoreData),
+%%             handle_recv_decode(P, D, ActionsR, Data);
+%%         {select, ?select_info(_) = SelectInfo} ->
+%% 	    %% ?DBG([{select_info, SelectInfo}]), 
+%%             {next_state,
+%%              #recv{info = SelectInfo},
+%%              {P, D#{buffer := BufferedData}},
+%%              reverse(ActionsR)};
+%%         {error, {Reason, <<MoreData/binary>>}} ->
+%%             %% ?DBG({P#params.socket, error, Reason, byte_size(MoreData)}),
+%%             Data = catbin(BufferedData, MoreData),
+%%             handle_recv_error_decode(P, D, ActionsR, Reason, Data);
+%%         {error, Reason} ->
+%%             %% ?DBG({P#params.socket, error, Reason}),
+%%             handle_recv_error(
+%%               P, D#{buffer := BufferedData}, ActionsR, Reason)
+%%     end.
+
+
+handle_recv_deliver(P, D, ActionsR, Data) ->
+    handle_reading(P, recv_data_deliver(P, D, ActionsR, Data)).
+
+%% handle_recv_error(P, D, ActionsR, Reason, Data) ->
+%%     %% Deliver, then error
+%%     {D_1, ActionsR_1} = recv_data_deliver(P, D, ActionsR, Data),
+%%     handle_recv_error(P, D_1, ActionsR_1, Reason).
+%%
+handle_recv_error(P, D, ActionsR, Reason) ->
+    %% ?DBG({P#params.socket, Reason}),
+    {D_1, ActionsR_1} = cleanup_recv_reply(P, D, ActionsR, Reason),
+    case Reason of
+        closed ->
+            {next_state, 'closed_read', {P, D_1}, reverse(ActionsR_1)};
+        emsgsize ->
+            {next_state, 'open',
+             {P, recv_stop(D#{active := false})}, reverse(ActionsR_1)};
+        _ ->
+            %% Temporary ... need somthing better here...maybe
+            {next_state, 'open',
+             {P, recv_stop(D#{active := false})}, reverse(ActionsR_1)}
+    end.
+
+%% -------------------------------------------------------------------------
+%% Callback Helpers
+
+next_state(P, {D, ActionsR}, State, Actions) ->
+    {next_state, State, {P, D}, reverse(ActionsR, Actions)}.
+
+cleanup_close_read(P, D, State, Reason) ->
+    cleanup_recv(P, D, State, Reason).
+
+cleanup_recv(P, D, State, Reason) ->
+    ?DBG([{socket, P#params.socket}, {state, State}, {reason, Reason}]),    
+    case State of
+        #recv{info = SelectInfo} ->
+            socket_cancel(P#params.socket, SelectInfo),
+            cleanup_recv_reply(P, D, [], Reason);
+        _ ->
+            cleanup_recv_reply(P, D, [], Reason)
+    end.
+
+cleanup_recv_reply(P, D, ActionsR, Reason) ->
+    case D of
+        #{active := false} -> ok;
+        #{active := _} ->
+            ModuleSocket = module_socket(P),
+            Owner        = P#params.owner,
+            case Reason of
+                timeout ->
+                    Owner ! {udp_error, ModuleSocket, Reason},
+                    ok;
+                closed ->
+                    Owner ! {udp_closed, ModuleSocket},
+                    ok;
+                emsgsize ->
+                    Owner ! {udp_error, ModuleSocket, Reason},
+                    ok;
+                _ ->
+                    Owner ! {udp_error, ModuleSocket, Reason},
+                    Owner ! {udp_closed, ModuleSocket},
+                    ok
+            end
+    end,
+    {recv_stop(D#{active := false}),
+     case D of
+         #{recv_from := From} ->
+             [{reply, From, {error, Reason}}, {{timeout, recv}, cancel} |
+              ActionsR];
+         #{} ->
+             ActionsR
+     end}.
+
+%% Initialize packet recv state
+recv_start(D) ->
+    D#{recv_length => 0}.
+
+recv_stop(D) ->
+    maps:without([recv_from, recv_length], D).
+
+%% decode_packet(#{packet := Packet} = D) ->
+%%     case D of
+%%         #{packet := http, recv_httph := true} -> httph;
+%%         #{packet := http_bin, recv_httph := true} -> httph_bin;
+%%         #{packet := Packet} -> Packet
+%%     end.
+
+%% Deliver data and update the active state
+%% -> {NewD, NewActionsR}
+recv_data_deliver(
+  #params{owner = Owner} = P,
+  #{mode := Mode, deliver := Deliver} = D,
+  ActionsR, Data) ->
+    %%
+    %% ?DBG([{owner, Owner},
+    %% 	  {mode, Mode},
+    %% 	  {header, Header}, {deliver, Deliver}, {packet, Packet}]), 
+    {IP, Port, AncData, DeliverData} = deliver_data(Data, Mode),
+    case D of
+        #{recv_from := From} ->
+            {recv_stop(D),
+             [{reply, From, {ok, mk_recv_reply(IP, Port, AncData, DeliverData)}},
+              {{timeout, recv}, cancel}
+              | ActionsR]};
+        #{active := false} ->
+            {recv_stop(D), ActionsR};
+        #{active := Active} ->
+            %% ?DBG({active, Active}),
+            ModuleSocket = module_socket(P),
+            deliver_recv_msg(Owner, Active, Deliver,
+                             ModuleSocket, IP, Port, AncData, DeliverData),
+            %% Owner !
+            %%     case Deliver of
+            %%         term ->
+            %%             {udp, ModuleSocket, DeliverData};
+            %%         port ->
+            %%             {ModuleSocket, {data, DeliverData}}
+            %%     end,
+            %% ?DBG('package delivered'),
+            case Active of
+                true ->
+                    {recv_start(D), ActionsR};
+                once ->
+                    {recv_stop(D#{active => false}), ActionsR};
+                1 ->
+                    Owner ! {tcp_passive, ModuleSocket},
+                    {recv_stop(D#{active => false}), ActionsR};
+                N when is_integer(N) ->
+                    {recv_start(D#{active => Active - 1}), ActionsR}
+            end
+    end.
+
+mk_recv_reply(IP, Port, undefined = _AncData, Data) ->
+    {IP, Port, Data};
+mk_recv_reply(IP, Port, AncData, Data) ->
+    {IP, Port, AncData, Data}.
+
+deliver_recv_msg(Pid, Active, Deliver, Socket, IP, Port, AncData, Data) ->
+    Pid ! mk_recv_msg(Active, Deliver, Socket, IP, Port, AncData, Data).
+
+mk_recv_msg(true = _Active, port = _Deliver,
+            Socket, IP, Port, undefined, Data) ->
+    {Socket, {data, [IP, Port, Data]}};
+mk_recv_msg(true = _Active, port = _Deliver,
+            Socket, IP, Port, AncData, Data) ->
+    {Socket, {data, [IP, Port, AncData, Data]}};
+mk_recv_msg(_Active, _Deliver,
+            Socket, IP, Port, undefined, Data) ->
+    {udp, Socket, IP, Port, Data};
+mk_recv_msg(_Active, _Deliver,
+            Socket, IP, Port, AncData, Data) ->
+    {udp, Socket, IP, Port, AncData, Data}.
+
+
+%% next_packet(D, Packet, Data) ->
+%%     if
+%%         Packet =:= http;
+%%         Packet =:= http_bin ->
+%%             case Data of
+%%                 {http_request, _HttpMethod, _HttpUri, _HttpVersion} ->
+%%                     D#{recv_httph => true};
+%%                 {http_response, _HttpVersion, _Integer, _HttpString} ->
+%%                     D#{recv_httph => true};
+%%                 {http_header, _Integer, _HttpField, _Reserver, _Value} -> D;
+%%                 http_eoh ->
+%%                     D#{recv_httph => false};
+%%                 {http_error, _HttpString} -> D
+%%             end;
+%%         true -> D
+%%     end.
+
+%% next_packet(D, Packet, Data, Active) ->
+%%     if
+%%         Packet =:= http;
+%%         Packet =:= http_bin ->
+%%             case Data of
+%%                 {http_request, _HttpMethod, _HttpUri, _HttpVersion} ->
+%%                     D#{recv_httph => true, active => Active};
+%%                 {http_response, _HttpVersion, _Integer, _HttpString} ->
+%%                     D#{recv_httph => true, active => Active};
+%%                 {http_header, _Integer, _HttpField, _Reserver, _Value} ->
+%%                     D#{active => Active};
+%%                 http_eoh ->
+%%                     D#{recv_httph => false, active => Active};
+%%                 {http_error, _HttpString} ->
+%%                     D#{active => Active}
+%%             end;
+%%         true ->
+%%             D#{active => Active}
+%%     end.
+
+%% catbin(<<>>, Bin) when is_binary(Bin) -> Bin;
+%% catbin(Bin, <<>>) when is_binary(Bin) -> Bin;
+%% catbin(Bin1, Bin2) when is_binary(Bin1), is_binary(Bin2) ->
+%%     <<Bin1/binary, Bin2/binary>>.
+
+%% unrecv_buffer(Data, Buffer) ->
+%%     case Buffer of
+%%         <<>> ->
+%%             Data;
+%%         _ when is_binary(Buffer) ->
+%%             [Data, Buffer];
+%%         _ ->
+%%             [Data | Buffer]
+%%     end.
+
+%% condense_buffer([Bin]) when is_binary(Bin) -> Bin;
+%% condense_buffer(Buffer) ->
+%%     iolist_to_binary(reverse_improper(Buffer, [])).
+
+
+%% {Source :: sockaddr(), Data :: binary()}
+%% #{addr := SockAddr :: sockaddr(),
+%%   iov  := IOV      :: iovec(),
+%%   ctrl := Ctrl     :: list()}
+deliver_data({#{addr := Addr, port := Port}, <<Data/binary>>}, Mode) ->
+    {Addr, Port, undefined, deliver_data_mode(Data, Mode)};
+deliver_data(#{addr := #{addr := Addr, port := Port},
+               iov  := IOV,
+               ctrl := Ctrl}, Mode) ->
+    Data = deliver_data_mode(IOV, Mode),
+    {Addr, Port, ctrl2ancdata(Ctrl), Data}.
+
+deliver_data_mode(Data, list)   when is_binary(Data) -> binary_to_list(Data);
+deliver_data_mode(Data, binary) when is_binary(Data) -> Data;
+deliver_data_mode(IOV,  list)   when is_list(IOV) -> deliver_data_mode_bin(IOV);
+deliver_data_mode(IOV,  binary) when is_list(IOV) -> iolist_to_binary(IOV).
+
+%% Make some optimizations
+deliver_data_mode_bin([Bin]) ->
+    Bin;
+deliver_data_mode_bin([Bin1, Bin2]) ->
+    <<Bin1/binary, Bin2/binary>>;
+deliver_data_mode_bin([Bin1, Bin2, Bin3]) ->
+    <<Bin1/binary, Bin2/binary, Bin3/binary>>;
+deliver_data_mode_bin([Bin1, Bin2, Bin3, Bin4]) ->
+    <<Bin1/binary, Bin2/binary, Bin3/binary, Bin4/binary>>;
+deliver_data_mode_bin(IOV) ->
+    deliver_data_mode_bin(IOV, <<>>).
+
+deliver_data_mode_bin([], Acc) ->
+    Acc;
+deliver_data_mode_bin([Bin|IOV], Acc) ->
+    deliver_data_mode_bin(IOV, <<Bin/binary, Acc/binary>>).
+
+
+ctrl2ancdata(CTRL) ->
+    ctrl2ancdata(CTRL, []).
+
+ctrl2ancdata([], AncData) ->
+   lists:reverse(AncData);
+ctrl2ancdata([#{level := ip, type := recvtos, data := Val}| CTRL], AncData) ->
+    ctrl2ancdata(CTRL, [{tos, erlang:binary_to_integer(Val)}|AncData]);
+ctrl2ancdata([#{level := ip, type := recvttl, data := Val}| CTRL], AncData) ->
+    ctrl2ancdata(CTRL, [{ttl, erlang:binary_to_integer(Val)}|AncData]);
+ctrl2ancdata([#{level := ipv6, type := tclass, data := Val}| CTRL], AncData) ->
+    ctrl2ancdata(CTRL, [{tclass, erlang:binary_to_integer(Val)}|AncData]);
+ctrl2ancdata([_|CTRL], AncData) ->
+    ctrl2ancdata(CTRL, AncData).
+
+
+%% -> {ok, NewD} | {{error, Reason}, D}
+state_setopts(P, D, _State, []) ->
+    {ok, {P, D}};
+state_setopts(P, D, State, [Opt | Opts]) ->
+    ?DBG([{state, State}, {opt, Opt}]),
+    Opt_1 = conv_setopt(Opt),
+    ?DBG([{'option converted', Opt_1}]),
+    case setopt_categories(Opt_1) of
+        %% This is a special case for options that trigger us to choose 
+        %% the recv "method"; either recvfrom or recvmsg.
+        %% If the recv_method list is empty => recvfrom otherwise recvmsg.
+        #{socket := _, recv_method := _} ->
+            RecvMethod = P#params.recv_method,
+            RecvMethod2 =
+                case Opt_1 of
+                    {Tag, true} -> %% Add if not already added
+                        M = lists:member(Tag, RecvMethod),
+                        if (M) -> RecvMethod; true -> [Tag|RecvMethod] end;
+                    {Tag, false} -> %% Remove
+                        lists:delete(Tag, RecvMethod)
+                end,
+            P_1 = P#params{recv_method = RecvMethod2},
+            case P_1#params.socket of
+                undefined ->
+                    {{error, closed}, D};
+                Socket ->
+                    case socket_setopt(Socket, Opt_1) of
+                        ok ->
+                            state_setopts(P_1, D, State, Opts);
+                        {error, _} = Error ->
+                            {Error, {P_1, D}}
+                    end
+            end;
+
+        #{socket := _} ->
+            %% ?DBG(socket),
+            case P#params.socket of
+                undefined ->
+                    {{error, closed}, D};
+                Socket ->
+                    case socket_setopt(Socket, Opt_1) of
+                        ok ->
+                            state_setopts(P, D, State, Opts);
+                        {error, _} = Error ->
+                            {Error, {P, D}}
+                    end
+            end;
+        %%
+        #{server_write := _} when State =:= 'closed' ->
+            %% ?DBG('server write when state closed'),
+            {{error, einval}, {P, D}};
+        #{server_write := _} ->
+            %% ?DBG('server write'),
+            state_setopts_server(P, D, State, Opts, Opt_1);
+        %%
+        #{server_read := _} when State =:= 'closed' ->
+            %% ?DBG('server read when state closed'),
+            {{error, einval}, {P, D}};
+        #{server_read := _} when (State =:= 'closed_read') orelse
+                                 (State =:= 'closed_read_write') ->
+            %% ?DBG('server read when state closed-read or closed-read-write'),
+            {{error, einval}, {P, D}};
+        #{server_read := _} ->
+            %% ?DBG('server read'),
+            state_setopts_server(P, D, State, Opts, Opt_1);
+        %%
+        #{ignore := _} ->
+            %% ?DBG(ignore),
+            state_setopts(P, D, State, Opts);
+        #{} = _EXTRA -> % extra | einval
+            %% ?DBG({extra, _EXTRA}),
+            {{error, einval}, {P, D}}
+    end.
+
+state_setopts_server(P, D, State, Opts, {Tag, Value}) ->
+    case Tag of
+        active ->
+            state_setopts_active(P, D, State, Opts, Value);
+        _ ->
+	    %% ?DBG([{tag, Tag}, {value, Value}]),
+            state_setopts(P, D#{Tag => Value}, State, Opts)
+    end.
+
+state_setopts_active(P, D, State, Opts, Active) ->
+    if
+        Active =:= once;
+        Active =:= true ->
+            state_setopts(P, D#{active := Active}, State, Opts);
+        Active =:= false ->
+            case D of
+                #{active := OldActive} when is_integer(OldActive) ->
+                    P#params.owner ! {tcp_passive, module_socket(P)},
+                    ok;
+                #{active := _OldActive} -> ok
+            end,
+            state_setopts(P, D#{active := Active}, State, Opts);
+        is_integer(Active), -32768 =< Active, Active =< 32767 ->
+            N =
+                case D of
+                    #{active := OldActive} when is_integer(OldActive) ->
+                        OldActive + Active;
+                    #{active := _OldActive} ->
+                        Active
+                end,
+            if
+                32767 < N ->
+                    {{error, einval}, D};
+                N =< 0 ->
+                    P#params.owner ! {tcp_passive, module_socket(P)},
+                    state_setopts(P, D#{active := false}, State, Opts);
+                true ->
+                    state_setopts(P, D#{active := N}, State, Opts)
+            end;
+        true ->
+            {{error, einval}, D}
+    end.
+
+%% -> {ok, [Options]} | {error, einval}
+state_getopts(P, D, State, Opts) ->
+    state_getopts(P, D, State, Opts, []).
+%%
+state_getopts(_P, _D, _State, [], Acc) ->
+    {ok, reverse(Acc)};
+state_getopts(P, D, State, [Tag | Tags], Acc) ->
+    %% ?DBG({'categorize option', Tag, State}),
+    case getopt_categories(Tag) of
+        #{socket := _} ->
+            %% ?DBG(socket),
+            case P#params.socket of
+                undefined ->
+                    {error, closed};
+                Socket ->
+                    %% ?DBG({'socket getopt', Tag}),
+                    case socket_getopt(Socket, Tag) of
+                        {ok, Value} ->
+                            %% ?DBG({'socket getopt', ok, Value}),
+                            state_getopts(
+                              P, D, State, Tags, [{Tag, Value} | Acc]);
+                        {error, _Reason} ->
+                            %% ?DBG({'socket getopt', error, _Reason}),
+                            state_getopts(P, D, State, Tags, Acc)
+                    end
+              end;
+        #{server_write := _} when State =:= 'closed' ->
+            %% ?DBG('server write when closed'),
+            {error, einval};
+        #{server_write := _} ->
+            %% ?DBG('server write'),
+            Value = maps:get(Tag, D),
+            state_getopts(P, D, State, Tags, [{Tag, Value} | Acc]);
+        #{server_read := _} when State =:= 'closed' ->
+            %% ?DBG('server read when closed'),
+            {error, einval};
+        #{server_read := _} when (State =:= 'closed_read') orelse
+                                 (State =:= 'closed_read_write') ->
+            %% ?DBG('server read when closed-read or closed-read-write'),
+            {error, einval};
+        #{server_read := _} ->
+            %% ?DBG('server read'),
+            Value = maps:get(Tag, D),
+            state_getopts(P, D, State, Tags, [{Tag, Value} | Acc]);
+        #{} = _EXTRA -> % extra | einval
+            %% ?DBG({'something else', _EXTRA}),
+            {error, einval}
+    end.
+
+handle_info(Socket, Owner, D) -> 
+    %% Read counters
+    Counters_1 = socket_info_counters(Socket),
+    %% Check for recent wraps
+    {D_1, Wrapped} = receive_counter_wrap(Socket, D, []),
+    %%
+    %% Assumption: a counter that we just now got a wrap message from
+    %% will not wrap again before we read the updated value
+    %%
+    %% Update wrapped counters
+    Info = #{counters := Counters_2} = socket:info(Socket),
+    Counters_3 = maps:merge(Counters_1, maps:with(Wrapped, Counters_2)),
+    %% Go ahead with wrap updated counters
+    Counters_4 = maps:from_list(getstat_what(D_1, Counters_3)),
+    {D_1, Info#{counters => Counters_4, owner => Owner}}.
+    
+getstat(Socket, D, What) ->
+    %% Read counters
+    Counters_1 = socket_info_counters(Socket),
+    %% Check for recent wraps
+    {D_1, Wrapped} = receive_counter_wrap(Socket, D, []),
+    %%
+    %% Assumption: a counter that we just now got a wrap message from
+    %% will not wrap again before we read the updated value
+    %%
+    %% Update wrapped counters
+    Counters_2 = socket_info_counters(Socket),
+    Counters_3 = maps:merge(Counters_1, maps:with(Wrapped, Counters_2)),
+    %% Go ahead with wrap updated counters
+    {D_1, getstat_what(What, D_1, Counters_3)}.
+
+getstat_what(D, C) ->
+    getstat_what(inet:stats(), D, C).
+
+getstat_what([], _D, _C) -> [];
+getstat_what([Tag | What], D, C) ->
+    Val =
+        case Tag of
+            recv_oct ->
+                counter_value(read_byte, D, C);
+            recv_cnt ->
+                counter_value(read_pkg, D, C);
+            recv_max ->
+                getstat_avg(read_byte, D, C, read_pkg);
+            recv_avg ->
+                getstat_avg(read_byte, D, C, read_pkg);
+            recv_dvi -> 0;
+            %%
+            send_oct ->
+                counter_value(write_byte, D, C);
+            send_cnt ->
+                counter_value(write_pkg, D, C);
+            send_max ->
+                getstat_avg(write_byte, D, C, write_pkg);
+            send_avg ->
+                getstat_avg(write_byte, D, C, write_pkg);
+            send_pend -> 0
+        end,
+    [{Tag, Val} | getstat_what(What, D, C)].
+
+getstat_avg(SumTag, D, C, CntTag) ->
+    Cnt = counter_value(CntTag, D, C),
+    if
+        Cnt =:= 0 ->
+            counter_value(SumTag, D, C);
+        true ->
+            round(counter_value(SumTag, D, C) / Cnt)
+    end.
+
+socket_info_counters(Socket) ->
+    #{counters := Counters} = socket:info(Socket),
+    Counters.
+
+receive_counter_wrap(Socket, D, Wrapped) ->
+    receive
+        ?socket_counter_wrap(Socket, Counter) ->
+	    %% ?DBG([{counter, Counter}]),
+            receive_counter_wrap(
+              Socket, wrap_counter(Counter, D), [Counter | Wrapped])
+    after 0 ->
+            {D, Wrapped}
+    end.
+
+wrap_counter(Counter, D) ->
+    case D of
+        #{Counter := N} ->
+            D#{Counter := N + 1};
+        #{} ->
+            D#{Counter => 1}
+    end.
+
+-define(COUNTER_BITS, 32).
+counter_value(Counter, D, Counters) ->
+    case D of
+        #{Counter := Wraps} ->
+            (Wraps bsl ?COUNTER_BITS) + maps:get(Counter, Counters);
+        #{} ->
+            maps:get(Counter, Counters)
+    end.
+
+
+
+-compile({inline, [reverse/1]}).
+reverse([]) -> [];
+reverse([_] = L) -> L;
+reverse([A, B]) -> [B, A];
+reverse(L) -> lists:reverse(L).
+
+-compile({inline, [reverse/2]}).
+reverse([], L) -> L;
+reverse([A], L) -> [A | L];
+reverse([A, B], L) -> [B, A | L];
+reverse(L1, L2) -> lists:reverse(L1, L2).
+
+%% Reverse but allow improper list
+%% reverse_improper([H | T], Acc) ->
+%%     reverse_improper(T, [H | Acc]);
+%% reverse_improper([], Acc) -> Acc;
+%% reverse_improper(T, Acc) -> [T | Acc].
+
+
+%% -------------------------------------------------------------------------
+-ifdef(undefined).
+
+%% Better, Leaner, Faster, Smarter, than inet:timeout
+
+end_time(infinity) -> infinity;
+end_time(Timeout) when is_integer(Timeout), 0 =< Timeout ->
+    erlang:monotonic_time(millisecond) + Timeout.
+
+timeout(infinity) -> infinity;
+timeout(EndTime) ->
+    Time = erlang:monotonic_time(millisecond),
+    if
+        Time < EndTime ->
+            EndTime - Time;
+        true -> 0
+    end.
+
+-endif.
diff --git a/lib/kernel/src/inet.erl b/lib/kernel/src/inet.erl
index 1c7dde5e1f..6350257835 100644
--- a/lib/kernel/src/inet.erl
+++ b/lib/kernel/src/inet.erl
@@ -40,7 +40,7 @@
 
 -export([connect_options/2, listen_options/2, udp_options/2, sctp_options/2]).
 -export([udp_module/1, tcp_module/1, tcp_module/2, sctp_module/1]).
--export([gen_tcp_module/1]).
+-export([gen_tcp_module/1, gen_udp_module/1]).
 
 -export([i/0, i/1, i/2]).
 
@@ -1073,15 +1073,19 @@ gen_tcp_module(Opts, inet) ->
 gen_tcp_module(Opts, socket) ->
     {gen_tcp_socket, Opts}.
 
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Available options for udp:open
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 udp_options() ->
-    [tos, tclass, priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode,
+    [
+     tos, tclass,
+     priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode,
      recvtos, recvtclass, ttl, recvttl, deliver, ipv6_v6only,
      broadcast, dontroute, multicast_if, multicast_ttl, multicast_loop,
-     add_membership, drop_membership, read_packets,raw,
-     high_msgq_watermark, low_msgq_watermark, bind_to_device].
+     add_membership, drop_membership, read_packets, raw,
+     high_msgq_watermark, low_msgq_watermark, bind_to_device
+    ].
 
 
 udp_options(Opts, Mod) ->
@@ -1133,6 +1137,20 @@ udp_module(Opts) ->
       Opts, udp_module, undefined,
       #{inet => inet_udp, inet6 => inet6_udp, local => local_udp}).
 
+gen_udp_module([{inet_backend, Flag}|Opts]) ->
+    gen_udp_module(Opts, Flag);
+gen_udp_module(Opts) ->
+    gen_udp_module(
+      Opts,
+      persistent_term:get(
+        {kernel, inet_backend}, ?DEFAULT_KERNEL_INET_BACKEND)).
+%%
+gen_udp_module(Opts, inet) ->
+    {gen_udp, Opts};
+gen_udp_module(Opts, socket) ->
+    {gen_udp_socket, Opts}.
+
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% Available options for sctp:open
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1948,8 +1966,8 @@ fmt_port(N, Proto) ->
     end.
 
 %% Return a list of all tcp sockets
-tcp_sockets() -> port_list("tcp_inet") ++ gen_tcp_socket:which_sockets().
-udp_sockets() -> port_list("udp_inet").
+tcp_sockets()  -> port_list("tcp_inet") ++ gen_tcp_socket:which_sockets().
+udp_sockets()  -> port_list("udp_inet") ++ gen_udp_socket:which_sockets().
 sctp_sockets() -> port_list("sctp_inet").
 
 %% Return all ports having the name 'Name'
@@ -1962,6 +1980,7 @@ port_list(Name) ->
 	      end
       end, erlang:ports()).
 
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%  utils
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/lib/kernel/src/inet_int.hrl b/lib/kernel/src/inet_int.hrl
index 38d35309cb..c19df16205 100644
--- a/lib/kernel/src/inet_int.hrl
+++ b/lib/kernel/src/inet_int.hrl
@@ -424,7 +424,7 @@
 	  ifaddr,
 	  port   = 0,
 	  fd     = -1,
-	  opts   = [{active,true}]
+	  opts   = [{active, true}]
 	 }).
 
 -define(SCTP_DEF_BUFSZ, 65536).
diff --git a/lib/kernel/test/gen_udp_SUITE.erl b/lib/kernel/test/gen_udp_SUITE.erl
index c7b020cf7f..6e63407115 100644
--- a/lib/kernel/test/gen_udp_SUITE.erl
+++ b/lib/kernel/test/gen_udp_SUITE.erl
@@ -56,30 +56,62 @@ suite() ->
      {timetrap,{minutes,1}}].
 
 all() -> 
-    [
-     send_to_closed,
-     buffer_size,
-     binary_passive_recv,
-     max_buffer_size,
-     bad_address,
-     read_packets,
-     recv_poll_after_active_once,
-     open_fd,
-     connect,
-     implicit_inet6,
-     active_n,
-     recvtos, recvtosttl, recvttl, recvtclass,
-     sendtos, sendtosttl, sendttl, sendtclass,
-     {group, local},
-     recv_close,
-     otp_17492
-    ].
+    %% This is a temporary messure to ensure that we can 
+    %% test the socket backend without effecting *all*
+    %% applications on *all* machines.
+    %% This flag is set only for *one* host.
+    case ?TEST_INET_BACKENDS() of
+        true ->
+            [
+             {group, inet_backend_default},
+             {group, inet_backend_inet},
+             {group, inet_backend_socket}
+            ];
+        _ ->
+            [
+             {group, inet_backend_default}
+            ]
+    end.
+
 
 groups() -> 
     [
+     {inet_backend_default,   [], inet_backend_default_cases()},
+     {inet_backend_inet,      [], inet_backend_inet_cases()},
+     {inet_backend_socket,    [], inet_backend_socket_cases()},
+
      {local, [], local_cases()}
     ].
 
+inet_backend_default_cases() ->
+    all_cases().
+
+inet_backend_inet_cases() ->
+    all_cases().
+
+inet_backend_socket_cases() ->
+    all_cases().
+
+all_cases() ->
+    [
+     %% send_to_closed,
+     %% buffer_size,
+     %% binary_passive_recv,
+     %% max_buffer_size,
+     %% bad_address,
+     %% read_packets,
+     %% recv_poll_after_active_once,
+     open_fd%%,
+     %% connect,
+     %% implicit_inet6,
+     %% active_n,
+     %% recvtos, recvtosttl, recvttl, recvtclass,
+     %% sendtos, sendtosttl, sendttl, sendtclass,
+     %% {group, local},
+     %% recv_close,
+     %% otp_17492
+    ].
+
 local_cases() ->
     [
      local_basic,
@@ -89,6 +121,7 @@ local_cases() ->
      local_abstract
     ].
 
+
 init_per_suite(Config0) ->
 
     ?P("init_per_suite -> entry with"
@@ -126,8 +159,28 @@ end_per_suite(Config0) ->
 
     Config1.
 
+init_per_group(inet_backend_default = _GroupName, Config) ->
+    [{socket_create_opts, []} | Config];
+init_per_group(inet_backend_inet = _GroupName, Config) ->
+    case ?EXPLICIT_INET_BACKEND() of
+        true ->
+            %% The environment trumps us,
+            %% so only the default group should be run!
+            {skip, "explicit inet backend"};
+        false ->
+            [{socket_create_opts, [{inet_backend, inet}]} | Config]
+    end;
+init_per_group(inet_backend_socket = _GroupName, Config) ->
+    case ?EXPLICIT_INET_BACKEND() of
+        true ->
+            %% The environment trumps us,
+            %% so only the default group should be run!
+            {skip, "explicit inet backend"};
+        false ->
+            [{socket_create_opts, [{inet_backend, socket}]} | Config]
+    end;
 init_per_group(local, Config) ->
-    case gen_udp:open(0, [local]) of
+    case ?OPEN(Config, 0, [local]) of
 	{ok,S} ->
 	    ok = gen_udp:close(S),
 	    Config;
@@ -192,7 +245,10 @@ end_per_testcase(_Case, Config) ->
 
 %% Tests core functionality.
 send_to_closed(Config) when is_list(Config) ->
-    {ok, Sock} = gen_udp:open(0),
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_send_to_closed(Config) end).
+
+do_send_to_closed(Config) ->
+    {ok, Sock} = ?OPEN(Config, 0),
     ok = gen_udp:send(Sock, {127,0,0,1}, ?CLOSED_PORT, "foo"),
     timer:sleep(2),
     ok = gen_udp:send(Sock, {127,0,0,1}, ?CLOSED_PORT, "foo"),
@@ -206,6 +262,9 @@ send_to_closed(Config) when is_list(Config) ->
 
 %% Test UDP buffer size setting.
 buffer_size(Config) when is_list(Config) ->
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_buffer_size(Config) end).
+
+do_buffer_size(Config) when is_list(Config) ->
     Len = 256,
     Bin = list_to_binary(lists:seq(0, Len-1)),
     M = 8192 div Len,
@@ -225,17 +284,16 @@ buffer_size(Config) when is_list(Config) ->
 		  [truncated,emsgsize,timeout]}
 	 end || {Tag,Val} <- Spec0],
     %%
-    {ok, ClientSocket}  = gen_udp:open(0, [binary]),
+    {ok, ClientSocket}  = ?OPEN(Config, 0, [binary]),
     {ok, ClientPort} = inet:port(ClientSocket),
     Client = self(),
     ClientIP = {127,0,0,1},
     ServerIP = {127,0,0,1},
-    io:format(
-      "Client: {~p, ~p}, ~p~n", [ClientIP, ClientPort, ClientSocket]),
+    ?P("Client: {~p, ~p}, ~p", [ClientIP, ClientPort, ClientSocket]),
     Server =
 	spawn_link(
 	  fun () -> 
-		  {ok, ServerSocket}  = gen_udp:open(0, [binary]),
+		  {ok, ServerSocket}  = ?OPEN(Config, 0, [binary]),
 		  {ok, ServerPort} = inet:port(ServerSocket),
 		  Client ! {self(),port,ServerPort},
 		  buffer_size_server(Client, ClientIP, ClientPort, 
@@ -244,10 +302,8 @@ buffer_size(Config) when is_list(Config) ->
 	  end),
     Mref = erlang:monitor(process, Server),
     receive
-	{Server,port,ServerPort} ->
-            io:format(
-              "Server: {~p, ~p}, ~p~n",
-              [ServerIP, ServerPort, Server]),
+	{Server, port, ServerPort} ->
+            ?P("Server: {~p, ~p}, ~p", [ServerIP, ServerPort, Server]),
 	    buffer_size_client(Server, ServerIP, ServerPort,
 			       ClientSocket, 1, Spec)
     end,
@@ -261,19 +317,22 @@ buffer_size_client(_, _, _, _, _, []) ->
     ok;
 buffer_size_client(Server, IP, Port, 
 		   Socket, Cnt, [Opts|T]) when is_list(Opts) ->
-    ?P("buffer_size_client Cnt=~w setopts ~p", [Cnt, Opts]),
+    ?P("buffer_size_client -> Cnt=~w setopts ~p", [Cnt, Opts]),
     ok = inet:setopts(Socket, Opts),
+    GOpts = [K || {K, _} <- Opts],
+    ?P("buffer_size_client -> opts result: ~p", [inet:getopts(Socket, GOpts)]),
     Server ! {self(),setopts,Cnt},
     receive {Server,setopts,Cnt} -> ok end,
     buffer_size_client(Server, IP, Port, Socket, Cnt+1, T);
 buffer_size_client(Server, IP, Port, 
 		   Socket, Cnt, [{B,Replies}|T]=Opts) when is_binary(B) ->
-    ?P("buffer_size_client Cnt=~w send size ~w expecting ~p",
-       [Cnt, size(B), Replies]),
+    ?P("buffer_size_client -> Cnt=~w send size ~w expecting ~p when"
+       "~n   Info: ~p",
+       [Cnt, size(B), Replies, inet:info(Socket)]),
     case gen_udp:send(Socket, IP, Port, <<Cnt,B/binary>>) of
 	ok ->
 	    receive
-		{Server,Cnt,Reply} ->
+		{Server, Cnt, Reply} ->
 		    Tag =
 			if
 			    is_tuple(Reply) ->
@@ -284,6 +343,9 @@ buffer_size_client(Server, IP, Port,
 		    case lists:member(Tag, Replies) of
 			true -> ok;
 			false ->
+                            ?P("missing from expected replies: "
+                               "~n   Tag:     ~p"
+                               "~n   Replies: ~p", [Tag, Replies]),
 			    ct:fail({reply_mismatch,Cnt,Reply,Replies,
 				     byte_size(B),
 				     inet:getopts(Socket,
@@ -299,7 +361,7 @@ buffer_size_client(Server, IP, Port,
 	    ?SKIPE(Reason);
 
 	{error, Reason} ->
-	    ?P("<ERROR> Failed sending data ~w bytes of data: "
+	    ?P("<ERROR> Client failed sending ~w bytes of data: "
 	       "~n   SndBuf: ~p"
 	       "~n   Reason: ~p",
 	       [size(B), inet:getopts(Socket, [sndbuf]), Reason]),
@@ -310,45 +372,77 @@ buffer_size_server(_, _, _, _, _, []) ->
     ok;
 buffer_size_server(Client, IP, Port, 
 		   Socket, Cnt, [Opts|T]) when is_list(Opts) ->
-    receive {Client,setopts,Cnt} -> ok end,
-    ?P("buffer_size_server Cnt=~w setopts ~p", [Cnt, Opts]),
+    ?P("buffer_size_server -> await client setopts"),
+    receive {Client, setopts, Cnt} -> ok end,
+    ?P("buffer_size_server -> Cnt=~w setopts ~p", [Cnt, Opts]),
     ok = inet:setopts(Socket, Opts),
-    Client ! {self(),setopts,Cnt},
+    GOpts = [K || {K, _} <- Opts],
+    ?P("buffer_size_server -> opts result: ~p", [inet:getopts(Socket, GOpts)]),
+    Client ! {self(), setopts, Cnt},
     buffer_size_server(Client, IP, Port, Socket, Cnt+1, T);
 buffer_size_server(Client, IP, Port, 
 		   Socket, Cnt, [{B,_}|T]) when is_binary(B) ->
-    ?P("buffer_size_server Cnt=~w expecting size ~w", [Cnt, size(B)]),
-    Client ! 
-	{self(),Cnt,
-	 case buffer_size_server_recv(Socket, IP, Port, Cnt) of
-	     D when is_binary(D) ->
-		 SizeD = byte_size(D),
-		 ?P("buffer_size_server Cnt=~w received size ~w", [Cnt, SizeD]),
-		 case B of
-		     D ->
-			 correct;
-		     <<D:SizeD/binary,_/binary>> ->
-			 truncated;
-		     _ ->
-			 {unexpected,D}
-		 end;
-	     Error ->
-		 ?P("buffer_size_server Cnt=~w received error ~w",
-		    [Cnt, Error]),
-		 Error
-	 end},
+    ?P("buffer_size_server -> try receive: Cnt=~w and ~w buytes of data",
+       [Cnt, size(B)]),
+    Reply = case buffer_size_server_recv(Socket, IP, Port, Cnt) of
+                D when is_binary(D) ->
+                    SizeD = byte_size(D),
+                    ?P("buffer_size_server -> received: ~w bytes of data",
+                       [SizeD]),
+                    case B of
+                        D ->
+                            correct;
+                        <<D:SizeD/binary,_/binary>> ->
+                            truncated;
+                        _ ->
+                            {unexpected,D}
+                    end;
+                Error ->
+                    ?P("buffer_size_server -> error: Cnt=~w received error ~w",
+                       [Cnt, Error]),
+                    Error
+            end,
+    ?P("buffer_size_server -> send reply '~p'", [Reply]),
+    Client ! {self(), Cnt, Reply},
     buffer_size_server(Client, IP, Port, Socket, Cnt+1, T).
 
 buffer_size_server_recv(Socket, IP, Port, Cnt) ->
+    ?P("buffer_size_server -> await data: "
+       "~n   Socket: ~p"
+       "~n   IP:     ~p"
+       "~n   Port:   ~p"
+       "~n   Cnt:    ~p", [Socket, IP, Port, Cnt]),
     receive
-	{udp,Socket,IP,Port,<<Cnt,B/binary>>} ->
+	{udp, Socket, IP, Port, <<Cnt, B/binary>>} ->
+            ?P("buffer_size_server -> received (~w) ~w bytes", [Cnt, size(B)]),
 	    B;
-	{udp,Socket,IP,Port,<<_/binary>>} ->
+	{udp, Socket, IP, Port, <<_B/binary>>} ->
+            ?P("buffer_size_server -> received unexpected ~w bytes",
+               [size(_B)]),
 	    buffer_size_server_recv(Socket, IP, Port, Cnt);
-	{udp_error,Socket,Error} ->
+
+	{udp, Socket, IP, Port, _CRAP} ->
+            ?P("buffer_size_server -> received unexpected crap"),
+	    buffer_size_server_recv(Socket, IP, Port, Cnt);
+
+	{udp, XSocket, XIP, XPort, _CRAP} ->
+            ?P("buffer_size_server -> received unexpected udp message: "
+               "~n   XSocket: ~p"
+               "~n   Socket:  ~p"
+               "~n   XIP:     ~p"
+               "~n   IP:      ~p"
+               "~n   XPort:   ~p"
+               "~n   Port:    ~p",
+               [XSocket, Socket, XIP, IP, XPort, Port]),
+	    buffer_size_server_recv(Socket, IP, Port, Cnt);
+
+	{udp_error, Socket, Error} ->
+            ?P("buffer_size_server -> error: ~p", [Error]),
 	    Error
+
     after 5000 ->
-	    {timeout,flush()}
+            ?P("buffer_size_server -> timeout"),
+	    {timeout, flush()}
     end.
 
 
@@ -356,35 +450,53 @@ buffer_size_server_recv(Socket, IP, Port, Cnt) ->
 %% OTP-15206: Keep buffer small for udp
 %%-------------------------------------------------------------
 max_buffer_size(Config) when is_list(Config) ->
-    {ok, Socket}  = gen_udp:open(0, [binary]),
-    ok = inet:setopts(Socket,[{recbuf, 1 bsl 20}]),
-    {ok, [{buffer, 65536}]} = inet:getopts(Socket,[buffer]),
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_max_buffer_size(Config) end).
+
+do_max_buffer_size(Config) when is_list(Config) ->
+    {ok, Socket} = ?OPEN(Config, 0, [binary]),
+    ok = inet:setopts(Socket, [{recbuf, 1 bsl 20}]),
+    {ok, [{buffer, 65536}]} = inet:getopts(Socket, [buffer]),
     gen_udp:close(Socket).
 
+
+
 %%-------------------------------------------------------------
 %% OTP-3823 gen_udp:recv does not return address in binary mode
 %%
 
 %% OTP-3823 gen_udp:recv does not return address in binary mode.
 binary_passive_recv(Config) when is_list(Config) ->
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_binary_passive_recv(Config) end).
+
+do_binary_passive_recv(Config) when is_list(Config) ->
     D1       = "The quick brown fox jumps over a lazy dog",
     D2       = list_to_binary(D1),
     D3       = ["The quick", <<" brown ">>, "fox jumps ", <<"over ">>,
 		<<>>, $a, [[], " lazy ", <<"dog">>]],
     D2       = iolist_to_binary(D3),
     B        = D2,
-    {ok, R}  = gen_udp:open(0, [binary, {active, false}]),
+    ?P("open receive socket"),
+    {ok, R}  = ?OPEN(Config, 0, [binary, {active, false}]),
     {ok, RP} = inet:port(R),
-    {ok, S}  = gen_udp:open(0),
+    ?P("open send socket"),
+    {ok, S}  = ?OPEN(Config, 0),
     {ok, SP} = inet:port(S),
+    ?P("try send (to port ~w) ~w bytes (as a list)", [RP, length(D1)]),
     ok       = gen_udp:send(S, localhost, RP, D1),
+    ?P("try recv (from port ~w) ~w bytes", [SP, byte_size(B)+1]),
     {ok, {{127, 0, 0, 1}, SP, B}} = gen_udp:recv(R, byte_size(B)+1),
+    ?P("try send (to port ~w) ~w bytes (as a binary)", [RP, byte_size(D2)]),
     ok       = gen_udp:send(S, localhost, RP, D2),
+    ?P("try recv (from port ~w) ~w bytes", [SP, byte_size(B)+1]),
     {ok, {{127, 0, 0, 1}, SP, B}} = gen_udp:recv(R, byte_size(B)+1),
+    ?P("try send (to port ~w) ~w bytes (as a iolist)", [RP, iolist_size(D3)]),
     ok       = gen_udp:send(S, localhost, RP, D3),
+    ?P("try recv (from port ~w) ~w bytes", [SP, byte_size(B)+1]),
     {ok, {{127, 0, 0, 1}, SP, B}} = gen_udp:recv(R, byte_size(B)+1),
+    ?P("cleanup"),
     ok       = gen_udp:close(S),
     ok       = gen_udp:close(R),
+    ?P("done"),
     ok.
 
 
@@ -393,16 +505,40 @@ binary_passive_recv(Config) when is_list(Config) ->
 
 %% OTP-3836 inet_udp crashes when IP-address is larger than 255.
 bad_address(Config) when is_list(Config) ->
-    {ok, R}  = gen_udp:open(0),
-    {ok, RP} = inet:port(R),
-    {ok, S}  = gen_udp:open(0),
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_bad_address(Config) end).
+
+do_bad_address(Config) when is_list(Config) ->
+    ?P("create sockets"),
+    {ok, R}   = ?OPEN(Config, 0),
+    {ok, RP}  = inet:port(R),
+    {ok, S}   = ?OPEN(Config, 0),
     {ok, _SP} = inet:port(S),
-    {'EXIT', badarg} =
-	(catch gen_udp:send(S, {127,0,0,1,0}, RP, "void")),
-    {'EXIT', badarg} =
-	(catch gen_udp:send(S, {127,0,0,256}, RP, "void")),
+
+    ?P("try send to invalid address 1 - expect failure"),
+    case (catch gen_udp:send(S, {127,0,0,1,0}, RP, "void")) of
+        {'EXIT', badarg} ->
+            ok;
+        Any1 ->
+            ?P("<ERROR> unexpected result: "
+               "~n   ~p", [Any1]),
+            ct:fail({unexpected_result, 1, Any1})                
+    end,
+
+    ?P("try send to invalid address 2 - expect failure"),
+    case (catch gen_udp:send(S, {127,0,0,256}, RP, "void")) of
+        {'EXIT', badarg} ->
+            ok;
+        Any2 ->
+            ?P("<ERROR> unexpected result: "
+               "~n   ~p", [Any2]),
+            ct:fail({unexpected_result, 2, Any2})
+    end,
+
+    ?P("cleanup"),
     ok       = gen_udp:close(S),
     ok       = gen_udp:close(R),
+
+    ?P("done"),
     ok.
 
 
@@ -419,26 +555,29 @@ bad_address(Config) when is_list(Config) ->
 
 %% OTP-6249 UDP option for number of packet reads.
 read_packets(Config) when is_list(Config) ->
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_read_packets(Config) end).
+
+do_read_packets(Config) when is_list(Config) ->
     N1   = 5,
     N2   = 1,
     Msgs = 30000,
     ?P("open socket (with read-packets: ~p)", [N1]),
-    {ok, R}   = gen_udp:open(0, [{read_packets,N1}]),
+    {ok, R}   = ?OPEN(Config, 0, [{read_packets,N1}]),
     {ok, RP}  = inet:port(R),
     ?P("create slave node"),
     {ok,Node} = start_node(gen_udp_SUITE_read_packets),
     %%
     ?P("perform read-packets test"),
-    {V1, Trace1} = read_packets_test(R, RP, Msgs, Node),
+    {V1, Trace1} = read_packets_test(Config, R, RP, Msgs, Node),
     ?P("verify read-packets (to ~w)", [N1]),
     {ok,[{read_packets,N1}]} = inet:getopts(R, [read_packets]),
     %%
     ?P("set new read-packets: ~p", [N2]),
     ok = inet:setopts(R, [{read_packets, N2}]),
     ?P("perform read-packets test"),
-    {V2, Trace2} = read_packets_test(R, RP, Msgs, Node),
+    {V2, Trace2} = read_packets_test(Config, R, RP, Msgs, Node),
     ?P("verify read-packets (to ~w)", [N2]),
-    {ok,[{read_packets,N2}]} = inet:getopts(R, [read_packets]),
+    {ok, [{read_packets,N2}]} = inet:getopts(R, [read_packets]),
     %%
     ?P("stop slave node"),
     stop_node(Node),
@@ -477,7 +616,7 @@ dump_terms(Config, Name, Terms) ->
     file:write_file(FName, term_to_binary(Terms)),
     ct:log("Logged terms to ~s",[FName]).
 
-read_packets_test(R, RP, Msgs, Node) ->
+read_packets_test(Config, R, RP, Msgs, Node) ->
     Receiver = self(),
     Tracer =
 	spawn_link(
@@ -491,8 +630,8 @@ read_packets_test(R, RP, Msgs, Node) ->
 	spawn_opt(
 	  Node,
 	  fun () ->
-		  {ok,S}  = gen_udp:open(0),
-		  {ok,SP} = inet:port(S),
+		  {ok, S}  = ?OPEN(Config, 0),
+		  {ok, SP} = inet:port(S),
 		  Receiver ! {self(),{port,SP}},
 		  receive
 		      {Receiver,go} ->
@@ -575,9 +714,9 @@ recv_poll_after_active_once(Config) when is_list(Config) ->
     Msg1 = <<"Hej!">>,
     Msg2 = <<"Hej igen!">>,
     Addr = {127,0,0,1},
-    {ok,S1} = gen_udp:open(0, [binary, {active, once}]),
+    {ok,S1} = ?OPEN(Config, 0, [binary, {active, once}]),
     {ok,P1} = inet:port(S1),
-    {ok,S2} = gen_udp:open(0, [binary, {active, false}]),
+    {ok,S2} = ?OPEN(Config, 0, [binary, {active, false}]),
     {ok,P2} = inet:port(S2),
     ok = gen_udp:send(S2, Addr, P1, Msg1),
     receive
@@ -592,32 +731,83 @@ recv_poll_after_active_once(Config) when is_list(Config) ->
 
 %% Test that the 'fd' option works.
 open_fd(Config) when is_list(Config) ->
+    ?TC_TRY(?FUNCTION_NAME, fun() -> do_open_fd(Config) end).
+
+do_open_fd(Config) when is_list(Config) ->
     Msg = "Det gör ont när knoppar brista. Varför skulle annars våren tveka?",
     Addr = {127,0,0,1},
-    {ok,S1}   = gen_udp:open(0),
-    {ok,P2} = inet:port(S1),
-    {ok,FD}   = prim_inet:getfd(S1),
-    {error,einval} = gen_udp:open(0, [inet6, {fd,FD}]),
-    {ok,S2}   = gen_udp:open(0, [{fd,FD}]),
-    {ok,S3}   = gen_udp:open(0),
-    {ok,P3} = inet:port(S3),
+    ?P("try open first (default domain = inet) socket and get its fd"),
+    {S1, FD} = case ?OPEN(Config, 0) of
+                   {ok, Sock1} when is_port(Sock1) ->
+                       {ok, FileDesc1} = prim_inet:getfd(Sock1),
+                       {Sock1, FileDesc1};
+                   {ok, Sock1} ->
+                      {ok, [{fd, FileDesc1}]} =
+                          gen_udp_socket:getopts(Sock1, [fd]),
+                      {Sock1, FileDesc1}
+               end,
+    ?P("try get the socket port number"),
+    {ok, P2} = inet:port(S1),
+
+    ?P("try open second (domain = inet6) socket with FD = ~w "
+       "and expect *failure*", [FD]),
+
+    case ?OPEN(Config, 0, [inet6, {fd,FD}]) of
+        {error, einval = Reason} ->
+            ?P("expected failure reason ~w", [Reason]),
+            ok;
+        {error, eafnosupport = Reason} ->
+            ?P("expected failure reason ~w (IPv6 not supported?)", [Reason]),
+            ok;
+        {error, Reason} ->
+            ?P("unexpected failure: ~w", [Reason]),
+            ct:fail({unexpected_failure, Reason});
+        {ok, Socket} ->
+            ?P("unexpected success: "
+               "~n   ~p", [inet:info(Socket)]),
+            (catch gen_udp:close(Socket)),
+            (catch gen_udp:close(S1)),
+            ct:fail(unexpected_succes)
+    end,
+
+    ?P("try open second socket with FD = ~w "
+       "and expect success", [FD]),
+    {ok, S2} = ?OPEN(Config, 0, [{fd, FD}]),
+    {ok, P2} = inet:port(S2),
+
+    ?P("try open third socket and expect success"),
+    {ok, S3} = ?OPEN(Config, 0),
+    {ok, P3} = inet:port(S3),
+
+    ?P("try send message from socket 3 to socket 2 (~w)", [P2]),
     ok = gen_udp:send(S3, Addr, P2, Msg),
     receive
-	{udp,S2,Addr,P3,Msg} ->
-	    ok = gen_udp:send(S2,Addr,P3,Msg),
+	{udp, S2, Addr, P3, Msg} ->
+            ?P("expected recv - "
+               "try send message from socket 2 to socket 3 (~w)", [P3]),
+	    ok = gen_udp:send(S2, Addr, P3, Msg),
 	    receive
-		{udp,S3,Addr,P2,Msg} ->
+		{udp, S3, Addr, P2, Msg} ->
+                    ?P("expected recv - done"),
 		    ok
 	    after 1000 ->
+                    ?P("unexpected timeout"),
 		    ct:fail(io_lib:format("~w", [flush()]))
 	    end
     after 1000 ->
+            ?P("unexpected timeout"),
 	    ct:fail(io_lib:format("~w", [flush()]))
-    end.
+    end,
+    ?P("cleanup"),
+    (catch gen_udp:close(S3)),
+    (catch gen_udp:close(S2)),
+    (catch gen_udp:close(S1)),
+    ?P("done"),
+    ok.
 
 active_n(Config) when is_list(Config) ->
     N = 3,
-    S1 = ok(gen_udp:open(0, [{active,N}])),
+    S1 = ok(?OPEN(Config, 0, [{active,N}])),
     [{active,N}] = ok(inet:getopts(S1, [active])),
     ok = inet:setopts(S1, [{active,-N}]),
     receive
@@ -667,7 +857,7 @@ active_n(Config) when is_list(Config) ->
     ok = inet:setopts(S1, [{active,false}]),
     [{active,false}] = ok(inet:getopts(S1, [active])),
     S1Port = ok(inet:port(S1)),
-    S2 = ok(gen_udp:open(0, [{active,N}])),
+    S2 = ok(?OPEN(Config, 0, [{active,N}])),
     S2Port = ok(inet:port(S2)),
     [{active,N}] = ok(inet:getopts(S2, [active])),
     ok = inet:setopts(S1, [{active,N}]),
@@ -705,7 +895,7 @@ active_n(Config) when is_list(Config) ->
         5000 ->
             exit({error,udp_passive})
     end,
-    S3 = ok(gen_udp:open(0, [{active,0}])),
+    S3 = ok(?OPEN(Config, 0, [{active,0}])),
     receive
         {udp_passive,S3} ->
             [{active,false}] = ok(inet:getopts(S3, [active]))
@@ -720,24 +910,27 @@ active_n(Config) when is_list(Config) ->
 
 
 
-recvtos(_Config) ->
+recvtos(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvtos,tos,96}], false,
       fun recvtos_ok/2).
 
-recvtosttl(_Config) ->
+recvtosttl(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvtos,tos,96},{recvttl,ttl,33}], false,
       fun (OSType, OSVer) ->
               recvtos_ok(OSType, OSVer) andalso recvttl_ok(OSType, OSVer)
       end).
 
-recvttl(_Config) ->
+recvttl(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvttl,ttl,33}], false,
       fun recvttl_ok/2).
 
-recvtclass(_Config) ->
+recvtclass(Config) ->
     {ok,IFs} = inet:getifaddrs(),
     case
         [Name ||
@@ -746,6 +939,7 @@ recvtclass(_Config) ->
     of
         [_] ->
             test_recv_opts(
+              Config,
               inet6, [{recvtclass,tclass,224}], false,
               fun recvtclass_ok/2);
         [] ->
@@ -753,36 +947,39 @@ recvtclass(_Config) ->
     end.
 
 
-sendtos(_Config) ->
-    ?TC_TRY(sendtos, fun() -> do_sendtos() end).
+sendtos(Config) ->
+    ?TC_TRY(sendtos, fun() -> do_sendtos(Config) end).
 
-do_sendtos() ->
+do_sendtos(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvtos,tos,96}], true,
       fun sendtos_ok/2).
 
-sendtosttl(_Config) ->
-    ?TC_TRY(sendtosttl, fun() -> do_sendtosttl() end).
+sendtosttl(Config) ->
+    ?TC_TRY(sendtosttl, fun() -> do_sendtosttl(Config) end).
 
-do_sendtosttl() ->
+do_sendtosttl(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvtos,tos,96},{recvttl,ttl,33}], true,
       fun (OSType, OSVer) ->
               sendtos_ok(OSType, OSVer) andalso sendttl_ok(OSType, OSVer)
       end).
 
-sendttl(_Config) ->
-    ?TC_TRY(sendttl, fun() -> do_sendttl() end).
+sendttl(Config) ->
+    ?TC_TRY(sendttl, fun() -> do_sendttl(Config) end).
 
-do_sendttl() ->
+do_sendttl(Config) ->
     test_recv_opts(
+      Config,
       inet, [{recvttl,ttl,33}], true,
       fun sendttl_ok/2).
 
-sendtclass(_Config) ->
-    ?TC_TRY(sendtclass, fun() -> do_sendtclass() end).
+sendtclass(Config) ->
+    ?TC_TRY(sendtclass, fun() -> do_sendtclass(Config) end).
 
-do_sendtclass() ->
+do_sendtclass(Config) ->
     {ok,IFs} = inet:getifaddrs(),
     case
         [Name ||
@@ -791,6 +988,7 @@ do_sendtclass() ->
     of
         [_] ->
             test_recv_opts(
+              Config,
               inet6, [{recvtclass,tclass,224}], true,
               fun sendtclass_ok/2);
         [] ->
@@ -893,18 +1091,19 @@ semver_lt(V1, {_,_,_} = V2) ->
        "~n   Version 2: ~p", [V1, V2]),
     false.
 
-test_recv_opts(Family, Spec, TestSend, OSFilter) ->
+test_recv_opts(Config, Family, Spec, TestSend, OSFilter) ->
     OSType = os:type(),
     OSVer  = os:version(),
     case OSFilter(OSType, OSVer) of
         true ->
             ?P("OS: ~p, ~p", [OSType, OSVer]),
-            test_recv_opts(Family, Spec, TestSend, OSType, OSVer);
+            test_recv_opts(Config,
+                           Family, Spec, TestSend, OSType, OSVer);
         false ->
             {skip,{not_supported_for_os_version,{OSType,OSVer}}}
     end.
 %%
-test_recv_opts(Family, Spec, TestSend, _OSType, _OSVer) ->
+test_recv_opts(Config, Family, Spec, TestSend, _OSType, _OSVer) ->
     Timeout = 5000,
     RecvOpts = [RecvOpt || {RecvOpt,_,_} <- Spec],
     TrueRecvOpts = [{RecvOpt,true} || {RecvOpt,_,_} <- Spec],
@@ -920,9 +1119,8 @@ test_recv_opts(Family, Spec, TestSend, _OSType, _OSVer) ->
                 {0,0,0,0,0,0,0,1}
         end,
     %%
-    {ok,S1} =
-        gen_udp:open(0, [Family,binary,{active,false}|TrueRecvOpts]),
-    {ok,P1} = inet:port(S1),
+    {ok, S1} = ?OPEN(Config, 0, [Family,binary,{active,false}|TrueRecvOpts]),
+    {ok, P1} = inet:port(S1),
     {ok,TrueRecvOpts} = inet:getopts(S1, RecvOpts),
     ok = inet:setopts(S1, FalseRecvOpts),
     {ok,FalseRecvOpts} = inet:getopts(S1, RecvOpts),
@@ -932,7 +1130,7 @@ test_recv_opts(Family, Spec, TestSend, _OSType, _OSVer) ->
     %% S1 now has true receive options and set option values
     %%
     {ok,S2} =
-        gen_udp:open(0, [Family,binary,{active,true}|FalseRecvOpts]),
+        ?OPEN(Config, 0, [Family,binary,{active,true}|FalseRecvOpts]),
     {ok,P2} = inet:port(S2),
     {ok,FalseRecvOpts_OptsVals2} = inet:getopts(S2, RecvOpts ++ Opts),
     OptsVals2 = FalseRecvOpts_OptsVals2 -- FalseRecvOpts,
@@ -1023,7 +1221,7 @@ verify_sets_eq(L1, L2) ->
     end.
 
 
-local_basic(_Config) ->
+local_basic(Config) ->
     SFile = local_filename(server),
     SAddr = {local,bin_filename(SFile)},
     CFile = local_filename(client),
@@ -1031,8 +1229,8 @@ local_basic(_Config) ->
     _ = file:delete(SFile),
     _ = file:delete(CFile),
     %%
-    S = ok(gen_udp:open(0, [{ifaddr,{local,SFile}},{active,false}])),
-    C = ok(gen_udp:open(0, [{ifaddr,{local,CFile}},{active,false}])),
+    S = ok(?OPEN(Config, 0, [{ifaddr,{local,SFile}},{active,false}])),
+    C = ok(?OPEN(Config, 0, [{ifaddr,{local,CFile}},{active,false}])),
     SAddr = ok(inet:sockname(S)),
     CAddr = ok(inet:sockname(C)),
     local_handshake(S, SAddr, C, CAddr),
@@ -1043,13 +1241,13 @@ local_basic(_Config) ->
     ok = file:delete(CFile),
     ok.
 
-local_unbound(_Config) ->
+local_unbound(Config) ->
     SFile = local_filename(server),
     SAddr = {local,bin_filename(SFile)},
     _ = file:delete(SFile),
     %%
-    S = ok(gen_udp:open(0, [{ifaddr,SAddr},{active,false}])),
-    C = ok(gen_udp:open(0, [local,{active,false}])),
+    S = ok(?OPEN(Config, 0, [{ifaddr,SAddr},{active,false}])),
+    C = ok(?OPEN(Config, 0, [local,{active,false}])),
     SAddr = ok(inet:sockname(S)),
     local_handshake(S, SAddr, C, undefined),
     ok = gen_udp:close(S),
@@ -1058,7 +1256,7 @@ local_unbound(_Config) ->
     ok = file:delete(SFile),
     ok.
 
-local_fdopen(_Config) ->
+local_fdopen(Config) ->
     SFile = local_filename(server),
     SAddr = {local,bin_filename(SFile)},
     CFile = local_filename(client),
@@ -1066,12 +1264,12 @@ local_fdopen(_Config) ->
     _ = file:delete(SFile),
     _ = file:delete(CFile),
     %%
-    S0 = ok(gen_udp:open(0, [{ifaddr,SAddr},{active,false}])),
-    C = ok(gen_udp:open(0, [{ifaddr,{local,CFile}},{active,false}])),
+    S0 = ok(?OPEN(Config, 0, [{ifaddr,SAddr},{active,false}])),
+    C  = ok(?OPEN(Config, 0, [{ifaddr,{local,CFile}},{active,false}])),
     SAddr = ok(inet:sockname(S0)),
     CAddr = ok(inet:sockname(C)),
     Fd = ok(prim_inet:getfd(S0)),
-    S = ok(gen_udp:open(0, [{fd,Fd},local,{active,false}])),
+    S  = ok(?OPEN(Config, 0, [{fd,Fd},local,{active,false}])),
     SAddr = ok(inet:sockname(S)),
     local_handshake(S, SAddr, C, CAddr),
     ok = gen_udp:close(S),
@@ -1082,16 +1280,16 @@ local_fdopen(_Config) ->
     ok = file:delete(CFile),
     ok.
 
-local_fdopen_unbound(_Config) ->
+local_fdopen_unbound(Config) ->
     SFile = local_filename(server),
     SAddr = {local,bin_filename(SFile)},
     _ = file:delete(SFile),
     %%
-    S = ok(gen_udp:open(0, [{ifaddr,SAddr},{active,false}])),
-    C0 = ok(gen_udp:open(0, [local,{active,false}])),
+    S  = ok(?OPEN(Config, 0, [{ifaddr,SAddr},{active,false}])),
+    C0 = ok(?OPEN(Config, 0, [local,{active,false}])),
     SAddr = ok(inet:sockname(S)),
     Fd = ok(prim_inet:getfd(C0)),
-    C = ok(gen_udp:open(0, [{fd,Fd},local,{active,false}])),
+    C  = ok(?OPEN(Config, 0, [{fd,Fd},local,{active,false}])),
     local_handshake(S, SAddr, C, undefined),
     ok = gen_udp:close(S),
     ok = gen_udp:close(C),
@@ -1100,11 +1298,11 @@ local_fdopen_unbound(_Config) ->
     ok = file:delete(SFile),
     ok.
 
-local_abstract(_Config) ->
+local_abstract(Config) ->
     case os:type() of
 	{unix,linux} ->
-	    S = ok(gen_udp:open(0, [{ifaddr,{local,<<>>}},{active,false}])),
-	    C = ok(gen_udp:open(0, [{ifaddr,{local,<<>>}},{active,false}])),
+	    S = ok(?OPEN(Config, 0, [{ifaddr,{local,<<>>}},{active,false}])),
+	    C = ok(?OPEN(Config, 0, [{ifaddr,{local,<<>>}},{active,false}])),
 	    {local,_} = SAddr = ok(inet:sockname(S)),
 	    {local,_} = CAddr = ok(inet:sockname(C)),
 	    local_handshake(S, SAddr, C, CAddr),
@@ -1139,7 +1337,7 @@ local_handshake(S, SAddr, C, CAddr) ->
 %% Then close the socket.
 recv_close(Config) when is_list(Config) ->
     ?P("begin"),
-    {ok, Sock} = gen_udp:open(0, [{active, false}]),
+    {ok, Sock} = ?OPEN(Config, 0, [{active, false}]),
     RECV = fun() ->
                    ?P("try recv"),
                    Res = gen_udp:recv(Sock, 0),
@@ -1183,10 +1381,10 @@ recv_close(Config) when is_list(Config) ->
 connect(Config) when is_list(Config) ->
     Addr = {127,0,0,1},
     ?P("try create first socket"),
-    {ok,S1} = gen_udp:open(0),
+    {ok,S1} = ?OPEN(Config, 0),
     {ok,P1} = inet:port(S1),
     ?P("try create second socket"),
-    {ok,S2} = gen_udp:open(0),
+    {ok,S2} = ?OPEN(Config, 0),
     ?P("try set second socket active: false"),
     ok = inet:setopts(S2, [{active,false}]),
     ?P("try close first socket"),
@@ -1212,7 +1410,7 @@ connect(Config) when is_list(Config) ->
 implicit_inet6(Config) when is_list(Config) ->
     ?TC_TRY(implicit_inet6, fun() -> do_implicit_inet6(Config) end).
 
-do_implicit_inet6(_Config) ->
+do_implicit_inet6(Config) ->
     Host = ok(inet:gethostname()),
     case inet:getaddr(Host, inet6) of
 	{ok, {16#fe80,0,0,0,_,_,_,_} = Addr} ->
@@ -1220,18 +1418,18 @@ do_implicit_inet6(_Config) ->
 	     "Got link local IPv6 address: "
 	     ++inet:ntoa(Addr)};
 	{ok, Addr} ->
-	    implicit_inet6(Host, Addr);
+	    implicit_inet6(Config, Host, Addr);
 	{error, Reason} ->
 	    {skip,
 	     "Can not look up IPv6 address: "
 	     ++atom_to_list(Reason)}
     end.
 
-implicit_inet6(Host, Addr) ->
+implicit_inet6(Config, Host, Addr) ->
     Active = {active,false},
     Loopback = {0,0,0,0,0,0,0,1},
     ?P("try 1 with explit inet6 on loopback"),
-    S1 = case gen_udp:open(0, [inet6, Active, {ip, Loopback}]) of
+    S1 = case ?OPEN(Config, 0, [inet6, Active, {ip, Loopback}]) of
              {ok, Sock1} ->
                  Sock1;
              {error, eaddrnotavail = Reason1} ->
@@ -1239,36 +1437,36 @@ implicit_inet6(Host, Addr) ->
              _ ->
                  ?SKIPT("IPv6 not supported")
          end,
-    implicit_inet6(S1, Active, Loopback),
+    implicit_inet6(Config, S1, Active, Loopback),
     ok = gen_udp:close(S1),
     %%
     Localaddr = ok(get_localaddr()),
     ?P("try 2 on local addr (~p)", [Localaddr]),
-    S2 = case gen_udp:open(0, [{ip, Localaddr}, Active]) of
+    S2 = case ?OPEN(Config, 0, [{ip, Localaddr}, Active]) of
              {ok, Sock2} ->
                  Sock2;
              {error, eaddrnotavail = Reason2} ->
                  ?SKIPT(open_failed_str(Reason2))
          end,
-    implicit_inet6(S2, Active, Localaddr),
+    implicit_inet6(Config, S2, Active, Localaddr),
     ok = gen_udp:close(S2),
     %%
     ?P("try 3 on addr ~p (~p)", [Addr, Host]),
-    S3 = case gen_udp:open(0, [{ifaddr, Addr}, Active]) of
+    S3 = case ?OPEN(Config, 0, [{ifaddr, Addr}, Active]) of
              {ok, Sock3} ->
                  Sock3;
              {error, eaddrnotavail = Reason3} ->
                  ?SKIPT(open_failed_str(Reason3))
          end,
-    implicit_inet6(S3, Active, Addr),
+    implicit_inet6(Config, S3, Active, Addr),
     ok = gen_udp:close(S3),
     ok.
 
-implicit_inet6(S1, Active, Addr) ->
+implicit_inet6(Config, S1, Active, Addr) ->
     ?P("get (\"local\") port number"),
     P1 = ok(inet:port(S1)),
     ?P("open \"remote\" socket"),
-    S2 = case gen_udp:open(0, [inet6, Active]) of
+    S2 = case ?OPEN(Config, 0, [inet6, Active]) of
              {ok, Sock2} ->
                  Sock2;
              {error, eaddrnotavail = Reason3} ->
@@ -1317,7 +1515,7 @@ do_otp_17492(Config) ->
     Self = self(),
 
     ?P("try create socket"),
-    {ok, L} = gen_udp:open(0, []),
+    {ok, L} = ?OPEN(Config, 0, []),
 
     ?P("try get (created) socket info"),
     try inet:info(L) of
diff --git a/lib/kernel/test/kernel_test_lib.erl b/lib/kernel/test/kernel_test_lib.erl
index 36ae71067d..59a089bdfc 100644
--- a/lib/kernel/test/kernel_test_lib.erl
+++ b/lib/kernel/test/kernel_test_lib.erl
@@ -26,6 +26,7 @@
 -export([socket_type/1,
 	 listen/3,
          connect/4, connect/5,
+         open/3,
          is_socket_backend/1,
          inet_backend_opts/1,
          explicit_inet_backend/0,
@@ -1735,6 +1736,8 @@ socket_type(Config) ->
 	    port
     end.
 
+%% gen_tcp wrappers
+
 listen(Config, Port, Opts) ->
     InetBackendOpts = inet_backend_opts(Config),
     gen_tcp:listen(Port, InetBackendOpts ++ Opts).
@@ -1748,6 +1751,13 @@ connect(Config, Host, Port, Opts, Timeout) ->
     gen_tcp:connect(Host, Port, InetBackendOpts ++ Opts, Timeout).
 
 
+%% gen_udp wrappers
+
+open(Config, Port, Opts) ->
+    InetBackendOpts = inet_backend_opts(Config),
+    gen_udp:open(Port, InetBackendOpts ++ Opts).
+
+
 inet_backend_opts(Config) when is_list(Config) ->
     case lists:keysearch(socket_create_opts, 1, Config) of
         {value, {socket_create_opts, InetBackendOpts}} ->
diff --git a/lib/kernel/test/kernel_test_lib.hrl b/lib/kernel/test/kernel_test_lib.hrl
index 3a8282971f..42f48dd502 100644
--- a/lib/kernel/test/kernel_test_lib.hrl
+++ b/lib/kernel/test/kernel_test_lib.hrl
@@ -43,6 +43,10 @@
         ?LIB:connect(__C__, __H__, __P__, __O__)).
 -define(CONNECT(__C__, __H__, __P__, __O__, __T__),
         ?LIB:connect(__C__, __H__, __P__, __O__, __T__)).
+
+-define(OPEN(C, P),              ?LIB:open(C, P, [])).
+-define(OPEN(C, P, O),           ?LIB:open(C, P, O)).
+
 -define(INET_BACKEND_OPTS(C),    ?LIB:inet_backend_opts(C)).
 -define(EXPLICIT_INET_BACKEND(), ?LIB:explicit_inet_backend()).
 -define(TEST_INET_BACKENDS(),    ?LIB:test_inet_backends()).
-- 
2.31.1

Places

File 1401-kernel-gen-udp-socket-Add-socket-based-gen_udp.patch of Package erlang (Revision e6fae69e60dcc1918fd2bc4ae52e9ff8)

Places