The R13B03 release.OTP_R13B03

1 files changed, 1342 insertions, 0 deletions

diff --git a/lib/kernel/src/inet.erl b/lib/kernel/src/inet.erl
new file mode 100644
index 0000000000..b86aa1839e
--- /dev/null
+++ b/lib/kernel/src/inet.erl
@@ -0,0 +1,1342 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(inet).
+
+-include("inet.hrl").
+-include("inet_int.hrl").
+-include("inet_sctp.hrl").
+
+%% socket
+-export([peername/1, sockname/1, port/1, send/2,
+	 setopts/2, getopts/2, 
+	 getif/1, getif/0, getiflist/0, getiflist/1,
+	 ifget/3, ifget/2, ifset/3, ifset/2,
+	 getstat/1, getstat/2,
+	 ip/1, stats/0, options/0, 
+	 pushf/3, popf/1, close/1, gethostname/0, gethostname/1]).
+
+-export([connect_options/2, listen_options/2, udp_options/2, sctp_options/2]).
+
+-export([i/0, i/1, i/2]).
+
+-export([getll/1, getfd/1, open/7, fdopen/5]).
+
+-export([tcp_controlling_process/2, udp_controlling_process/2,
+	 tcp_close/1, udp_close/1]).
+%% used by socks5
+-export([setsockname/2, setpeername/2]).
+
+%% resolve
+-export([gethostbyname/1, gethostbyname/2, gethostbyname/3, 
+	 gethostbyname_tm/3]).
+-export([gethostbyaddr/1, gethostbyaddr/2, 
+	 gethostbyaddr_tm/2]).
+
+-export([getservbyname/2, getservbyport/2]).
+-export([getaddrs/2, getaddrs/3, getaddrs_tm/3,
+	 getaddr/2, getaddr/3, getaddr_tm/3]).
+-export([translate_ip/2]).
+
+-export([get_rc/0]).
+
+%% format error
+-export([format_error/1]).
+
+%% timer interface
+-export([start_timer/1, timeout/1, timeout/2, stop_timer/1]).
+
+%% imports
+-import(lists, [append/1, duplicate/2, filter/2, foldl/3]).
+
+%% Record Signature
+-define(RS(Record),
+	{Record, record_info(size, Record)}).
+%% Record Signature Check (guard)
+-define(RSC(Record, RS),
+	element(1, Record) =:= element(1, RS),
+	tuple_size(Record) =:= element(2, RS)).
+
+%%% ---------------------------------
+%%% Contract type definitions
+
+-type socket() :: port().
+-type posix() :: atom().
+
+-type socket_setopt() ::
+      {'raw', non_neg_integer(), non_neg_integer(), binary()} |
+      %% TCP/UDP options
+      {'reuseaddr',       boolean()} |
+      {'keepalive',       boolean()} |
+      {'dontroute',       boolean()} |
+      {'linger',          {boolean(), non_neg_integer()}} |
+      {'broadcast',       boolean()} |
+      {'sndbuf',          non_neg_integer()} |
+      {'recbuf',          non_neg_integer()} |
+      {'priority',        non_neg_integer()} |
+      {'tos',             non_neg_integer()} |
+      {'nodelay',         boolean()} |
+      {'multicast_ttl',   non_neg_integer()} |
+      {'multicast_loop',  boolean()} |
+      {'multicast_if',    ip_address()} |
+      {'add_membership',  {ip_address(), ip_address()}} |
+      {'drop_membership', {ip_address(), ip_address()}} |
+      {'header',          non_neg_integer()} |
+      {'buffer',          non_neg_integer()} |
+      {'active',          boolean() | 'once'} |
+      {'packet',        
+       0 | 1 | 2 | 4 | 'raw' | 'sunrm' |  'asn1' |
+       'cdr' | 'fcgi' | 'line' | 'tpkt' | 'http' | 'httph' | 'http_bin' | 'httph_bin' } |
+      {'mode',           list() | binary()} |
+      {'port',           'port', 'term'} |
+      {'exit_on_close',   boolean()} |
+      {'low_watermark',   non_neg_integer()} |
+      {'high_watermark',  non_neg_integer()} |
+      {'bit8',            'clear' | 'set' | 'on' | 'off'} |
+      {'send_timeout',    non_neg_integer() | 'infinity'} |
+      {'send_timeout_close', boolean()} |
+      {'delay_send',      boolean()} |
+      {'packet_size',     non_neg_integer()} |
+      {'read_packets',    non_neg_integer()} |
+      %% SCTP options
+      {'sctp_rtoinfo',               #sctp_rtoinfo{}} |
+      {'sctp_associnfo',             #sctp_assocparams{}} |
+      {'sctp_initmsg',               #sctp_initmsg{}} |
+      {'sctp_nodelay',               boolean()} |
+      {'sctp_autoclose',             non_neg_integer()} |
+      {'sctp_disable_fragments',     boolean()} |
+      {'sctp_i_want_mapped_v4_addr', boolean()} |
+      {'sctp_maxseg',                non_neg_integer()} |
+      {'sctp_primary_addr',          #sctp_prim{}} |
+      {'sctp_set_peer_primary_addr', #sctp_setpeerprim{}} |
+      {'sctp_adaptation_layer',      #sctp_setadaptation{}} |
+      {'sctp_peer_addr_params',      #sctp_paddrparams{}} |
+      {'sctp_default_send_param',    #sctp_sndrcvinfo{}} |
+      {'sctp_events',                #sctp_event_subscribe{}} |
+      {'sctp_delayed_ack_time',      #sctp_assoc_value{}}.
+
+-type socket_getopt() ::
+      {'raw',
+       non_neg_integer(), non_neg_integer(), binary()|non_neg_integer()} |
+      %% TCP/UDP options
+      'reuseaddr' | 'keepalive' | 'dontroute' | 'linger' |
+      'broadcast' | 'sndbuf' | 'recbuf' | 'priority' | 'tos' | 'nodelay' | 
+      'multicast_ttl' | 'multicast_loop' | 'multicast_if' | 
+      'add_membership' | 'drop_membership' | 
+      'header' | 'buffer' | 'active' | 'packet' | 'mode' | 'port' | 
+      'exit_on_close' | 'low_watermark' | 'high_watermark' | 'bit8' | 
+      'send_timeout' | 'send_timeout_close' |
+      'delay_send' | 'packet_size' | 'read_packets' | 
+      %% SCTP options
+      {'sctp_status',                #sctp_status{}} |
+      'sctp_get_peer_addr_info' |
+      {'sctp_get_peer_addr_info',    #sctp_status{}} |
+      'sctp_rtoinfo' |
+      {'sctp_rtoinfo',               #sctp_rtoinfo{}} |
+      'sctp_associnfo' |
+      {'sctp_associnfo',             #sctp_assocparams{}} |
+      'sctp_initmsg' |
+      {'sctp_initmsg',               #sctp_initmsg{}} |
+      'sctp_nodelay' | 'sctp_autoclose' | 'sctp_disable_fragments' |
+      'sctp_i_want_mapped_v4_addr' | 'sctp_maxseg' |
+      {'sctp_primary_addr',          #sctp_prim{}} |
+      {'sctp_set_peer_primary_addr', #sctp_setpeerprim{}} |
+      'sctp_adaptation_layer' |
+      {'sctp_adaptation_layer',      #sctp_setadaptation{}} |
+      {'sctp_peer_addr_params',      #sctp_paddrparams{}} |
+      'sctp_default_send_param' |
+      {'sctp_default_send_param',    #sctp_sndrcvinfo{}} |
+      'sctp_events' |
+      {'sctp_events',                #sctp_event_subscribe{}} |
+      'sctp_delayed_ack_time' |
+      {'sctp_delayed_ack_time',      #sctp_assoc_value{}}.
+
+-type ether_address() :: [0..255].
+
+-type if_setopt() ::
+      {'addr', ip_address()} |
+      {'broadaddr', ip_address()} |
+      {'dstaddr', ip_address()} |
+      {'mtu', non_neg_integer()} |
+      {'netmask', ip_address()} |
+      {'flags', ['up' | 'down' | 'broadcast' | 'no_broadcast' |
+		 'pointtopoint' | 'no_pointtopoint' | 
+		 'running' | 'multicast']} |
+      {'hwaddr', ether_address()}.
+
+-type if_getopt() ::
+      'addr' | 'broadaddr' | 'dstaddr' | 
+      'mtu' | 'netmask' | 'flags' |'hwaddr'.
+
+-type family_option() :: 'inet' | 'inet6'.
+-type protocol_option() :: 'tcp' | 'udp' | 'sctp'.
+-type stat_option() :: 
+	'recv_cnt' | 'recv_max' | 'recv_avg' | 'recv_oct' | 'recv_dvi' |
+	'send_cnt' | 'send_max' | 'send_avg' | 'send_oct' | 'send_pend'.
+
+%%% ---------------------------------
+
+-spec get_rc() -> [{any(),any()}].
+
+get_rc() ->
+    inet_db:get_rc().
+
+-spec close(Socket :: socket()) -> 'ok'.
+
+close(Socket) ->
+    prim_inet:close(Socket),
+    receive
+	{Closed, Socket} when Closed =:= tcp_closed; Closed =:= udp_closed ->
+	    ok
+    after 0 ->
+	    ok
+    end.
+
+-spec peername(Socket :: socket()) -> 
+	{'ok', {ip_address(), non_neg_integer()}} | {'error', posix()}.
+
+peername(Socket) -> 
+    prim_inet:peername(Socket).
+
+-spec setpeername(Socket :: socket(), Address :: {ip_address(), ip_port()}) ->
+	'ok' | {'error', any()}.
+
+setpeername(Socket, {IP,Port}) ->
+    prim_inet:setpeername(Socket, {IP,Port});
+setpeername(Socket, undefined) ->
+    prim_inet:setpeername(Socket, undefined).
+
+
+-spec sockname(Socket :: socket()) -> 
+	{'ok', {ip_address(), non_neg_integer()}} | {'error', posix()}.
+
+sockname(Socket) -> 
+    prim_inet:sockname(Socket).
+
+-spec setsockname(Socket :: socket(), Address :: {ip_address(), ip_port()}) ->
+	'ok' | {'error', any()}.
+
+setsockname(Socket, {IP,Port}) -> 
+    prim_inet:setsockname(Socket, {IP,Port});
+setsockname(Socket, undefined) ->
+    prim_inet:setsockname(Socket, undefined).
+
+-spec port(Socket :: socket()) -> {'ok', ip_port()} | {'error', any()}.
+
+port(Socket) ->
+    case prim_inet:sockname(Socket) of
+	{ok, {_,Port}} -> {ok, Port};
+	Error -> Error
+    end.
+
+-spec send(Socket :: socket(), Packet :: iolist()) -> % iolist()?
+	'ok' | {'error', posix()}.
+
+send(Socket, Packet) -> 
+    prim_inet:send(Socket, Packet).
+    
+-spec setopts(Socket :: socket(), Opts :: [socket_setopt()]) -> 
+	'ok' | {'error', posix()}.
+
+setopts(Socket, Opts) -> 
+    prim_inet:setopts(Socket, Opts).
+
+-spec getopts(Socket :: socket(), Opts :: [socket_getopt()]) ->	
+	{'ok', [socket_setopt()]} | {'error', posix()}.
+
+getopts(Socket, Opts) ->
+    prim_inet:getopts(Socket, Opts).
+
+-spec getiflist(Socket :: socket()) ->
+	{'ok', [string()]} | {'error', posix()}.
+
+getiflist(Socket) -> 
+    prim_inet:getiflist(Socket).
+
+-spec getiflist() -> {'ok', [string()]} | {'error', posix()}.
+
+getiflist() -> 
+    withsocket(fun(S) -> prim_inet:getiflist(S) end).
+    
+-spec ifget(Socket :: socket(),
+            Name :: string() | atom(),
+	    Opts :: [if_getopt()]) ->
+	{'ok', [if_setopt()]} | {'error', posix()}.
+
+ifget(Socket, Name, Opts) -> 
+    prim_inet:ifget(Socket, Name, Opts).
+
+-spec ifget(Name :: string() | atom(), Opts :: [if_getopt()]) ->
+	{'ok', [if_setopt()]} | {'error', posix()}.
+
+ifget(Name, Opts) ->
+    withsocket(fun(S) -> prim_inet:ifget(S, Name, Opts) end).
+
+-spec ifset(Socket :: socket(),
+            Name :: string() | atom(),
+	    Opts :: [if_setopt()]) ->
+	'ok' | {'error', posix()}.
+
+ifset(Socket, Name, Opts) -> 
+    prim_inet:ifset(Socket, Name, Opts).
+
+-spec ifset(Name :: string() | atom(), Opts :: [if_setopt()]) ->
+	'ok' | {'error', posix()}.
+
+ifset(Name, Opts) ->
+    withsocket(fun(S) -> prim_inet:ifset(S, Name, Opts) end).
+
+-spec getif() ->
+	{'ok', [{ip_address(), ip_address() | 'undefined', ip_address()}]} | 
+	{'error', posix()}.
+
+getif() -> 
+    withsocket(fun(S) -> getif(S) end).
+
+%% backwards compatible getif
+-spec getif(Socket :: socket()) ->
+	{'ok', [{ip_address(), ip_address() | 'undefined', ip_address()}]} | 
+	{'error', posix()}.
+
+getif(Socket) ->
+    case prim_inet:getiflist(Socket) of
+	{ok, IfList} ->
+	    {ok, lists:foldl(
+		   fun(Name,Acc) ->
+			   case prim_inet:ifget(Socket,Name,
+						[addr,broadaddr,netmask]) of
+			       {ok,[{addr,A},{broadaddr,B},{netmask,M}]} ->
+				   [{A,B,M}|Acc];
+			       %% Some interfaces does not have a b-addr
+			       {ok,[{addr,A},{netmask,M}]} ->
+				   [{A,undefined,M}|Acc];
+			       _ ->
+				   Acc
+			   end
+		   end, [], IfList)};
+	Error -> Error
+    end.
+
+withsocket(Fun) ->
+    case inet_udp:open(0,[]) of
+	{ok,Socket} ->
+	    Res = Fun(Socket),
+	    inet_udp:close(Socket),
+	    Res;
+	Error ->
+	    Error
+    end.
+
+pushf(_Socket, Fun, _State) when is_function(Fun) ->
+    {error, einval}.
+
+popf(_Socket) ->
+    {error, einval}.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% the hostname is not cached any more because this
+% could cause troubles on at least windows with plug-and-play
+% and network-cards inserted and removed in conjunction with
+% use of the DHCP-protocol
+% should never fail
+
+-spec gethostname() -> {'ok', string()}.
+
+gethostname() ->
+    case inet_udp:open(0,[]) of
+	{ok,U} ->
+	    {ok,Res} = gethostname(U),
+	    inet_udp:close(U),
+	    {Res2,_} = lists:splitwith(fun($.)->false;(_)->true end,Res),
+	    {ok, Res2};
+	_ ->
+	    {ok, "nohost.nodomain"}
+    end.
+
+-spec gethostname(Socket :: socket()) ->
+	{'ok', string()} | {'error', posix()}.
+
+gethostname(Socket) ->
+    prim_inet:gethostname(Socket).
+
+-spec getstat(Socket :: socket()) ->
+	{'ok', [{stat_option(), integer()}]} | {'error', posix()}.
+
+getstat(Socket) ->
+    prim_inet:getstat(Socket, stats()).
+
+-spec getstat(Socket :: socket(), Statoptions :: [stat_option()]) ->
+	{'ok', [{stat_option(), integer()}]} | {'error', posix()}.
+
+getstat(Socket,What) ->
+    prim_inet:getstat(Socket, What).
+
+-spec gethostbyname(Name :: string() | atom()) ->
+	{'ok', #hostent{}} | {'error', posix()}.
+
+gethostbyname(Name) -> 
+    gethostbyname_tm(Name, inet, false).
+
+-spec gethostbyname(Name :: string() | atom(), Family :: family_option()) ->
+	{'ok', #hostent{}} | {'error', posix()}.
+
+gethostbyname(Name,Family) -> 
+    gethostbyname_tm(Name, Family, false).
+
+-spec gethostbyname(Name :: string() | atom(),
+	            Family :: family_option(),
+	            Timeout :: non_neg_integer() | 'infinity') ->
+	{'ok', #hostent{}} | {'error', posix()}.
+	
+gethostbyname(Name,Family,Timeout) ->
+    Timer = start_timer(Timeout),
+    Res = gethostbyname_tm(Name,Family,Timer),
+    stop_timer(Timer),
+    Res.
+
+gethostbyname_tm(Name,Family,Timer) ->
+    gethostbyname_tm(Name,Family,Timer,inet_db:res_option(lookup)).
+
+
+-spec gethostbyaddr(Address :: string() | ip_address()) ->
+	{'ok', #hostent{}} | {'error', posix()}.
+
+gethostbyaddr(Address) ->
+    gethostbyaddr_tm(Address, false).
+
+-spec gethostbyaddr(Address :: string() | ip_address(), 
+	            Timeout :: non_neg_integer() | 'infinity') ->
+	{'ok', #hostent{}} | {'error', posix()}.
+
+gethostbyaddr(Address,Timeout) ->
+    Timer = start_timer(Timeout),    
+    Res = gethostbyaddr_tm(Address, Timer),
+    stop_timer(Timer),
+    Res.
+
+gethostbyaddr_tm(Address,Timer) ->
+    gethostbyaddr_tm(Address, Timer, inet_db:res_option(lookup)).
+
+-spec ip(Ip :: ip_address() | string() | atom()) ->
+	{'ok', ip_address()} | {'error', posix()}.
+
+ip({A,B,C,D}) when ?ip(A,B,C,D) ->
+    {ok, {A,B,C,D}};
+ip(Name) ->
+    case gethostbyname(Name) of
+	{ok, Ent} ->
+	    {ok, hd(Ent#hostent.h_addr_list)};
+	Error -> Error
+    end.
+
+%% This function returns the erlang port used (with inet_drv)
+
+-spec getll(Socket :: socket()) -> {'ok', socket()}.
+
+getll(Socket) when is_port(Socket) ->
+    {ok, Socket}.
+
+%%
+%% Return the internal file descriptor number
+%%
+
+-spec getfd(Socket :: socket()) ->
+	{'ok', non_neg_integer()} | {'error', posix()}.
+
+getfd(Socket) ->
+    prim_inet:getfd(Socket).
+
+%%
+%% Lookup an ip address
+%%
+
+-spec getaddr(Host :: ip_address() | string() | atom(),
+	      Family :: family_option()) ->
+	{'ok', ip_address()} | {'error', posix()}.
+
+getaddr(Address, Family) ->
+    getaddr(Address, Family, infinity).
+
+-spec getaddr(Host :: ip_address() | string() | atom(),
+	      Family :: family_option(),
+	      Timeout :: non_neg_integer() | 'infinity') ->
+	{'ok', ip_address()} | {'error', posix()}.
+
+getaddr(Address, Family, Timeout) ->
+    Timer = start_timer(Timeout),
+    Res = getaddr_tm(Address, Family, Timer),
+    stop_timer(Timer),
+    Res.
+
+getaddr_tm(Address, Family, Timer) ->
+    case getaddrs_tm(Address, Family, Timer) of
+	{ok, [IP|_]} -> {ok, IP};
+	Error -> Error
+    end.
+
+-spec getaddrs(Host :: ip_address() | string() | atom(),
+	       Family :: family_option()) ->
+	{'ok', [ip_address()]} | {'error', posix()}.
+
+getaddrs(Address, Family) -> 
+    getaddrs(Address, Family, infinity).
+
+-spec getaddrs(Host :: ip_address() | string() | atom(),
+	       Family :: family_option(),
+	       Timeout :: non_neg_integer() | 'infinity') ->
+	{'ok', [ip_address()]} | {'error', posix()}.
+
+getaddrs(Address, Family, Timeout) ->
+    Timer = start_timer(Timeout),
+    Res = getaddrs_tm(Address, Family, Timer),
+    stop_timer(Timer),
+    Res.
+
+-spec getservbyport(Port :: ip_port(), Protocol :: atom() | string()) ->
+	{'ok', string()} | {'error', posix()}.
+
+getservbyport(Port, Proto) ->
+    case inet_udp:open(0, []) of
+	{ok,U} ->
+	    Res = prim_inet:getservbyport(U, Port, Proto),
+	    inet_udp:close(U),
+	    Res;
+	Error -> Error
+    end.
+
+-spec getservbyname(Name :: atom() | string(),
+	            Protocol :: atom() | string()) ->
+	{'ok', ip_port()} | {'error', posix()}.
+
+getservbyname(Name, Protocol) when is_atom(Name) ->
+    case inet_udp:open(0, []) of
+	{ok,U} ->
+	    Res = prim_inet:getservbyname(U, Name, Protocol),
+	    inet_udp:close(U),
+	    Res;
+	Error -> Error
+    end.
+
+%% Return a list of available options
+options() ->
+    [
+     tos, priority, reuseaddr, keepalive, dontroute, linger,
+     broadcast, sndbuf, recbuf, nodelay,
+     buffer, header, active, packet, deliver, mode,
+     multicast_if, multicast_ttl, multicast_loop,
+     exit_on_close, high_watermark, low_watermark,
+     bit8, send_timeout, send_timeout_close
+    ].
+
+%% Return a list of statistics options
+
+-spec stats() -> [stat_option(),...].
+
+stats() ->
+    [recv_oct, recv_cnt, recv_max, recv_avg, recv_dvi,
+     send_oct, send_cnt, send_max, send_avg, send_pend].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Available options for tcp:connect
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+connect_options() ->
+    [tos, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
+     header, active, packet, packet_size, buffer, mode, deliver,
+     exit_on_close, high_watermark, low_watermark, bit8, send_timeout,
+     send_timeout_close, delay_send,raw].
+    
+connect_options(Opts, Family) ->
+    BaseOpts = 
+	case application:get_env(kernel, inet_default_connect_options) of
+	    {ok,List} when is_list(List) ->
+		NList = [{active, true} | lists:keydelete(active,1,List)],     
+		#connect_opts{ opts = NList};
+	    {ok,{active,_Bool}} -> 
+		#connect_opts{ opts = [{active,true}]};
+	    {ok,Option} -> 
+		#connect_opts{ opts = [{active,true}, Option]};
+	    _ ->
+		#connect_opts{ opts = [{active,true}]}
+	end,
+    case con_opt(Opts, BaseOpts, connect_options()) of
+	{ok, R} ->
+	    {ok, R#connect_opts {
+		   ifaddr = translate_ip(R#connect_opts.ifaddr, Family)
+		  }};
+	Error -> Error	    
+    end.
+
+con_opt([{raw,A,B,C}|Opts],R,As) ->
+    con_opt([{raw,{A,B,C}}|Opts],R,As);
+con_opt([Opt | Opts], R, As) ->
+    case Opt of
+	{ip,IP}     -> con_opt(Opts, R#connect_opts { ifaddr = IP }, As);
+	{ifaddr,IP} -> con_opt(Opts, R#connect_opts { ifaddr = IP }, As);
+	{port,P}    -> con_opt(Opts, R#connect_opts { port = P }, As);
+	{fd,Fd}     -> con_opt(Opts, R#connect_opts { fd = Fd }, As);
+	binary      -> con_add(mode, binary, R, Opts, As);
+	list        -> con_add(mode, list, R, Opts, As);
+	{tcp_module,_}  -> con_opt(Opts, R, As);
+	inet        -> con_opt(Opts, R, As);
+	inet6       -> con_opt(Opts, R, As);
+	{Name,Val} when is_atom(Name) -> con_add(Name, Val, R, Opts, As);
+	_ -> {error, badarg}
+    end;
+con_opt([], R, _) ->
+    {ok, R}.
+
+con_add(Name, Val, R, Opts, AllOpts) ->
+    case add_opt(Name, Val, R#connect_opts.opts, AllOpts) of
+	{ok, SOpts} ->
+	    con_opt(Opts, R#connect_opts { opts = SOpts }, AllOpts);
+	Error -> Error
+    end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Available options for tcp:listen
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+listen_options() ->
+    [tos, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
+     header, active, packet, buffer, mode, deliver, backlog,
+     exit_on_close, high_watermark, low_watermark, bit8, send_timeout,
+     send_timeout_close, delay_send, packet_size,raw].
+
+listen_options(Opts, Family) ->
+    BaseOpts = 
+	case application:get_env(kernel, inet_default_listen_options) of
+	    {ok,List} when is_list(List) ->
+		NList = [{active, true} | lists:keydelete(active,1,List)],		       
+		#listen_opts{ opts = NList};
+	    {ok,{active,_Bool}} -> 
+		#listen_opts{ opts = [{active,true}]};
+	    {ok,Option} -> 
+		#listen_opts{ opts = [{active,true}, Option]};
+	    _ ->
+		#listen_opts{ opts = [{active,true}]}
+	end,
+    case list_opt(Opts, BaseOpts, listen_options()) of
+	{ok, R} ->
+	    {ok, R#listen_opts {
+		   ifaddr = translate_ip(R#listen_opts.ifaddr, Family)
+		  }};
+	Error -> Error
+    end.
+	
+list_opt([{raw,A,B,C}|Opts], R, As) ->
+    list_opt([{raw,{A,B,C}}|Opts], R, As);
+list_opt([Opt | Opts], R, As) ->
+    case Opt of
+	{ip,IP}      ->  list_opt(Opts, R#listen_opts { ifaddr = IP }, As);
+	{ifaddr,IP}  ->  list_opt(Opts, R#listen_opts { ifaddr = IP }, As);
+	{port,P}     ->  list_opt(Opts, R#listen_opts { port = P }, As);
+	{fd,Fd}      ->  list_opt(Opts, R#listen_opts { fd = Fd }, As);
+	{backlog,BL} ->  list_opt(Opts, R#listen_opts { backlog = BL }, As);
+	binary       ->  list_add(mode, binary, R, Opts, As);
+	list         ->  list_add(mode, list, R, Opts, As);
+	{tcp_module,_}  -> list_opt(Opts, R, As);
+	inet         -> list_opt(Opts, R, As);
+	inet6        -> list_opt(Opts, R, As);
+	{Name,Val} when is_atom(Name) -> list_add(Name, Val, R, Opts, As);
+	_ -> {error, badarg}
+    end;
+list_opt([], R, _SockOpts) ->
+    {ok, R}.
+
+list_add(Name, Val, R, Opts, As) ->
+    case add_opt(Name, Val, R#listen_opts.opts, As) of
+	{ok, SOpts} ->
+	    list_opt(Opts, R#listen_opts { opts = SOpts }, As);
+	Error -> Error
+    end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Available options for udp:open
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+udp_options() ->
+    [tos, priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode, 
+     deliver,
+     broadcast, dontroute, multicast_if, multicast_ttl, multicast_loop,
+     add_membership, drop_membership, read_packets,raw].
+
+
+udp_options(Opts, Family) ->
+    case udp_opt(Opts, #udp_opts { }, udp_options()) of
+	{ok, R} ->
+	    {ok, R#udp_opts {
+		   ifaddr = translate_ip(R#udp_opts.ifaddr, Family)
+		  }};
+	Error -> Error
+    end.
+
+udp_opt([{raw,A,B,C}|Opts], R, As) ->
+    udp_opt([{raw,{A,B,C}}|Opts], R, As);
+udp_opt([Opt | Opts], R, As) ->
+    case Opt of
+	{ip,IP}     ->  udp_opt(Opts, R#udp_opts { ifaddr = IP }, As);
+	{ifaddr,IP} ->  udp_opt(Opts, R#udp_opts { ifaddr = IP }, As);
+	{port,P}    ->  udp_opt(Opts, R#udp_opts { port = P }, As);
+	{fd,Fd}     ->  udp_opt(Opts, R#udp_opts { fd = Fd }, As);
+	binary      ->  udp_add(mode, binary, R, Opts, As);
+	list        ->  udp_add(mode, list, R, Opts, As);
+	{udp_module,_} -> udp_opt(Opts, R, As);
+	inet        -> udp_opt(Opts, R, As);
+	inet6       -> udp_opt(Opts, R, As);
+	{Name,Val} when is_atom(Name) -> udp_add(Name, Val, R, Opts, As);
+	_ -> {error, badarg}
+    end;
+udp_opt([], R, _SockOpts) ->
+    {ok, R}.
+
+udp_add(Name, Val, R, Opts, As) ->
+    case add_opt(Name, Val, R#udp_opts.opts, As) of
+	{ok, SOpts} ->
+	    udp_opt(Opts, R#udp_opts { opts = SOpts }, As);
+	Error -> Error
+    end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Available options for sctp:open
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%  Currently supported options include:
+%  (*) {mode,   list|binary}	 or just list|binary
+%  (*) {active, true|false|once}
+%  (*) {sctp_module, inet_sctp|inet6_sctp} or just inet|inet6
+%  (*) options set via setsockopt.
+%      The full list is below in sctp_options/0 .
+%  All other options are currently NOT supported. In particular:
+%  (*) multicast on SCTP is not (yet) supported, as it may be incompatible
+%      with automatic associations;
+%  (*) passing of open FDs ("fdopen") is not supported.
+sctp_options() ->
+[   % The following are generic inet options supported for SCTP sockets:
+    mode, active, buffer, tos, priority, dontroute, reuseaddr, linger, sndbuf,
+    recbuf,
+
+    % Other options are SCTP-specific (though they may be similar to their
+    % TCP and UDP counter-parts):
+    sctp_rtoinfo,   		 sctp_associnfo,	sctp_initmsg,
+    sctp_autoclose,		 sctp_nodelay,		sctp_disable_fragments,
+    sctp_i_want_mapped_v4_addr,  sctp_maxseg,		sctp_primary_addr,
+    sctp_set_peer_primary_addr,  sctp_adaptation_layer,	sctp_peer_addr_params,
+    sctp_default_send_param,	 sctp_events,		sctp_delayed_ack_time,
+    sctp_status,	   	 sctp_get_peer_addr_info
+].
+
+sctp_options(Opts, Mod)  ->
+    case sctp_opt(Opts, Mod, #sctp_opts{}, sctp_options()) of
+	{ok,#sctp_opts{ifaddr=undefined}=SO} -> 
+	    {ok,SO#sctp_opts{ifaddr=Mod:translate_ip(?SCTP_DEF_IFADDR)}};
+	{ok,_}=OK ->
+	    OK;
+	Error -> Error
+    end.
+
+sctp_opt([Opt|Opts], Mod, R, As) ->
+    case Opt of
+	{ip,IP} ->
+	    sctp_opt_ifaddr(Opts, Mod, R, As, IP);
+	{ifaddr,IP} ->
+	    sctp_opt_ifaddr(Opts, Mod, R, As, IP);
+	{port,Port} ->
+	    case Mod:getserv(Port) of
+		{ok,P} ->
+		    sctp_opt(Opts, Mod, R#sctp_opts{port=P}, As);
+		Error -> Error
+	    end;
+	binary		-> sctp_opt (Opts, Mod, R, As, mode, binary);
+	list		-> sctp_opt (Opts, Mod, R, As, mode, list);
+	{sctp_module,_}	-> sctp_opt (Opts, Mod, R, As); % Done with
+	inet		-> sctp_opt (Opts, Mod, R, As); % Done with
+	inet6		-> sctp_opt (Opts, Mod, R, As); % Done with
+	{Name,Val}	-> sctp_opt (Opts, Mod, R, As, Name, Val);
+	_ -> {error,badarg}
+    end;
+sctp_opt([], _Mod, R, _SockOpts) ->
+    {ok, R}.
+
+sctp_opt(Opts, Mod, R, As, Name, Val) ->
+    case add_opt(Name, Val, R#sctp_opts.opts, As) of
+	{ok,SocketOpts} ->
+	    sctp_opt(Opts, Mod, R#sctp_opts{opts=SocketOpts}, As);
+	Error -> Error
+    end.
+
+sctp_opt_ifaddr(Opts, Mod, #sctp_opts{ifaddr=IfAddr}=R, As, Addr) ->
+    IP = Mod:translate_ip(Addr),
+    sctp_opt(Opts, Mod, 
+	     R#sctp_opts{
+	       ifaddr=case IfAddr of
+			  undefined              -> IP;
+			  _ when is_list(IfAddr) -> [IP|IfAddr];
+			  _                      -> [IP,IfAddr]
+		      end}, As).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Util to check and insert option in option list
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+add_opt(Name, Val, Opts, As) ->
+    case lists:member(Name, As) of
+	true ->
+	    case prim_inet:is_sockopt_val(Name, Val) of
+		true ->
+		    Opts1 = lists:keydelete(Name, 1, Opts),
+		    {ok, [{Name,Val} | Opts1]};
+		false -> {error,badarg}
+	    end;
+	false -> {error,badarg}
+    end.
+	
+
+translate_ip(any,      inet) -> {0,0,0,0};
+translate_ip(loopback, inet) -> {127,0,0,1};
+translate_ip(any,      inet6) -> {0,0,0,0,0,0,0,0};
+translate_ip(loopback, inet6) -> {0,0,0,0,0,0,0,1};
+translate_ip(IP, _) -> IP.
+
+
+getaddrs_tm({A,B,C,D} = IP, Fam, _)  ->
+    %% Only "syntactic" validation and check of family.
+    if 
+	?ip(A,B,C,D) ->
+	    if
+		Fam =:= inet -> {ok,[IP]};
+		true -> {error,eafnosupport}
+	    end;
+	true -> {error,einval}
+    end;
+getaddrs_tm({A,B,C,D,E,F,G,H} = IP, Fam, _) ->
+    %% Only "syntactic" validation; we assume that the address was
+    %% "semantically" validated when it was converted to a tuple.
+    if 
+	?ip6(A,B,C,D,E,F,G,H) ->
+	    if
+		Fam =:= inet6 -> {ok,[IP]};
+		true -> {error,eafnosupport}
+	    end;
+	true -> {error,einval}
+    end;
+getaddrs_tm(Address, Family, Timer) when is_atom(Address) ->
+    getaddrs_tm(atom_to_list(Address), Family, Timer);
+getaddrs_tm(Address, Family, Timer) ->
+    case inet_parse:visible_string(Address) of
+	false ->
+	    {error,einval};
+	true ->
+	    %% Address is a host name or a valid IP address,
+	    %% either way check it with the resolver.
+	    case gethostbyname_tm(Address, Family, Timer) of
+		{ok,Ent} -> {ok,Ent#hostent.h_addr_list};
+		Error -> Error
+	    end
+    end.
+
+%%
+%% gethostbyname with option search
+%%
+gethostbyname_tm(Name, Type, Timer, [dns | Opts]) ->
+    Res = inet_res:gethostbyname_tm(Name, Type, Timer),
+    case Res of
+	{ok,_} -> Res;
+	{error,timeout} -> Res;
+	{error,formerr} -> {error,einval};
+	{error,_} -> gethostbyname_tm(Name,Type,Timer,Opts)
+    end;
+gethostbyname_tm(Name, Type, Timer, [file | Opts]) ->
+    case inet_hosts:gethostbyname(Name, Type) of
+	{error,formerr} -> {error,einval};
+	{error,_} -> gethostbyname_tm(Name,Type,Timer,Opts);
+	Result -> Result
+    end;
+gethostbyname_tm(Name, Type, Timer, [yp | Opts]) ->
+    gethostbyname_tm_native(Name, Type, Timer, Opts);
+gethostbyname_tm(Name, Type, Timer, [nis | Opts]) ->
+    gethostbyname_tm_native(Name, Type, Timer, Opts);
+gethostbyname_tm(Name, Type, Timer, [nisplus | Opts]) ->
+    gethostbyname_tm_native(Name, Type, Timer, Opts);
+gethostbyname_tm(Name, Type, Timer, [wins | Opts]) ->
+    gethostbyname_tm_native(Name, Type, Timer, Opts);
+gethostbyname_tm(Name, Type, Timer, [native | Opts]) ->
+    gethostbyname_tm_native(Name, Type, Timer, Opts);
+gethostbyname_tm(_, _, _, [no_default|_]) ->
+    %% If the native resolver has failed, we should not bother
+    %% to try to be smarter and parse the IP address here.
+    {error,nxdomain};
+gethostbyname_tm(Name, Type, Timer, [_ | Opts]) ->
+    gethostbyname_tm(Name, Type, Timer, Opts);
+%% Last resort - parse the hostname as address
+gethostbyname_tm(Name, inet, _Timer, []) ->
+    case inet_parse:ipv4_address(Name) of
+	{ok,IP4} ->
+	    {ok,make_hostent(Name, [IP4], [], inet)};
+	_ ->
+	    gethostbyname_self(Name)
+    end;
+gethostbyname_tm(Name, inet6, _Timer, []) ->
+    case inet_parse:ipv6_address(Name) of
+	{ok,IP6} ->
+	    {ok,make_hostent(Name, [IP6], [], inet6)};
+	_ ->
+	    %% Even if Name is a valid IPv4 address, we can't
+	    %% assume it's correct to return it on a IPv6
+	    %% format ( {0,0,0,0,0,16#ffff,?u16(A,B),?u16(C,D)} ).
+	    %% This host might not support IPv6.
+	    gethostbyname_self(Name)
+    end.
+
+gethostbyname_tm_native(Name, Type, Timer, Opts) ->
+    %% Fixme: add (global) timeout to gethost_native
+    case inet_gethost_native:gethostbyname(Name, Type) of
+	{error,formerr} -> {error,einval};
+	{error,timeout} -> {error,timeout};
+	{error,_} -> gethostbyname_tm(Name, Type, Timer, Opts++[no_default]);
+	Result -> Result
+    end.
+
+%% Make sure we always can look up our own hostname.
+gethostbyname_self(Name) ->
+    Type = case inet_db:res_option(inet6) of
+	       true -> inet6;
+	       false -> inet
+	   end,
+    case inet_db:gethostname() of
+	Name ->
+	    {ok,make_hostent(Name, [translate_ip(loopback, Type)],
+			 [], Type)};
+	Self ->
+	    case inet_db:res_option(domain) of
+		"" -> {error,nxdomain};
+		Domain ->
+		    case lists:append([Self,".",Domain]) of
+			Name ->
+			    {ok,make_hostent(Name,
+					     [translate_ip(loopback, Type)],
+					     [], Type)};
+			_ -> {error,nxdomain}
+		    end
+	    end
+    end.
+
+make_hostent(Name, Addrs, Aliases, Type) ->
+    #hostent{h_name = Name,
+	     h_aliases = Aliases,
+	     h_addrtype = Type,
+	     h_length = case Type of inet -> 4; inet6 -> 16 end,
+	     h_addr_list = Addrs}.
+
+%%
+%% gethostbyaddr with option search
+%%
+gethostbyaddr_tm(Addr, Timer, [dns | Opts]) ->
+    Res = inet_res:gethostbyaddr_tm(Addr,Timer),
+    case Res of
+	{ok,_} -> Res;
+	{error,timeout} -> Res;
+	{error,formerr} -> {error, einval};
+	{error,_} -> gethostbyaddr_tm(Addr,Timer,Opts)
+    end;    
+gethostbyaddr_tm(Addr, Timer, [file | Opts]) ->
+    case inet_hosts:gethostbyaddr(Addr) of
+	{error,formerr} -> {error, einval};
+	{error,_} -> gethostbyaddr_tm(Addr,Timer,Opts);
+	Result -> Result
+    end;
+gethostbyaddr_tm(Addr, Timer, [yp | Opts]) ->
+    gethostbyaddr_tm_native(Addr, Timer, Opts);
+gethostbyaddr_tm(Addr, Timer, [nis | Opts]) ->
+    gethostbyaddr_tm_native(Addr, Timer, Opts);
+gethostbyaddr_tm(Addr, Timer,  [nisplus | Opts]) ->
+    gethostbyaddr_tm_native(Addr, Timer, Opts);
+gethostbyaddr_tm(Addr, Timer, [wins | Opts]) ->
+    gethostbyaddr_tm_native(Addr, Timer, Opts);
+gethostbyaddr_tm(Addr, Timer, [native | Opts]) ->
+    gethostbyaddr_tm_native(Addr, Timer, Opts);
+gethostbyaddr_tm(Addr, Timer, [_ | Opts]) ->
+    gethostbyaddr_tm(Addr, Timer, Opts);
+gethostbyaddr_tm({127,0,0,1}=IP, _Timer, []) ->
+    gethostbyaddr_self(IP, inet);
+gethostbyaddr_tm({0,0,0,0,0,0,0,1}=IP, _Timer, []) ->
+    gethostbyaddr_self(IP, inet6);
+gethostbyaddr_tm(_Addr, _Timer, []) ->
+    {error, nxdomain}.
+
+gethostbyaddr_self(IP, Type) ->
+    Name = inet_db:gethostname(),
+    case inet_db:res_option(domain) of
+	"" ->
+	    {ok,make_hostent(Name, [IP], [], Type)};
+	Domain ->
+	    {ok,make_hostent(Name++"."++Domain, [IP], [Name], Type)}
+    end.
+	    
+gethostbyaddr_tm_native(Addr, Timer, Opts) ->
+    %% Fixme: user timer for timeoutvalue
+    case inet_gethost_native:gethostbyaddr(Addr) of
+	{error,formerr} -> {error, einval};
+	{error,_} -> gethostbyaddr_tm(Addr,Timer,Opts);
+	Result -> Result
+    end.
+
+-spec open(Fd :: integer(),
+	   Addr :: ip_address(),
+	   Port :: ip_port(),
+	   Opts :: [socket_setopt()],
+	   Protocol :: protocol_option(),
+	   Family :: 'inet' | 'inet6',
+	   Module :: atom()) ->
+	{'ok', socket()} | {'error', posix()}.
+
+open(Fd, Addr, Port, Opts, Protocol, Family, Module) when Fd < 0 ->
+    case prim_inet:open(Protocol, Family) of
+	{ok,S} ->
+	    case prim_inet:setopts(S, Opts) of
+		ok ->
+		    case if is_list(Addr) ->
+				 prim_inet:bind(S, add,
+						[case A of
+						     {_,_} -> A;
+						     _     -> {A,Port}
+						 end || A <- Addr]);
+			    true ->
+				 prim_inet:bind(S, Addr, Port)
+			 end of
+			{ok, _} -> 
+			    inet_db:register_socket(S, Module),
+			    {ok,S};
+			Error  ->
+			    prim_inet:close(S),
+			    Error
+		    end;
+		Error  ->
+		    prim_inet:close(S),
+		    Error
+	    end;
+	Error ->
+	    Error
+    end;
+open(Fd, _Addr, _Port, Opts, Protocol, Family, Module) ->
+    fdopen(Fd, Opts, Protocol, Family, Module).
+
+-spec fdopen(Fd :: non_neg_integer(),
+	     Opts :: [socket_setopt()],
+	     Protocol :: protocol_option(),
+	     Family :: family_option(),
+	     Module :: atom()) ->
+	{'ok', socket()} | {'error', posix()}.
+
+fdopen(Fd, Opts, Protocol, Family, Module) ->
+    case prim_inet:fdopen(Protocol, Fd, Family) of
+	{ok, S} ->
+	    case prim_inet:setopts(S, Opts) of
+		ok ->
+		    inet_db:register_socket(S, Module),
+		    {ok, S};
+		Error ->
+		    prim_inet:close(S), Error
+	    end;
+	Error -> Error
+    end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%  socket stat
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+i() -> i(tcp), i(udp).
+
+i(Proto) -> i(Proto, [port, module, recv, sent, owner,
+		      local_address, foreign_address, state]).
+
+i(tcp, Fs) ->
+    ii(tcp_sockets(), Fs, tcp);
+i(udp, Fs) ->
+    ii(udp_sockets(), Fs, udp).
+
+ii(Ss, Fs, Proto) ->
+    LLs = [h_line(Fs) | info_lines(Ss, Fs, Proto)],
+    Maxs = foldl(
+	     fun(Line,Max0) -> smax(Max0,Line) end, 
+	     duplicate(length(Fs),0),LLs),
+    Fmt = append(["~-" ++ integer_to_list(N) ++ "s " || N <- Maxs]) ++ "\n",
+    lists:foreach(fun(Line) -> io:format(Fmt, Line) end, LLs).
+
+smax([Max|Ms], [Str|Strs]) ->
+    N = length(Str),
+    [if N > Max -> N; true -> Max end | smax(Ms, Strs)];
+smax([], []) -> [].
+
+info_lines(Ss, Fs, Proto) -> [i_line(S, Fs,Proto) || S <- Ss].
+i_line(S, Fs, Proto)      -> [info(S, F, Proto) || F <- Fs].
+
+h_line(Fs) -> [h_field(atom_to_list(F)) || F <- Fs].
+
+h_field([C|Cs]) -> [upper(C) | hh_field(Cs)].
+
+hh_field([$_,C|Cs]) -> [$\s,upper(C) | hh_field(Cs)];
+hh_field([C|Cs]) -> [C|hh_field(Cs)];
+hh_field([]) -> [].
+
+upper(C) when C >= $a, C =< $z -> (C-$a) + $A;
+upper(C) -> C.
+
+    
+info(S, F, Proto) ->
+    case F of
+	owner ->
+	    case erlang:port_info(S, connected) of
+		{connected, Owner} -> pid_to_list(Owner);
+		_ -> " "
+	    end;
+	port ->
+	    case erlang:port_info(S,id) of
+		{id, Id}  -> integer_to_list(Id);
+		undefined -> " "
+	    end;
+	sent ->
+	    case prim_inet:getstat(S, [send_oct]) of
+		{ok,[{send_oct,N}]} -> integer_to_list(N);
+		_ -> " "
+	    end;
+	recv ->
+	    case  prim_inet:getstat(S, [recv_oct]) of
+		{ok,[{recv_oct,N}]} -> integer_to_list(N);
+		_ -> " "
+	    end;
+	local_address ->
+	    fmt_addr(prim_inet:sockname(S), Proto);
+	foreign_address ->
+	    fmt_addr(prim_inet:peername(S), Proto);
+	state ->
+	    case prim_inet:getstatus(S) of
+		{ok,Status} -> fmt_status(Status);
+		_ -> " "
+	    end;
+	packet ->
+	    case prim_inet:getopt(S, packet) of
+		{ok,Type} when is_atom(Type) -> atom_to_list(Type);
+		{ok,Type} when is_integer(Type) -> integer_to_list(Type);
+		_ -> " "
+	    end;
+	type ->
+	    case prim_inet:gettype(S) of
+		{ok,{_,stream}} -> "STREAM";
+		{ok,{_,dgram}}  -> "DGRAM";
+		_ -> " "
+	    end;
+	fd ->
+	    case prim_inet:getfd(S) of
+		{ok, Fd} -> integer_to_list(Fd);
+		_ -> " "
+	    end;
+	module ->
+	    case inet_db:lookup_socket(S) of
+		{ok,Mod} -> atom_to_list(Mod);
+		_ -> "prim_inet"
+	    end
+    end.
+%% Possible flags: (sorted)
+%% [accepting,bound,busy,connected,connecting,listen,listening,open]
+%%
+fmt_status(Flags) ->
+    case lists:sort(Flags) of
+	[accepting | _]               -> "ACCEPTING";
+	[bound,busy,connected|_]      -> "CONNECTED*";
+	[bound,connected|_]           -> "CONNECTED";
+	[bound,listen,listening | _]  -> "LISTENING";
+	[bound,listen | _]            -> "LISTEN";
+	[bound,connecting | _]        -> "CONNECTING";
+	[bound,open]                  -> "BOUND";
+	[open]                        -> "IDLE";
+	[]                            -> "CLOSED";
+	_                             -> "????"
+    end.
+
+fmt_addr({error,enotconn}, _) -> "*:*";
+fmt_addr({error,_}, _)        -> " ";
+fmt_addr({ok,Addr}, Proto) ->
+    case Addr of
+	%%Dialyzer {0,0}            -> "*:*";
+	{{0,0,0,0},Port} -> "*:" ++ fmt_port(Port, Proto);
+	{{0,0,0,0,0,0,0,0},Port} -> "*:" ++ fmt_port(Port, Proto);
+	{{127,0,0,1},Port} -> "localhost:" ++ fmt_port(Port, Proto);
+	{{0,0,0,0,0,0,0,1},Port} -> "localhost:" ++ fmt_port(Port, Proto);
+	{IP,Port} -> inet_parse:ntoa(IP) ++ ":" ++ fmt_port(Port, Proto)
+    end.
+
+fmt_port(N, Proto) ->
+    case inet:getservbyport(N, Proto) of
+	{ok, Name} -> Name;
+	_ -> integer_to_list(N)
+    end.
+
+%% Return a list of all tcp sockets
+tcp_sockets() -> port_list("tcp_inet").
+udp_sockets() -> port_list("udp_inet").
+
+%% Return all ports having the name 'Name'
+port_list(Name) ->
+    filter(
+      fun(Port) ->
+	      case erlang:port_info(Port, name) of
+		  {name, Name} -> true;
+		  _ -> false
+	      end
+      end, erlang:ports()).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%  utils
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-spec format_error(posix()) -> string().
+
+format_error(exbadport) -> "invalid port state";
+format_error(exbadseq) ->  "bad command sequence";
+format_error(Tag) ->
+    erl_posix_msg:message(Tag).
+
+%% Close a TCP socket.
+tcp_close(S) when is_port(S) ->
+    %% if exit_on_close is set we must force a close even if remotely closed!!!
+    prim_inet:close(S),
+    receive {tcp_closed, S} -> ok after 0 -> ok end.
+
+%% Close a UDP socket.
+udp_close(S) when is_port(S) ->
+    receive 
+	{udp_closed, S} -> ok
+    after 0 ->
+	    prim_inet:close(S),
+	    receive {udp_closed, S} -> ok after 0 -> ok end
+    end.
+
+%% Set controlling process for TCP socket.
+tcp_controlling_process(S, NewOwner) when is_port(S), is_pid(NewOwner) ->
+    case erlang:port_info(S, connected) of
+	{connected, Pid} when Pid =/= self() ->
+	    {error, not_owner};
+	undefined ->
+	    {error, einval};
+	_ ->
+	    case prim_inet:getopt(S, active) of
+		{ok, A0} ->
+		    prim_inet:setopt(S, active, false),
+		    case tcp_sync_input(S, NewOwner, false) of
+			true ->  %% socket already closed, 
+			    ok;
+			false ->
+			    try erlang:port_connect(S, NewOwner) of
+				true -> 
+				    unlink(S), %% unlink from port
+				    prim_inet:setopt(S, active, A0),
+				    ok
+			    catch
+				error:Reason -> 
+				    {error, Reason}
+			    end
+		    end;
+		Error ->
+		    Error
+	    end
+    end.
+
+tcp_sync_input(S, Owner, Flag) ->
+    receive
+	{tcp, S, Data} ->
+	    Owner ! {tcp, S, Data},
+	    tcp_sync_input(S, Owner, Flag);
+	{tcp_closed, S} ->
+	    Owner ! {tcp_closed, S},
+	    tcp_sync_input(S, Owner, true);
+	{S, {data, Data}} ->
+	    Owner ! {S, {data, Data}},
+	    tcp_sync_input(S, Owner, Flag);	    
+	{inet_async, S, Ref, Status} ->
+	    Owner ! {inet_async, S, Ref, Status},
+	    tcp_sync_input(S, Owner, Flag);
+	{inet_reply, S, Status} ->
+	    Owner ! {inet_reply, S, Status},
+	    tcp_sync_input(S, Owner, Flag)
+    after 0 -> 
+	    Flag
+    end.
+
+%% Set controlling process for UDP or SCTP socket.
+udp_controlling_process(S, NewOwner) when is_port(S), is_pid(NewOwner) ->
+    case erlang:port_info(S, connected) of
+	{connected, Pid} when Pid =/= self() ->
+	    {error, not_owner};
+	_ ->
+	    {ok, A0} = prim_inet:getopt(S, active),
+	    prim_inet:setopt(S, active, false),
+	    udp_sync_input(S, NewOwner),
+	    try erlang:port_connect(S, NewOwner) of
+		true -> 
+		    unlink(S),
+		    prim_inet:setopt(S, active, A0),
+		    ok
+	    catch
+		error:Reason -> 
+		    {error, Reason}
+	    end
+    end.
+
+udp_sync_input(S, Owner) ->
+    receive
+	{sctp, S, _, _, _}=Msg    -> udp_sync_input(S, Owner, Msg);
+	{udp, S, _, _, _}=Msg     -> udp_sync_input(S, Owner, Msg);
+	{udp_closed, S}=Msg       -> udp_sync_input(S, Owner, Msg);
+	{S, {data,_}}=Msg         -> udp_sync_input(S, Owner, Msg);
+	{inet_async, S, _, _}=Msg -> udp_sync_input(S, Owner, Msg);
+	{inet_reply, S, _}=Msg    -> udp_sync_input(S, Owner, Msg)
+    after 0 ->
+	    ok
+    end.
+
+udp_sync_input(S, Owner, Msg) ->
+    Owner ! Msg,
+    udp_sync_input(S, Owner).
+
+start_timer(infinity) -> false;
+start_timer(Timeout) ->
+    erlang:start_timer(Timeout, self(), inet).
+
+timeout(false) -> infinity;
+timeout(Timer) ->
+    case erlang:read_timer(Timer) of
+	false -> 0;
+	Time  -> Time
+    end.
+
+timeout(Time, false) -> Time;
+timeout(Time, Timer) ->
+    TimerTime = timeout(Timer),
+    if TimerTime < Time -> TimerTime;
+       true -> Time
+    end.
+
+stop_timer(false) -> false;
+stop_timer(Timer) ->
+    case erlang:cancel_timer(Timer) of
+	false ->
+	    receive
+		{timeout,Timer,_} -> false
+	    after 0 ->
+		    false
+	    end;
+	T -> T
+    end.