/lib/kernel/src/inet.erl
Erlang | 1342 lines | 1049 code | 187 blank | 106 comment | 9 complexity | 446dc994267cd4487d3f2be2a48b0ab3 MD5 | raw file
Possible License(s): BSD-2-Clause, LGPL-2.1, MPL-2.0-no-copyleft-exception
- %%
- %% %CopyrightBegin%
- %%
- %% Copyright Ericsson AB 1997-2011. 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,
- getifaddrs/0, getifaddrs/1,
- 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([gethostbyname_string/2, gethostbyname_self/2]).
- -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]).
- -export_type([address_family/0, hostent/0, hostname/0, ip4_address/0,
- ip6_address/0, ip_address/0, posix/0, socket/0,
- port_number/0]).
- %% 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 hostent() :: #hostent{}.
- -type hostname() :: atom() | string().
- -type ip4_address() :: {0..255,0..255,0..255,0..255}.
- -type ip6_address() :: {0..65535,0..65535,0..65535,0..65535,
- 0..65535,0..65535,0..65535,0..65535}.
- -type ip_address() :: ip4_address() | ip6_address().
- -type port_number() :: 0..65535.
- -type posix() :: exbadport | exbadseq | file:posix().
- -type socket() :: port().
- -type socket_setopt() ::
- gen_sctp:option() | gen_tcp:option() | gen_udp:option().
- -type socket_getopt() ::
- gen_sctp:option_name() | gen_tcp:option_name() | gen_udp:option_name().
- -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 address_family() :: '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() -> [{Par :: any(), Val :: any()}].
- get_rc() ->
- inet_db:get_rc().
- -spec close(Socket) -> 'ok' when
- Socket :: socket().
- close(Socket) ->
- prim_inet:close(Socket),
- receive
- {Closed, Socket} when Closed =:= tcp_closed; Closed =:= udp_closed ->
- ok
- after 0 ->
- ok
- end.
- -spec peername(Socket) -> {ok, {Address, Port}} | {error, posix()} when
- Socket :: socket(),
- Address :: ip_address(),
- Port :: non_neg_integer().
- peername(Socket) ->
- prim_inet:peername(Socket).
- -spec setpeername(Socket :: socket(), Address :: {ip_address(), port_number()}) ->
- 'ok' | {'error', any()}.
- setpeername(Socket, {IP,Port}) ->
- prim_inet:setpeername(Socket, {IP,Port});
- setpeername(Socket, undefined) ->
- prim_inet:setpeername(Socket, undefined).
- -spec sockname(Socket) -> {ok, {Address, Port}} | {error, posix()} when
- Socket :: socket(),
- Address :: ip_address(),
- Port :: non_neg_integer().
- sockname(Socket) ->
- prim_inet:sockname(Socket).
- -spec setsockname(Socket :: socket(), Address :: {ip_address(), port_number()}) ->
- 'ok' | {'error', any()}.
- setsockname(Socket, {IP,Port}) ->
- prim_inet:setsockname(Socket, {IP,Port});
- setsockname(Socket, undefined) ->
- prim_inet:setsockname(Socket, undefined).
- -spec port(Socket) -> {'ok', Port} | {'error', any()} when
- Socket :: socket(),
- Port :: port_number().
- 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, Options) -> ok | {error, posix()} when
- Socket :: socket(),
- Options :: [socket_setopt()].
- setopts(Socket, Opts) ->
- prim_inet:setopts(Socket, Opts).
- -spec getopts(Socket, Options) ->
- {'ok', OptionValues} | {'error', posix()} when
- Socket :: socket(),
- Options :: [socket_getopt()],
- OptionValues :: [socket_setopt()].
- getopts(Socket, Opts) ->
- prim_inet:getopts(Socket, Opts).
- -spec getifaddrs(Socket :: socket()) ->
- {'ok', [string()]} | {'error', posix()}.
- getifaddrs(Socket) ->
- prim_inet:getifaddrs(Socket).
- -spec getifaddrs() -> {ok, Iflist} | {error, posix()} when
- Iflist :: [{Ifname,[Ifopt]}],
- Ifname :: string(),
- Ifopt :: {flag,[Flag]} | {addr,Addr} | {netmask,Netmask}
- | {broadaddr,Broadaddr} | {dstaddr,Dstaddr}
- | {hwaddr,Hwaddr},
- Flag :: up | broadcast | loopback | pointtopoint
- | running | multicast,
- Addr :: ip_address(),
- Netmask :: ip_address(),
- Broadaddr :: ip_address(),
- Dstaddr :: ip_address(),
- Hwaddr :: [byte()].
- getifaddrs() ->
- withsocket(fun(S) -> prim_inet:getifaddrs(S) end).
- -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', Hostname} when
- Hostname :: 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) ->
- {ok, OptionValues} | {error, posix()} when
- Socket :: socket(),
- OptionValues :: [{stat_option(), integer()}].
- getstat(Socket) ->
- prim_inet:getstat(Socket, stats()).
- -spec getstat(Socket, Options) ->
- {ok, OptionValues} | {error, posix()} when
- Socket :: socket(),
- Options :: [stat_option()],
- OptionValues :: [{stat_option(), integer()}].
- getstat(Socket,What) ->
- prim_inet:getstat(Socket, What).
- -spec gethostbyname(Hostname) -> {ok, Hostent} | {error, posix()} when
- Hostname :: hostname(),
- Hostent :: hostent().
- gethostbyname(Name) ->
- gethostbyname_tm(Name, inet, false).
- -spec gethostbyname(Hostname, Family) ->
- {ok, Hostent} | {error, posix()} when
- Hostname :: hostname(),
- Family :: address_family(),
- Hostent :: hostent().
- gethostbyname(Name,Family) ->
- gethostbyname_tm(Name, Family, false).
- -spec gethostbyname(Name :: hostname(),
- Family :: address_family(),
- 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) ->
- Opts0 = inet_db:res_option(lookup),
- Opts =
- case (lists:member(native, Opts0) orelse
- lists:member(string, Opts0) orelse
- lists:member(nostring, Opts0)) of
- true ->
- Opts0;
- false ->
- [string|Opts0]
- end,
- gethostbyname_tm(Name, Family, Timer, Opts).
- -spec gethostbyaddr(Address) -> {ok, Hostent} | {error, posix()} when
- Address :: string() | ip_address(),
- Hostent :: hostent().
- 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, Family) -> {ok, Address} | {error, posix()} when
- Host :: ip_address() | hostname(),
- Family :: address_family(),
- Address :: ip_address().
- getaddr(Address, Family) ->
- getaddr(Address, Family, infinity).
- -spec getaddr(Host :: ip_address() | hostname(),
- Family :: address_family(),
- 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, Family) ->
- {ok, Addresses} | {error, posix()} when
- Host :: ip_address() | hostname(),
- Family :: address_family(),
- Addresses :: [ip_address()].
- getaddrs(Address, Family) ->
- getaddrs(Address, Family, infinity).
- -spec getaddrs(Host :: ip_address() | string() | atom(),
- Family :: address_family(),
- 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 :: port_number(), 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', port_number()} | {'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, [string|_]=Opts) ->
- Result = gethostbyname_string(Name, Type),
- gethostbyname_tm(Name, Type, Timer, Opts, Result);
- gethostbyname_tm(Name, Type, Timer, [dns|_]=Opts) ->
- Result = inet_res:gethostbyname_tm(Name, Type, Timer),
- gethostbyname_tm(Name, Type, Timer, Opts, Result);
- gethostbyname_tm(Name, Type, Timer, [file|_]=Opts) ->
- Result = inet_hosts:gethostbyname(Name, Type),
- gethostbyname_tm(Name, Type, Timer, Opts, Result);
- 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(Name, Type, Timer, [_|_]=Opts) ->
- gethostbyname_tm(Name, Type, Timer, Opts);
- %% Make sure we always can look up our own hostname.
- gethostbyname_tm(Name, Type, Timer, []) ->
- Result = gethostbyname_self(Name, Type),
- gethostbyname_tm(Name, Type, Timer, [], Result).
- gethostbyname_tm(Name, Type, Timer, Opts, Result) ->
- case Result of
- {ok,_} ->
- Result;
- {error,formerr} ->
- {error,einval};
- {error,_} when Opts =:= [] ->
- {error,nxdomain};
- {error,_} ->
- gethostbyname_tm(Name, Type, Timer, tl(Opts))
- end.
- gethostbyname_tm_native(Name, Type, Timer, Opts) ->
- %% Fixme: add (global) timeout to gethost_native
- Result = inet_gethost_native:gethostbyname(Name, Type),
- gethostbyname_tm(Name, Type, Timer, Opts, Result).
- gethostbyname_self(Name, Type) when is_atom(Name) ->
- gethostbyname_self(atom_to_list(Name), Type);
- gethostbyname_self(Name, Type)
- when is_list(Name), Type =:= inet;
- is_list(Name), Type =:= inet6 ->
- 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;
- gethostbyname_self(_, _) ->
- {error,formerr}.
- gethostbyname_string(Name, Type) when is_atom(Name) ->
- gethostbyname_string(atom_to_list(Name), Type);
- gethostbyname_string(Name, Type)
- when is_list(Name), Type =:= inet;
- is_list(Name), Type =:= inet6 ->
- case
- case Type of
- inet ->
- inet_parse:ipv4_address(Name);
- inet6 ->
- %% XXX should we really translate IPv4 addresses here
- %% even if we do not know if this host can do IPv6?
- inet_parse:ipv6_address(Name)
- end of
- {ok,IP} ->
- {ok,make_hostent(Name, [IP], [], Type)};
- {error,einval} ->
- {error,nxdomain}
- end;
- gethostbyname_string(_, _) ->
- {error,formerr}.
- 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 :: port_number(),
- 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 :: address_family(),
- 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() when
- Posix :: posix().
- 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.