%%% @copyright 2010-2023 Michael Santos <michael.santos@gmail.com>
%%% All rights reserved.
%%%
%%% Redistribution and use in source and binary forms, with or without
%%% modification, are permitted provided that the following conditions
%%% are met:
%%%
%%% 1. Redistributions of source code must retain the above copyright notice,
%%% this list of conditions and the following disclaimer.
%%%
%%% 2. Redistributions in binary form must reproduce the above copyright
%%% notice, this list of conditions and the following disclaimer in the
%%% documentation and/or other materials provided with the distribution.
%%%
%%% 3. Neither the name of the copyright holder nor the names of its
%%% contributors may be used to endorse or promote products derived from
%%% this software without specific prior written permission.
%%%
%%% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
%%% "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
%%% LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
%%% A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
%%% HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
%%% SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
%%% TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
%%% PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
%%% LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
%%% NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
%%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%% @doc gen_icmp is an interface for using ICMP and ICMPv6 sockets
%%
%% gen_icmp uses raw sockets and abuses gen_udp for the socket
%% handling. gen_icmp should work on Linux and BSDs.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:ping("hex.pm").
%% [{ok,"hex.pm",
%% {35,241,14,39},
%% {35,241,14,39},
%% {61261,0,116,215},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% '''
-module(gen_icmp).
-behaviour(gen_server).
-include_lib("kernel/include/inet.hrl").
-include_lib("pkt/include/pkt.hrl").
-define(PING_TIMEOUT, 5000).
-export([
open/0, open/1, open/2,
close/1,
send/3,
controlling_process/2,
setopts/2,
family/1,
getfd/1,
set_ttl/3,
get_ttl/2,
filter/1, filter/2,
icmp6_filter_setpassall/0,
icmp6_filter_setblockall/0,
icmp6_filter_setpass/2,
icmp6_filter_setblock/2,
icmp6_filter_willpass/2,
icmp6_filter_willblock/2
]).
-export([recv/2, recv/3]).
-export([ping/1, ping/2, ping/3]).
-export([
echo/3, echo/4,
packet/2, packet/3,
parse/1, parse/2,
gettime/0,
timediff/1, timediff/2
]).
-export([addr_list/3]).
-export([start_link/2, start/2]).
%% gen_server callbacks
-export([
init/1,
handle_call/3,
handle_cast/2,
handle_info/2,
terminate/2,
code_change/3
]).
-type uint8_t() :: 0..16#ff.
-type uint16_t() :: 0..16#ffff.
-type uint32_t() :: 0..16#ffffffff.
-type int32_t() :: -16#7fffffff..16#7fffffff.
-type fd() :: int32_t().
-type socket() :: pid().
-type icmp6_filter() :: <<_:256>>.
% ping details
-type id() :: uint16_t().
-type sequence() :: uint16_t().
-type ttlx() :: uint8_t().
% ICMP packet time to live (renamed to avoid conflict with ttl() defined in the pkt header file)
-type elapsed() :: int32_t() | undefined.
-type packet_option() ::
{type, atom | uint8_t()}
| {code, atom | uint8_t()}
| {id, id()}
| {sequence, sequence()}
| {gateway, pkt:in_addr()}
| {un, binary()}
| {mtu, uint16_t()}
| {pointer, uint8_t() | uint32_t()}
| {ts_orig, uint32_t()}
| {ts_recv, uint32_t()}
| {ts_tx, uint32_t()}
| {maxdelay, uint16_t()}
| {saddr, pkt:in6_addr()}
| {daddr, pkt:in6_addr()}
| {len, non_neg_integer()}
| {next, uint8_t()}.
-export_type([
uint8_t/0,
uint16_t/0,
uint32_t/0,
int32_t/0,
fd/0,
socket/0,
icmp6_filter/0,
id/0,
sequence/0,
ttlx/0,
elapsed/0,
packet_option/0
]).
-record(state, {
% Protocol family (inet, inet6)
family = inet :: inet | inet6,
% caller PID
pid :: pid(),
% socket file descriptor
fd :: fd(),
% udp socket
s :: gen_udp:socket()
}).
-record(ping_opt, {
s,
id,
sequence,
timeout,
tref,
timestamp = true
}).
-record(icmp6_pseudohdr, {
saddr = {0, 0, 0, 0, 0, 0, 0, 0},
daddr = {0, 0, 0, 0, 0, 0, 0, 0},
len = 0,
next = ?IPPROTO_ICMPV6,
h = #icmp6{}
}).
%% @doc Open an ICMP socket.
%%
%% By default, the ICMP socket is opened in {active,false} mode. No
%% packets will be received by the socket. setopts/2 can be used
%% to place the socket in {active,true} mode.
%%
%% gen_icmp first attempts to natively open the socket and falls
%% back to forking the setuid helper program if beam does not have
%% the appropriate privileges. Privileges to open a raw socket can
%% be given by, for example, running as root or, on Linux, granting
%% the CAP_NET_RAW capability to beam:
%%
%% setcap cap_net_raw=ep /usr/local/lib/erlang/erts-5.8.3/bin/beam.smp
%%
%% Only the owning process will receive ICMP packets (see
%% controlling_process/2 to change the owner). The process owning the
%% raw socket will receive all ICMP packets sent to the host.
%%
%% Messages sent to the controlling process are:
%%
%% {icmp, Socket, Address, TTL, Packet}
%%
%% Where:
%%
%% * Socket is the pid of the gen_icmp process
%%
%% * Address is a tuple representing the IPv4 or IPv6 source address
%%
%% * TTL: IPv4: TTL taken from the IP header
%%
%% * TTL: IPv6: the socket's hop limit returned from
%% getsockopt(IPV6_UNICAST_HOPS) (this is not the packet's
%% TTL, it is the socket's max TTL)
%%
%% * Packet is the complete ICMP packet including the ICMP headers
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:open().
%% {ok,<0.299.0>}
%% '''
-spec open() -> {ok, socket()} | {error, system_limit | inet:posix()}.
open() ->
open([], []).
%% @doc Open an ICMP socket with raw socket options.
%%
%% See the https://github.com/msantos/procket for the raw socket options
%% and for instructions on setting up the setuid helper.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:open([{ttl, 1}, inet6]).
%% {ok,<0.302.0>}
%% '''
-spec open(proplists:proplist()) -> {ok, socket()} | {error, system_liimt | inet:posix()}.
open(RawOpts) ->
open(RawOpts, []).
%% @doc Open an ICMP socket with options.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:open([{ttl, 1}, inet6], [list]).
%% {ok,<0.302.0>}
%% '''
-spec open(proplists:proplist(), [inet:inet_backend() | gen_udp:open_option()]) ->
{ok, socket()} | {error, system_liimt | inet:posix()}.
open(RawOpts, SockOpts) ->
start_link(RawOpts, SockOpts).
%% @doc Close the ICMP socket.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open().
%% {ok,<0.224.0>}
%% 2> gen_icmp:close(S).
%% ok
%% '''
-spec close(socket()) -> ok.
close(Socket) when is_pid(Socket) ->
gen_server:call(Socket, close, infinity).
%% @doc Send data via an ICMP socket.
%%
%% Like the gen_udp and gen_tcp modules, any process can send ICMP
%% packets but only the owner will receive the responses.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open().
%% {ok,<0.224.0>}
%% 2>gen_icmp:send(S, "google.com", gen_icmp:echo(inet, 0, 0)).
%% ok
%% 3> gen_icmp:recv(S, 1).
%% {ok,{{142,251,32,78},
%% <<69,0,0,84,0,0,0,0,116,1,214,38,142,251,32,78,100,115,
%% 92,198,0,0,19,125,0,...>>}}
%% 4> gen_icmp:close(S).
%% ok
%% '''
-spec send(
socket(),
{inet:ip_address(), inet:port_number()}
| inet:family_address()
| socket:sockaddr_in()
| socket:sockaddr_in6(),
iodata()
) -> ok | {error, not_owner | inet:posix()}.
send(Socket, Address, Packet) when is_pid(Socket) ->
gen_server:call(Socket, {send, Address, Packet}, infinity).
%% @doc Read data from an ICMP socket.
%%
%% This function receives a packet from a socket in passive mode.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open().
%% {ok,<0.224.0>}
%% 2>gen_icmp:send(S, "google.com", gen_icmp:echo(inet, 0, 0)).
%% ok
%% 3> gen_icmp:recv(S, 1).
%% {ok,{{142,251,32,78},
%% <<69,0,0,84,0,0,0,0,116,1,214,38,142,251,32,78,100,115,
%% 92,198,0,0,19,125,0,...>>}}
%% 4> gen_icmp:close(S).
%% ok
%% '''
-spec recv(socket(), non_neg_integer()) ->
{ok, inet:ip_address() | inet:returned_non_ip_address(), string() | binary()}
| {error, not_owner | timeout | inet:posix()}.
recv(Socket, Length) ->
recv(Socket, Length, infinity).
%% @doc Read data from an ICMP socket with timeout.
%%
%% The optional Timeout parameter specifies a timeout in
%% milliseconds. The default value is infinity.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open().
%% {ok,<0.299.0>}
%% 2> gen_icmp:send(S, "google.com", gen_icmp:echo(inet, 0, 0)).
%% ok
%% 3> gen_icmp:recv(S, 1, 5000).
%% {ok,{{142,251,41,78},
%% <<69,0,0,84,0,0,0,0,116,1,205,38,142,251,41,78,100,115,
%% 92,198,0,0,100,77,0,...>>}}
%% 4> gen_icmp:recv(S, 1, 5000).
%% {error,timeout}
%% 5> gen_icmp:close(S).
%% ok
%% '''
-spec recv(socket(), non_neg_integer(), timeout()) ->
{ok, inet:ip_address() | inet:returned_non_ip_address(), string() | binary()}
| {error, not_owner | timeout | inet:posix()}.
recv(Socket, Length, Timeout) ->
gen_server:call(Socket, {recv, Length, Timeout}, infinity).
%% @doc Change the controlling process of the ICMP socket.
%%
%% Change the process owning the socket. Allows another process to
%% receive the ICMP responses.
-spec controlling_process(socket(), pid()) -> ok.
controlling_process(Socket, Pid) when is_pid(Socket), is_pid(Pid) ->
gen_server:call(Socket, {controlling_process, Pid}, infinity).
%% @doc Set socket options.
%%
%% For options, see the inet man page. Simply calls inet:setopts/2 on
%% the gen_udp socket.
%%
%% setopts/2 can be used to toggle the socket between passive and
%% active mode.
%%
%% == Examples ==
%%
%% ```
%% {ok, Socket} = gen_icmp:open(), % socket is {active,false}
%% ok = gen_icmp:setopts(Socket, [{active, true}]),
%% % do stuff with the socket
%% ok = gen_icmp:setopts(Socket, [{active, false}]).
%% '''
-spec setopts(socket(), [inet:socket_setopt()]) -> ok | {error, inet:posix()}.
setopts(Socket, Options) when is_pid(Socket), is_list(Options) ->
gen_server:call(Socket, {setopts, Options}, infinity).
%% @doc Get socket family.
%%
%% Returns the socket family: `inet' (IPv4), `inet6' (IPv6)
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open([inet6]).
%% {ok,<0.224.0>}
%% 2> gen_icmp:family(S).
%% inet6
%% '''
-spec family(socket()) -> inet | inet6.
family(Socket) when is_pid(Socket) ->
gen_server:call(Socket, family, infinity).
%% @doc Get underlying file descriptor for socket.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open().
%% {ok,<0.221.0>}
%% 2> gen_icmp:getfd(S).
%% 20
%% '''
-spec getfd(socket()) -> fd().
getfd(Socket) when is_pid(Socket) ->
gen_server:call(Socket, getfd, infinity).
%% @doc Get ICMPv6 socket filter.
%%
%% Retrieves the ICMPv6 filter for a socket. For ICMPv4
%% sockets, the atom `unsupported' is returned.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open([inet6]).
%% {ok,<0.299.0>}
%% 2> gen_icmp:filter(S).
%% {ok,<<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
%% 0,0,...>>}
%% '''
-spec filter(socket()) -> {ok, icmp6_filter()} | {error, unsupported | inet:posix()}.
filter(Socket) when is_pid(Socket) ->
gen_server:call(Socket, filter, infinity).
%% @doc Set ICMPv6 socket filter.
%%
%% Sets an ICMPv6 filter on a socket. For ICMPv4 sockets, the atom
%% `unsupported' is returned.
%%
%% Filters can be generated by using the icmp6_filter functions.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open([inet6]).
%% {ok,<0.299.0>}
%% 2> gen_icmp:filter(S, gen_icmp:icmp6_filter_setpassall()).
%% ok
%% '''
-spec filter(socket(), icmp6_filter()) -> ok | {error, unsupported | inet:posix()}.
filter(Socket, Filter) when is_pid(Socket) ->
gen_server:call(Socket, {filter, Filter}, infinity).
%% @doc Send an ICMP ECHO_REQUEST.
%%
%% ping/1 is a convenience function to send a single ping
%% packet. The argument to ping/1 can be either a hostname or a
%% list of hostnames.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:ping("google.com").
%% [{ok,"google.com",
%% {142,251,41,46},
%% {142,251,41,46},
%% {61261,0,116,84},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% '''
%%
%% @see ping/3
-spec ping(inet:socket_address() | inet:hostname() | [inet:socket_address() | inet:hostname()]) ->
[
{ok, inet:socket_address() | inet:hostname(), inet:ip_address(), inet:ip_address(),
{id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, unreach_host | timxceed_intrans, [inet:socket_address() | inet:hostname()],
inet:ip_address(), inet:ip_address(), {id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, timeout | inet:posix(), [inet:socket_address() | inet:hostname()],
inet:ip_address()}
].
ping(Host) ->
ping(Host, []).
%% @doc Send an ICMP ECHO_REQUEST with options.
%%
%% Ping a host or a list of hosts.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:ping("google.com", [inet6]).
%% [{ok,"google.com",
%% {9735,63664,16395,2052,0,0,0,8206},
%% {9735,63664,16395,2052,0,0,0,8206},
%% {61261,0,64,53},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% '''
%%
%% @see ping/3
-spec ping(
inet:socket_address() | inet:hostname() | [inet:socket_address() | inet:hostname()],
proplists:proplist()
) ->
[
{ok, inet:socket_address() | inet:hostname(), inet:ip_address(), inet:ip_address(),
{id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, unreach_host | timxceed_intrans, [inet:socket_address() | inet:hostname()],
inet:ip_address(), inet:ip_address(), {id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, timeout | inet:posix(), [inet:socket_address() | inet:hostname()],
inet:ip_address()}
].
ping(Host, Options) when is_tuple(Host) ->
ping([Host], Options);
ping([Char | _] = Host, Options) when is_integer(Char) ->
ping([Host], Options);
ping(Hosts, Options) ->
{ok, Socket} = gen_icmp:open(Options),
Res = ping(Socket, Hosts, Options),
gen_icmp:close(Socket),
Res.
%% @doc Send an ICMP ECHO_REQUEST.
%%
%% To prevent the process mailbox from being flooded with ICMP
%% messages, ping/3 will put the socket into `{active,false}' mode
%% after completing.
%%
%% The ping/3 function blocks until either an ICMP ECHO REPLY is
%% received from all hosts or Timeout is reached.
%%
%% Id and sequence are used to differentiate ping responses. Usually,
%% the sequence is incremented for each ping in one run.
%%
%% A list of responses is returned. If the ping was successful,
%% the elapsed time in milliseconds is included (calculated by
%% subtracting the current time from the time we sent in the ICMP
%% ECHO packet and returned to us in the ICMP ECHOREPLY payload)
%% where:
%%
%% * Host: the provided hostname
%%
%% * Address: the resolved IPv4 or IPv6 network address represented
%% as a 4 or 8-tuple used in the ICMP echo request
%%
%% * ReplyAddr: the IPv4 or IPv6 network address originating the
%% ICMP echo reply
%%
%% The timeout is set for all ICMP packets and is set after all
%% packets have been sent out.
%%
%% By default only one address per hostname is pinged. To
%% enable pinging all addresses per hostname pass `{multi, true}'
%% to options.
%%
%% A ping payload contains an 8 byte timestamp in microseconds. When
%% creating a custom payload, the first 8 bytes of the ICMP echo
%% reply payload will be used for calculating the elapsed time. To
%% disable this behaviour, use the option {timestamp,false} (the
%% elapsed time in the return value will be set to 0).
%%
%% The timeout defaults to 5 seconds.
%%
%% ICMPv6 sockets can restrict which ICMPv6 types are received by the
%% socket using the filter option. The filter argument is a binary
%% generated using the icmp6_filter functions described below.
%%
%% The default filter allows: ICMP6_ECHO_REPLY, ICMP6_DST_UNREACH,
%% ICMP6_PACKET_TOO_BIG, ICMP6_TIME_EXCEEDED and ICMP6_PARAM_PROB.
%% Note: ping/3 does not restore the original filter on the socket.
%%
%% == Examples ==
%%
%% ```
%% 1> {ok, S} = gen_icmp:open([inet6]).
%% {ok,<0.299.0>}
%% 2> gen_icmp:ping(S, ["google.com"], []).
%% [{ok,"google.com",
%% {9735,63664,16395,2051,0,0,0,8206},
%% {9735,63664,16395,2051,0,0,0,8206},
%% {61261,0,64,110},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% 3> gen_icmp:ping(S, ["2001:4860:4860::8888"], []).
%% [{ok,"2001:4860:4860::8888",
%% {8193,18528,18528,0,0,0,0,34952},
%% {8193,18528,18528,0,0,0,0,34952},
%% {61261,0,64,20},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% 4> gen_icmp:ping(S, ["2001:4860:4860::8888", "google.com"], []).
%% [{ok,"google.com",
%% {9735,63664,16395,2051,0,0,0,8206},
%% {9735,63664,16395,2051,0,0,0,8206},
%% {61261,1,64,23},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>},
%% {ok,"2001:4860:4860::8888",
%% {8193,18528,18528,0,0,0,0,34952},
%% {8193,18528,18528,0,0,0,0,34952},
%% {61261,0,64,23},
%% <<" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO">>}]
%% 5> gen_icmp:close(S).
%% ok
%% '''
-spec ping(socket(), [inet:socket_address() | inet:hostname()], proplists:proplist()) ->
[
{ok, inet:socket_address() | inet:hostname(), inet:ip_address(), inet:ip_address(),
{id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, unreach_host | timxceed_intrans, [inet:socket_address() | inet:hostname()],
inet:ip_address(), inet:ip_address(), {id(), sequence(), ttlx(), elapsed()}, binary()}
| {error, timeout | inet:posix(), [inet:socket_address() | inet:hostname()],
inet:ip_address()}
].
ping(Socket, Hosts, Options) when is_pid(Socket), is_list(Hosts), is_list(Options) ->
ok = setopts(Socket, [{active, true}]),
Family = family(Socket),
Id = proplists:get_value(id, Options, erlang:phash2(self(), 16#FFFF)),
Seq = proplists:get_value(sequence, Options, 0),
Data = proplists:get_value(data, Options, payload(echo)),
Timeout = proplists:get_value(timeout, Options, ?PING_TIMEOUT),
Timestamp = proplists:get_value(timestamp, Options, true),
Multi = proplists:get_value(multi, Options, false),
ICMP6_filter = lists:foldl(
fun(T, X) ->
gen_icmp:icmp6_filter_setpass(T, X)
end,
gen_icmp:icmp6_filter_setblockall(),
[
echo_reply,
dst_unreach,
packet_too_big,
time_exceeded,
param_prob
]
),
Filter = proplists:get_value(filter, Options, ICMP6_filter),
ok =
case Family of
inet6 ->
filter(Socket, Filter);
_ ->
ok
end,
Hosts2 = addr_list(Family, Hosts, Multi),
{Addresses, Errors, _} = lists:foldl(
fun
({ok, Host, Addr}, {NHosts, Nerr, NSeq}) ->
{[{ok, Host, Addr, NSeq} | NHosts], Nerr, NSeq + 1};
(Err, {NHosts, Nerr, NSeq}) ->
{NHosts, [Err | Nerr], NSeq}
end,
{[], [], Seq},
Hosts2
),
Result =
case Addresses of
[] ->
Errors;
_ ->
[
spawn(fun() ->
gen_icmp:send(Socket, Addr, gen_icmp:echo(Family, Id, S, Data))
end)
|| {ok, _Host, Addr, S} <- Addresses
],
{Timeouts, Replies} = ping_reply(Addresses, #ping_opt{
s = Socket,
id = Id,
timeout = Timeout,
timestamp = Timestamp
}),
Errors ++ Timeouts ++ Replies
end,
ok = setopts(Socket, [{active, false}]),
flush_events(Socket),
Result.
%%-------------------------------------------------------------------------
%%% Callbacks
%%-------------------------------------------------------------------------
%% @private
start_link(RawOpts, SockOpts) ->
Pid = self(),
gen_server:start_link(?MODULE, [Pid, RawOpts, SockOpts], []).
%% @private
start(RawOpts, SockOpts) ->
Pid = self(),
case gen_server:start(?MODULE, [Pid, RawOpts, SockOpts], []) of
{ok, Socket} -> {ok, Socket};
{error, Error} -> Error
end.
%% @private
init([Pid, RawOpts, SockOpts]) ->
process_flag(trap_exit, true),
{Protocol, Family} =
case proplists:get_value(inet6, RawOpts, false) of
false -> {icmp, inet};
true -> {'ipv6-icmp', inet6}
end,
Result =
case procket:socket(Family, raw, Protocol) of
{error, eperm} ->
procket:open(0, RawOpts ++ [{protocol, Protocol}, {type, raw}, {family, Family}]);
N ->
N
end,
init_1(Pid, Family, RawOpts, SockOpts, Result).
init_1(Pid, Family, RawOpts, SockOpts0, {ok, FD}) ->
TTL = proplists:get_value(ttl, RawOpts),
_ =
case TTL of
undefined -> ok;
_ -> set_ttl(FD, Family, TTL)
end,
SockOpts =
case proplists:is_defined(active, SockOpts0) of
true -> SockOpts0;
false -> SockOpts0 ++ [{active, false}]
end,
case gen_udp:open(0, SockOpts ++ [binary, {fd, FD}, Family]) of
{ok, Socket} ->
{ok, #state{
family = Family,
pid = Pid,
fd = FD,
s = Socket
}};
Error ->
Error
end;
init_1(_Pid, _Family, _RawOpts, _SockOpts, Error) ->
{stop, Error}.
%% @private
handle_call(close, {Pid, _}, #state{pid = Pid, s = Socket} = State) ->
{stop, normal, gen_udp:close(Socket), State};
handle_call({send, IP, Packet}, _From, #state{s = Socket} = State) ->
{reply, gen_udp:send(Socket, IP, 0, Packet), State};
handle_call({recv, Length, Timeout}, {Pid, _}, #state{pid = Pid, s = Socket} = State) ->
Reply =
case gen_udp:recv(Socket, Length, Timeout) of
{ok, {Address, _Port, Packet}} -> {ok, {Address, Packet}};
N -> N
end,
{reply, Reply, State};
handle_call({controlling_process, Pid}, {Owner, _}, #state{pid = Owner} = State) ->
{reply, ok, State#state{pid = Pid}};
handle_call({setopts, Options}, {Pid, _}, #state{pid = Pid, s = Socket} = State) ->
{reply, inet:setopts(Socket, Options), State};
handle_call(family, _From, #state{family = Family} = State) ->
{reply, Family, State};
handle_call(getfd, _From, #state{fd = Socket} = State) ->
{reply, Socket, State};
handle_call(filter, _From, #state{family = inet6, fd = Socket} = State) ->
Reply = procket:getsockopt(Socket, ?IPPROTO_ICMPV6, icmp6_filter(), <<0:256>>),
{reply, Reply, State};
handle_call(filter, _From, State) ->
{reply, unsupported, State};
handle_call({filter, Filter}, _From, #state{family = inet6, fd = Socket} = State) ->
Reply = procket:setsockopt(Socket, ?IPPROTO_ICMPV6, icmp6_filter(), Filter),
{reply, Reply, State};
handle_call({filter, _Filter}, _From, State) ->
{reply, unsupported, State};
handle_call(Request, From, State) ->
error_logger:info_report([{call, Request}, {from, From}, {state, State}]),
{reply, error, State}.
%% @private
handle_cast(Msg, State) ->
error_logger:info_report([{cast, Msg}, {state, State}]),
{noreply, State}.
%% @private
% IPv4 ICMP
handle_info(
{udp, Socket, {_, _, _, _} = Saddr, 0,
<<4:4, HL:4, _ToS:8, _Len:16, _Id:16, 0:1, _DF:1, _MF:1, _Off:13, TTL:8, ?IPPROTO_ICMP:8,
_Sum:16, _SA1:8, _SA2:8, _SA3:8, _SA4:8, _DA1:8, _DA2:8, _DA3:8, _DA4:8, Data/binary>>},
#state{pid = Pid, s = Socket} = State
) ->
N = (HL - 5) * 4,
Opt =
if
N > 0 -> N;
true -> 0
end,
<<_:Opt/bits, Payload/bits>> = Data,
Pid ! {icmp, self(), Saddr, TTL, Payload},
{noreply, State};
% IPv6 ICMP
handle_info(
{udp, Socket, {_, _, _, _, _, _, _, _} = Saddr, 0, Data},
#state{pid = Pid, fd = FD, s = Socket} = State
) ->
{ok, TTL} = get_ttl(FD, inet6),
Pid ! {icmp, self(), Saddr, TTL, Data},
{noreply, State};
handle_info({'EXIT', _, normal}, State) ->
{noreply, State};
handle_info(Info, State) ->
error_logger:info_report([{info, Info}, {state, State}]),
{noreply, State}.
%% @private
terminate(_Reason, #state{fd = Socket}) ->
procket:close(Socket),
ok.
%% @private
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
%%-------------------------------------------------------------------------
%%% Utility Functions
%%-------------------------------------------------------------------------
%% @doc Create an ICMP packet.
%%
%% Convenience function for creating arbitrary ICMP packets. This
%% function will calculate the ICMP checksum and insert it into the
%% packet.
%%
%% == Examples ==
%%
%% ```
%% 1> rr("_build/default/lib/pkt/include/pkt_icmp.hrl").
%% [icmp]
%% 2> gen_icmp:packet(#icmp{}, <<"abc">>).
%% <<8,0,51,157,0,0,0,0,97,98,99>>
%% '''
-spec packet(#icmp{} | #icmp6_pseudohdr{} | [packet_option()], binary()) -> binary().
packet(#icmp{} = Header, Payload) when is_binary(Payload) ->
Sum = pkt:makesum(
list_to_binary([
pkt:icmp(Header),
Payload
])
),
list_to_binary([
pkt:icmp(Header#icmp{checksum = Sum}),
Payload
]);
packet(
#icmp6_pseudohdr{
saddr = {SA1, SA2, SA3, SA4, SA5, SA6, SA7, SA8},
daddr = {DA1, DA2, DA3, DA4, DA5, DA6, DA7, DA8},
len = Len,
next = Next,
h = Header
},
Payload
) when is_binary(Payload) ->
Sum = pkt:makesum(
list_to_binary([
<<SA1, SA2, SA3, SA4, SA5, SA6, SA7, SA8, DA1, DA2, DA3, DA4, DA5, DA6, DA7, DA8,
Len:32, 0:24, Next:8>>,
pkt:icmp6(Header),
Payload
])
),
list_to_binary([
pkt:icmp6(Header#icmp6{checksum = Sum}),
Payload
]);
packet(Header, Payload) when is_list(Header) ->
packet(inet, Header, Payload).
%% @doc Construct an ICMP or ICMPv6 packet payload.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:packet(inet, [{type, dest_unreach}, {code, unreach_port}], <<"payload goes here">>).
%% <<3,3,135,239,0,0,0,0,112,97,121,108,111,97,100,32,103,
%% 111,101,115,32,104,101,114,101>>
%% '''
-spec packet(inet | inet6, [packet_option()], binary()) -> binary().
packet(inet, Header, Payload) when is_list(Header), is_binary(Payload) ->
Default = #icmp{},
Type = icmp_message:type_to_uint8(
proplists:get_value(type, Header, Default#icmp.type)
),
Code = icmp_message:code_to_uint8(
proplists:get_value(code, Header, Default#icmp.code)
),
Id = proplists:get_value(id, Header, Default#icmp.id),
Seq = proplists:get_value(sequence, Header, Default#icmp.sequence),
GW = proplists:get_value(gateway, Header, Default#icmp.gateway),
UN = proplists:get_value(un, Header, Default#icmp.un),
MTU = proplists:get_value(mtu, Header, Default#icmp.mtu),
Pointer = proplists:get_value(pointer, Header, Default#icmp.pointer),
TS_orig = proplists:get_value(ts_orig, Header, Default#icmp.ts_orig),
TS_recv = proplists:get_value(ts_recv, Header, Default#icmp.ts_recv),
TS_tx = proplists:get_value(ts_tx, Header, Default#icmp.ts_tx),
ICMP = #icmp{
type = Type,
code = Code,
id = Id,
sequence = Seq,
gateway = GW,
un = UN,
mtu = MTU,
pointer = Pointer,
ts_orig = TS_orig,
ts_recv = TS_recv,
ts_tx = TS_tx
},
packet(ICMP, Payload);
% IPv6 ICMP packet
packet(inet6, Header, Payload) when is_list(Header), is_binary(Payload) ->
Default = #icmp6{},
Type = icmp6_message:type_to_uint8(
proplists:get_value(type, Header, Default#icmp6.type)
),
Code = icmp6_message:code_to_uint8(
proplists:get_value(code, Header, Default#icmp6.code)
),
Id = proplists:get_value(id, Header, Default#icmp6.id),
Seq = proplists:get_value(sequence, Header, Default#icmp6.seq),
UN = proplists:get_value(un, Header, Default#icmp6.un),
MTU = proplists:get_value(mtu, Header, Default#icmp6.mtu),
Pointer = proplists:get_value(pointer, Header, Default#icmp6.pptr),
Maxdelay = proplists:get_value(maxdelay, Header, Default#icmp6.maxdelay),
% IPv6 pseudoheader
Saddr = proplists:get_value(saddr, Header, {0, 0, 0, 0, 0, 0, 0, 0}),
Daddr = proplists:get_value(daddr, Header, {0, 0, 0, 0, 0, 0, 0, 0}),
Len = proplists:get_value(len, Header, 0),
Next = proplists:get_value(next, Header, ?IPPROTO_ICMPV6),
Pseudo = #icmp6_pseudohdr{
saddr = Saddr,
daddr = Daddr,
len = Len,
next = Next,
h = #icmp6{
type = Type,
code = Code,
id = Id,
seq = Seq,
un = UN,
mtu = MTU,
pptr = Pointer,
maxdelay = Maxdelay
}
},
packet(Pseudo, Payload).
%% @doc Generate ICMP ECHO_REQUEST payload.
%%
%% Creates an ICMP echo packet with an 8 byte timestamp and a
%% payload consisting of ASCII 32 to 79.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:echo(inet, 0, 0).
%% <<8,0,166,49,0,0,0,0,255,253,243,182,71,2,233,209,32,33,
%% 34,35,36,37,38,39,40,41,42,43,44,...>>
%% '''
-spec echo(inet | inet6, id(), sequence()) -> binary().
echo(Family, Id, Seq) ->
% Pad packet to 64 bytes
echo(Family, Id, Seq, payload(echo)).
%% @doc Generate ICMP ECHO_REQUEST with user specified payload.
%%
%% Creates an ICMP echo packet with the results of
%% erlang:monotonic_time(micro_seconds) used as the timestamp and a user
%% specified payload (padded to 64 bytes).
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:echo(inet, 0, 0, <<"ping", 0:(60*8)>>).
%% <<8,0,25,47,0,0,0,0,112,105,110,103,0,0,0,0,0,0,0,0,0,0,0,
%% 0,0,0,0,0,0,...>>
%% '''
-spec echo(inet | inet6, id(), sequence(), <<_:64>>) -> binary().
echo(Family, Id, Seq, Payload) when
is_integer(Id),
Id >= 0,
Id < 16#FFFF,
is_integer(Seq),
Seq >= 0,
Seq < 16#FFFF,
is_binary(Payload)
->
Echo =
case Family of
inet -> echo;
inet6 -> echo_request
end,
packet(
Family,
[
{type, Echo},
{id, Id},
{sequence, Seq}
],
Payload
).
% Default ICMP echo payload
payload(echo) ->
USec = gettime(),
<<USec:8/signed-integer-unit:8, (list_to_binary(lists:seq($\s, $O)))/binary>>.
%% @doc Set the TTL on a file descriptor.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:set_ttl(gen_icmp:getfd(S), gen_icmp:family(S), 1).
%% ok
%% 2> gen_icmp:get_ttl(gen_icmp:getfd(S), gen_icmp:family(S)).
%% {ok,1}
%% '''
-spec set_ttl(fd(), inet | inet6, int32_t()) -> ok | {error, inet:posix()}.
set_ttl(FD, inet, TTL) ->
procket:setsockopt(FD, ?IPPROTO_IP, ip_ttl(), <<TTL:32/native>>);
set_ttl(FD, inet6, TTL) ->
procket:setsockopt(FD, ?IPPROTO_IPV6, ipv6_unicast_hops(), <<TTL:32/native>>).
%% @doc Get the TTL for a file descriptor.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:get_ttl(gen_icmp:getfd(S), gen_icmp:family(S)).
%% {ok,64}
%% '''
-spec get_ttl(fd(), inet | inet6) -> {ok, int32_t()} | {error, inet:posix()}.
get_ttl(FD, inet) ->
case procket:getsockopt(FD, ?IPPROTO_IP, ip_ttl(), <<0:32>>) of
{ok, <<TTL:32/native>>} -> {ok, TTL};
Error -> Error
end;
get_ttl(FD, inet6) ->
case procket:getsockopt(FD, ?IPPROTO_IPV6, ipv6_unicast_hops(), <<0:32>>) of
{ok, <<TTL:32/native>>} -> {ok, TTL};
Error -> Error
end.
%% @doc Resolve a host list.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:addr_list(inet, ["8.8.8.8", "google.com", "cloudflare.com", {8,8,8,8}, "8.8.8.8"], false).
%% [{ok,"8.8.8.8",{8,8,8,8}},
%% {ok,"google.com",{172,217,165,14}},
%% {ok,"cloudflare.com",{104,16,133,229}},
%% {ok,{8,8,8,8},{8,8,8,8}},
%% {ok,"8.8.8.8",{8,8,8,8}}]
%%
%% 2> [{ok,"8.8.8.8",{8,8,8,8}},
%% {ok,"google.com",{172,217,165,14}},
%% {ok,"cloudflare.com",{104,16,132,229}},
%% {ok,"cloudflare.com",{104,16,133,229}},
%% {ok,{8,8,8,8},{8,8,8,8}},
%% {ok,"8.8.8.8",{8,8,8,8}}]
%% '''
-spec addr_list(inet | inet6, [inet:socket_address() | inet:hostname()], boolean()) ->
[
{ok, inet:hostname(), inet:socket_address()}
| {error, inet:posix(), inet:hostname(), undefined}
].
addr_list(Family, Hosts, Multi) ->
lists:flatmap(
fun(Host) ->
case parse(Family, Host) of
{ok, IPs} when Multi == true ->
[{ok, Host, IP} || IP <- IPs];
{ok, [IP | _]} ->
[{ok, Host, IP}];
{error, Error} ->
[{error, Error, Host, undefined}]
end
end,
Hosts
).
%% @doc Parse or resolve an IPv4 host identifier.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:parse("8.8.8.8").
%% {ok,[{8,8,8,8}]}
%%
%% 2> gen_icmp:parse({8,8,8,8}).
%% {ok,[{8,8,8,8}]}
%%
%% 3> gen_icmp:parse("2001:4860:4860::8888").
%% {ok,[{8193,18528,18528,0,0,0,0,34952}]}
%%
%% 4> gen_icmp:parse("cloudflare.com").
%% {ok,[{104,16,132,229},{104,16,133,229}]}
%%
%% 5> gen_icmp:parse("foo").
%% {error,nxdomain}
%% '''
-spec parse(inet:socket_address() | inet:hostname()) ->
{ok, [inet:socket_address()]} | {error, inet:posix()}.
parse(Addr) ->
parse(inet, Addr).
%% @doc Parse or resolve a host identifier.
%%
%% == Examples ==
%%
%% ```
%% 1> gen_icmp:parse(inet, "cloudflare.com").
%% {ok,[{104,16,133,229},{104,16,132,229}]}
%%
%% 2> gen_icmp:parse(inet6, "cloudflare.com").
%% {ok,[{9734,18176,0,0,0,0,26640,34021},
%% {9734,18176,0,0,0,0,26640,34277}]}
%% '''
-spec parse(inet | inet6, inet:socket_address() | inet:hostname()) ->
{ok, [inet:socket_address()]} | {error, inet:posix()}.
parse(Family, Addr) when is_list(Addr) ->
parse_or_resolve(Family, Addr, inet_parse:address(Addr));
parse(_Family, Addr) when is_tuple(Addr) ->
{ok, [Addr]}.
%% @doc IPv6 ICMP filtering: allow all ICMP types.
%%
%% @see icmp6_filter_setblock/2
-spec icmp6_filter_setpassall() -> icmp6_filter().
icmp6_filter_setpassall() ->
case os:type() of
{unix, linux} ->
% Linux reverses the RFC3542 macros
<<0:256>>;
{unix, _} ->
<<16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff,
16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff,
16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff>>
end.
%% @doc ICMPv6 filtering: block all ICMP types.
%%
%% @see icmp6_filter_setpass/2
-spec icmp6_filter_setblockall() -> icmp6_filter().
icmp6_filter_setblockall() ->
case os:type() of
{unix, linux} ->
% Linux reverses the RFC3542 macros
<<16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff,
16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff,
16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff, 16#ff>>;
{unix, _} ->
<<0:256>>
end.
%% @doc Update a filter to allow an ICMPv6 type.
%%
%% == Examples ==
%%
%% To generate a filter that allowed only ICMP6_ECHO_REPLY messages:
%%
%% ```
%% {ok, Socket} = gen_icmp:open([inet6]),
%% Filter = gen_icmp:icmp6_filter_setpass(echo_reply, gen_icmp:icmp6_filter_setblockall()),
%% ok = gen_icmp:filter(Socket, Filter).
%% '''
%%
%% @see filter/2
%#define ICMP6_FILTER_SETPASS(type, filterp) \
% (((filterp)->icmp6_filt[(type) >> 5]) |= (1 << ((type) & 31)))
-spec icmp6_filter_setpass(atom() | uint8_t(), icmp6_filter()) -> icmp6_filter().
icmp6_filter_setpass(Type0, <<_:256>> = Filter) ->
Type = icmp6_message:type_to_uint8(Type0),
Offset = Type bsr 5,
Value = 1 bsl (Type band 31),
Fun =
case os:type() of
{unix, linux} ->
fun(N) -> N band bnot Value end;
{unix, _} ->
fun(N) -> N bor Value end
end,
array_set(Offset, Fun, Filter).
%% @doc Update a filter to block an ICMPv6 type.
%%
%% == Examples ==
%%
%% To generate a filter that allowed only ICMP6_PACKET_TOO_BIG messages:
%%
%% ```
%% 1> {ok, Socket} = gen_icmp:open([inet6]).
%% {ok,<0.300.0>}
%% 2> Filter = gen_icmp:icmp6_filter_setblock(packet_too_big, gen_icmp:icmp6_filter_setpassall()).
%% <<4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
%% 0,...>>
%% 3> gen_icmp:filter(Socket, Filter).
%% ok
%% '''
%%
%% @see filter/2
%#define ICMP6_FILTER_SETBLOCK(type, filterp) \
% (((filterp)->icmp6_filt[(type) >> 5]) &= ~(1 << ((type) & 31)))
-spec icmp6_filter_setblock(atom() | uint8_t(), icmp6_filter()) -> icmp6_filter().
icmp6_filter_setblock(Type0, <<_:256>> = Filter) ->
Type = icmp6_message:type_to_uint8(Type0),
Offset = Type bsr 5,
Value = 1 bsl (Type band 31),
Fun =
case os:type() of
{unix, linux} ->
fun(N) -> N bor Value end;
{unix, _} ->
fun(N) -> N band bnot Value end
end,
array_set(Offset, Fun, Filter).
%% @doc Test if a filter allows an ICMPv6 type.
%%
%% == Examples ==
%%
%% ```
%% 1> Filter = gen_icmp:icmp6_filter_setblock(packet_too_big, gen_icmp:icmp6_filter_setpassall()).
%% <<4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
%% 0,...>>
%% 2> gen_icmp:icmp6_filter_willpass(echo_reply, Filter).
%% true
%% 3> gen_icmp:icmp6_filter_willpass(packet_too_big, Filter).
%% false
%% '''
%#define ICMP6_FILTER_WILLPASS(type, filterp) \
% ((((filterp)->icmp6_filt[(type) >> 5]) & (1 << ((type) & 31))) != 0)
-spec icmp6_filter_willpass(atom() | uint8_t(), icmp6_filter()) -> boolean().
icmp6_filter_willpass(Type0, <<_:256>> = Filter) ->
Type = icmp6_message:type_to_uint8(Type0),
Offset = Type bsr 5,
Value = 1 bsl (Type band 31),
El = array_get(Offset, Filter),
case os:type() of
{unix, linux} -> El band Value =:= 0;
{unix, _} -> El band Value =/= 0
end.
%% @doc Test if a filter blocks an ICMPv6 type.
%%
%% == Examples ==
%%
%% ```
%% 1> Filter = gen_icmp:icmp6_filter_setblock(packet_too_big, gen_icmp:icmp6_filter_setpassall()).
%% <<4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
%% 0,...>>
%% 2> gen_icmp:icmp6_filter_willblock(echo_reply, Filter).
%% false
%% 3> gen_icmp:icmp6_filter_willblock(packet_too_big, Filter).
%% true
%% '''
%#define ICMP6_FILTER_WILLBLOCK(type, filterp) \
% ((((filterp)->icmp6_filt[(type) >> 5]) & (1 << ((type) & 31))) == 0)
-spec icmp6_filter_willblock(atom() | uint8_t(), icmp6_filter()) -> boolean().
icmp6_filter_willblock(Type0, <<_:256>> = Filter) ->
Type = icmp6_message:type_to_uint8(Type0),
Offset = Type bsr 5,
Value = 1 bsl (Type band 31),
El = array_get(Offset, Filter),
case os:type() of
{unix, linux} -> El band Value =/= 0;
{unix, _} -> El band Value =:= 0
end.
%%-------------------------------------------------------------------------
%%% Internal Functions
%%-------------------------------------------------------------------------
parse_or_resolve(_Family, _Addr, {ok, IP}) ->
{ok, [IP]};
parse_or_resolve(Family, Addr, {error, einval}) ->
case inet:gethostbyname(Addr, Family) of
{ok, #hostent{h_addr_list = IPs}} ->
{ok, IPs};
Error ->
Error
end.
ping_reply(Hosts, #ping_opt{s = Socket, timeout = Timeout} = Opt) ->
Pid = self(),
TRef =
case Timeout of
infinity ->
infinity;
_ ->
erlang:send_after(Timeout, Pid, {icmp, Socket, timeout})
end,
ping_loop(Hosts, [], Opt#ping_opt{tref = TRef}).
cancel_timeout(infinity) ->
false;
cancel_timeout(TRef) ->
erlang:cancel_timer(TRef).
ping_loop([], Acc, #ping_opt{tref = TRef}) ->
_ = cancel_timeout(TRef),
{[], Acc};
ping_loop(
Hosts,
Acc,
#ping_opt{
tref = TRef,
s = Socket,
id = Id,
timestamp = Timestamp
} = Opt
) ->
receive
% IPv4 ICMP Echo Reply
{icmp, Socket, {_, _, _, _} = Reply, TTL,
<<?ICMP_ECHOREPLY:8, 0:8, _Checksum:16, Id:16, Seq:16, Data/binary>>} ->
{Elapsed, Payload} =
case Timestamp of
true ->
<<USec:8/signed-integer-unit:8, Data1/binary>> = Data,
{timediff(USec) div 1000, Data1};
false ->
{0, Data}
end,
{Hosts2, Result} =
case lists:keytake(Seq, 4, Hosts) of
{value, {ok, Addr, Address, Seq}, NHosts} ->
{NHosts, [
{ok, Addr, Address, Reply, {Id, Seq, TTL, Elapsed}, Payload} | Acc
]};
false ->
{Hosts, Acc}
end,
ping_loop(Hosts2, Result, Opt);
% IPv4 ICMP Error
{icmp, Socket, {_, _, _, _} = Reply, TTL,
<<Type:8, Code:8, _Checksum1:16, _Unused:32, 4:4, 5:4, _ToS:8, _Len:16, _Id:16, 0:1,
_DF:1, _MF:1, _Off:13, _TTL:8, ?IPPROTO_ICMP:8, _Sum:16, _SA1:8, _SA2:8, _SA3:8,
_SA4:8, DA1:8, DA2:8, DA3:8, DA4:8, ?ICMP_ECHO:8, 0:8, _Checksum2:16, Id:16, Seq:16,
_/binary>> = Data} ->
<<_ICMPHeader:8/bytes, Payload/binary>> = Data,
DA = {DA1, DA2, DA3, DA4},
{Hosts2, Result} =
case lists:keytake(Seq, 4, Hosts) of
{value, {ok, Addr, DA, Seq}, NHosts} ->
{NHosts, [
{error, icmp_message:code({Type, Code}), Addr, DA, Reply,
{Id, Seq, TTL, undefined}, Payload}
| Acc
]};
false ->
{Hosts, Acc}
end,
ping_loop(Hosts2, Result, Opt);
% IPv6 ICMP Echo Reply
{icmp, Socket, {_, _, _, _, _, _, _, _} = Reply, TTL,
<<?ICMP6_ECHO_REPLY:8, 0:8, _Checksum:16, Id:16, Seq:16, Data/binary>>} ->
{Elapsed, Payload} =
case Timestamp of
true ->
<<USec:8/signed-integer-unit:8, Data1/binary>> = Data,
{timediff(USec) div 1000, Data1};
false ->
{0, Data}
end,
{Hosts2, Result} =
case lists:keytake(Seq, 4, Hosts) of
{value, {ok, Addr, Address, Seq}, NHosts} ->
{NHosts, [
{ok, Addr, Address, Reply, {Id, Seq, TTL, Elapsed}, Payload} | Acc
]};
false ->
{Hosts, Acc}
end,
ping_loop(Hosts2, Result, Opt);
% IPv6 ICMP Error
{icmp, Socket, {_, _, _, _, _, _, _, _} = Reply, TTL,
<<Type:8, Code:8, _Checksum1:16, _Unused:32, 6:4, _Class:8, _Flow:20, _Len:16,
?IPPROTO_ICMPV6:8, _Hop:8, _SA1:16, _SA2:16, _SA3:16, _SA4:16, _SA5:16, _SA6:16,
_SA7:16, _SA8:16, DA1:16, DA2:16, DA3:16, DA4:16, DA5:16, DA6:16, DA7:16, DA8:16,
?ICMP6_ECHO_REQUEST:8, 0:8, _Checksum2:16, Id:16, Seq:16, _/binary>> = Data} ->
<<_ICMPHeader:8/bytes, Payload/binary>> = Data,
DA = {DA1, DA2, DA3, DA4, DA5, DA6, DA7, DA8},
{value, {ok, Addr, DA, Seq}, Hosts2} = lists:keytake(Seq, 4, Hosts),
{Hosts2, Result} =
case lists:keytake(Seq, 4, Hosts) of
{value, {ok, Addr, DA, Seq}, NHosts} ->
{NHosts, [
{error, icmp_message:code({Type, Code}), Addr, DA, Reply,
{Id, Seq, TTL, undefined}, Payload}
| Acc
]};
false ->
{Hosts, Acc}
end,
ping_loop(Hosts2, Result, Opt);
% IPv4/IPv6 timeout on socket
{icmp, Socket, timeout} ->
_ = cancel_timeout(TRef),
Timeouts = [{error, timeout, Addr, IP} || {ok, Addr, IP, _Seq} <- Hosts],
{Timeouts, Acc}
end.
% TTL
ip_ttl() ->
case os:type() of
{unix, linux} -> 2;
{unix, _} -> 4
end.
ipv6_unicast_hops() ->
case os:type() of
{unix, linux} -> 16;
{unix, _} -> 4
end.
icmp6_filter() ->
case os:type() of
{unix, linux} ->
1;
{unix, _} ->
18
end.
% Offset starts at 0
array_set(Offset, Fun, Bin) ->
Array = array:from_list([N || <<N:4/native-unsigned-integer-unit:8>> <= Bin]),
Value = Fun(array:get(Offset, Array)),
<<
<<N:4/native-unsigned-integer-unit:8>>
|| N <- array:to_list(array:set(Offset, Value, Array))
>>.
array_get(Offset, Bin) ->
Array = array:from_list([N || <<N:4/native-unsigned-integer-unit:8>> <= Bin]),
array:get(Offset, Array).
flush_events(Socket) ->
receive
{icmp, Socket, _Addr, _TTL, _Data} ->
flush_events(Socket)
after 0 -> ok
end.
%% @private
-spec gettime() -> integer().
gettime() ->
try erlang:monotonic_time(micro_seconds) of
N ->
N
catch
error:undef ->
timestamp_to_microseconds(os:timestamp())
end.
%% @private
-spec timediff(integer()) -> integer().
timediff(T) ->
timediff(gettime(), T).
%% @private
-spec timediff(integer(), integer()) -> integer().
timediff(T1, T2) ->
T1 - T2.
timestamp_to_microseconds({MegaSecs, Secs, MicroSecs}) ->
(MegaSecs * 1000000 + Secs) * 1000000 + MicroSecs.
