%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2018-2018. All Rights Reserved. %% %% Licensed under the Apache License, Version 2.0 (the "License"); %% you may not use this file except in compliance with the License. %% You may obtain a copy of the License at %% %% http://www.apache.org/licenses/LICENSE-2.0 %% %% Unless required by applicable law or agreed to in writing, software %% distributed under the License is distributed on an "AS IS" BASIS, %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %% See the License for the specific language governing permissions and %% limitations under the License. %% %% %CopyrightEnd% %% -module(socket_SUITE). -include_lib("common_test/include/ct.hrl"). -include_lib("common_test/include/ct_event.hrl"). %% Suite exports -export([suite/0, all/0, groups/0]). -export([init_per_suite/1, end_per_suite/1, init_per_testcase/2, end_per_testcase/2]). %% Test cases -export([ %% API Basic api_b_open_and_close_udp4/1, api_b_open_and_close_tcp4/1, api_b_sendto_and_recvfrom_udp4/1, api_b_sendmsg_and_recvmsg_udp4/1, api_b_send_and_recv_tcp4/1, api_b_sendmsg_and_recvmsg_tcp4/1, %% API Options api_opt_simple_otp_options/1, api_opt_simple_otp_controlling_process/1, %% API Operation Timeout api_to_connect_tcp4/1, api_to_connect_tcp6/1, api_to_accept_tcp4/1, api_to_accept_tcp6/1, api_to_send_tcp4/1, api_to_send_tcp6/1, api_to_sendapi_to_udp4/1, api_to_sendapi_to_udp6/1, api_to_sendmsg_tcp4/1, api_to_sendmsg_tcp6/1, api_to_recv_udp4/1, api_to_recv_udp6/1, api_to_recv_tcp4/1, api_to_recv_tcp6/1, api_to_recvfrom_udp4/1, api_to_recvfrom_udp6/1, api_to_recvmsg_udp4/1, api_to_recvmsg_udp6/1, api_to_recvmsg_tcp4/1, api_to_recvmsg_tcp6/1 %% Tickets ]). %% Internal exports %% -export([]). -type initial_evaluator_state() :: map(). -type evaluator_state() :: term(). -type command_fun() :: fun((State :: evaluator_state()) -> ok) | fun((State :: evaluator_state()) -> {ok, evaluator_state()}) | fun((State :: evaluator_state()) -> {error, term()}). -type command() :: #{desc := string(), cmd := command_fun()}. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -define(BASIC_REQ, <<"hejsan">>). -define(BASIC_REP, <<"hoppsan">>). -define(FAIL(R), exit(R)). -define(SLEEP(T), receive after T -> ok end). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% suite() -> [{ct_hooks,[ts_install_cth]}, {timetrap,{minutes,1}}]. all() -> [ {group, api} %% {group, tickets} ]. groups() -> [{api, [], api_cases()}, {api_basic, [], api_basic_cases()}, {api_op_with_timeout, [], api_op_with_timeout_cases()}, {api_options, [], api_options_cases()} %% {tickets, [], ticket_cases()} ]. api_cases() -> [ {group, api_basic}, {group, api_options}, {group, api_op_with_timeout} ]. api_basic_cases() -> [ api_b_open_and_close_udp4, api_b_open_and_close_tcp4, api_b_sendto_and_recvfrom_udp4, api_b_sendmsg_and_recvmsg_udp4, api_b_send_and_recv_tcp4, api_b_sendmsg_and_recvmsg_tcp4 ]. api_options_cases() -> [ api_opt_simple_otp_options, api_opt_simple_otp_controlling_process ]. api_op_with_timeout_cases() -> [ api_to_connect_tcp4, api_to_connect_tcp6, api_to_accept_tcp4, api_to_accept_tcp6, api_to_send_tcp4, api_to_send_tcp6, api_to_sendapi_to_udp4, api_to_sendapi_to_udp6, api_to_sendmsg_tcp4, api_to_sendmsg_tcp6, api_to_recv_udp4, api_to_recv_udp6, api_to_recv_tcp4, api_to_recv_tcp6, api_to_recvfrom_udp4, api_to_recvfrom_udp6, api_to_recvmsg_udp4, api_to_recvmsg_udp6, api_to_recvmsg_tcp4, api_to_recvmsg_tcp6 ]. %% ticket_cases() -> %% []. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% init_per_suite(Config) -> Config. end_per_suite(_) -> ok. init_per_testcase(_TC, Config) -> Config. end_per_testcase(_TC, Config) -> Config. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically open (create) and close an IPv4 UDP (dgram) socket. %% With some extra checks... api_b_open_and_close_udp4(suite) -> []; api_b_open_and_close_udp4(doc) -> []; api_b_open_and_close_udp4(_Config) when is_list(_Config) -> tc_begin(api_b_open_and_close_udp4), State = #{domain => inet, type => dgram, protocol => udp}, ok = api_b_open_and_close(State), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically open (create) and close an IPv4 TCP (stream) socket. %% With some extra checks... api_b_open_and_close_tcp4(suite) -> []; api_b_open_and_close_tcp4(doc) -> []; api_b_open_and_close_tcp4(_Config) when is_list(_Config) -> tc_begin(api_b_open_and_close_tcp4), State = #{domain => inet, type => stream, protocol => tcp}, ok = api_b_open_and_close(State), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_b_open_and_close(InitState) -> Seq = [ #{desc => "open", cmd => fun(#{domain := Domain, type := Type, protocol := Protocol} = S) -> Res = socket:open(Domain, Type, Protocol), {ok, {S, Res}} end}, #{desc => "validate open", cmd => fun({S, {ok, Sock}}) -> NewS = S#{socket => Sock}, {ok, NewS}; ({_, {error, _} = ERROR}) -> ERROR end}, #{desc => "get domain (maybe)", cmd => fun(#{socket := Sock} = S) -> Res = socket:getopt(Sock, socket, domain), {ok, {S, Res}} end}, #{desc => "validate domain (maybe)", cmd => fun({#{domain := Domain} = S, {ok, Domain}}) -> {ok, S}; ({#{domain := ExpDomain}, {ok, Domain}}) -> {error, {unexpected_domain, ExpDomain, Domain}}; %% Some platforms do not support this option ({S, {error, einval}}) -> {ok, S}; ({_, {error, _} = ERROR}) -> ERROR end}, #{desc => "get type", cmd => fun(#{socket := Sock} = State) -> Res = socket:getopt(Sock, socket, type), {ok, {State, Res}} end}, #{desc => "validate type", cmd => fun({#{type := Type} = State, {ok, Type}}) -> {ok, State}; ({#{type := ExpType}, {ok, Type}}) -> {error, {unexpected_type, ExpType, Type}}; ({_, {error, _} = ERROR}) -> ERROR end}, #{desc => "get protocol", cmd => fun(#{socket := Sock} = State) -> Res = socket:getopt(Sock, socket, protocol), {ok, {State, Res}} end}, #{desc => "validate protocol", cmd => fun({#{protocol := Protocol} = State, {ok, Protocol}}) -> {ok, State}; ({#{protocol := ExpProtocol}, {ok, Protocol}}) -> {error, {unexpected_type, ExpProtocol, Protocol}}; ({_, {error, _} = ERROR}) -> ERROR end}, #{desc => "get controlling-process", cmd => fun(#{socket := Sock} = State) -> Res = socket:getopt(Sock, otp, controlling_process), {ok, {State, Res}} end}, #{desc => "validate controlling-process", cmd => fun({State, {ok, Pid}}) -> case self() of Pid -> {ok, State}; _ -> {error, {unexpected_owner, Pid}} end; ({_, {error, _} = ERROR}) -> ERROR end}, #{desc => "close socket", cmd => fun(#{socket := Sock} = State) -> Res = socket:close(Sock), {ok, {State, Res}} end}, #{desc => "validate socket close", cmd => fun({_, ok}) -> {ok, normal}; ({_, {error, _} = ERROR}) -> ERROR end}], Evaluator = evaluator_start("tester", Seq, InitState), ok = await_evaluator_finish([Evaluator]). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically send and receive on an IPv4 UDP (dgram) socket using %% sendto and recvfrom.. api_b_sendto_and_recvfrom_udp4(suite) -> []; api_b_sendto_and_recvfrom_udp4(doc) -> []; api_b_sendto_and_recvfrom_udp4(_Config) when is_list(_Config) -> tc_begin(api_b_sendto_and_recvfrom_udp4), Send = fun(Sock, Data, Dest) -> socket:sendto(Sock, Data, Dest) end, Recv = fun(Sock) -> socket:recvfrom(Sock) end, InitState = #{domain => inet, send => Send, recv => Recv}, ok = api_b_send_and_recv_udp(InitState), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically send and receive on an IPv4 UDP (dgram) socket %% using sendmsg and recvmsg. api_b_sendmsg_and_recvmsg_udp4(suite) -> []; api_b_sendmsg_and_recvmsg_udp4(doc) -> []; api_b_sendmsg_and_recvmsg_udp4(_Config) when is_list(_Config) -> tc_begin(api_b_sendmsg_and_recvmsg_udp4), Send = fun(Sock, Data, Dest) -> %% CMsgHdr = #{level => ip, type => tos, data => reliability}, %% CMsgHdrs = [CMsgHdr], MsgHdr = #{addr => Dest, %% ctrl => CMsgHdrs, iov => [Data]}, socket:sendmsg(Sock, MsgHdr) end, Recv = fun(Sock) -> case socket:recvmsg(Sock) of {ok, #{addr := Source, iov := [Data]}} -> {ok, {Source, Data}}; {error, _} = ERROR -> ERROR end end, InitState = #{domain => inet, send => Send, recv => Recv}, ok = api_b_send_and_recv_udp(InitState), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_b_send_and_recv_udp(InitState) -> Seq = [ #{desc => "local address", cmd => fun(#{domain := Domain} = State) -> LAddr = which_local_addr(Domain), LSA = #{family => Domain, addr => LAddr}, {ok, State#{lsa => LSA}} end}, #{desc => "open src socket", cmd => fun(#{domain := Domain} = State) -> Sock = sock_open(Domain, dgram, udp), SASrc = sock_sockname(Sock), {ok, State#{sock_src => Sock, sa_src => SASrc}} end}, #{desc => "bind src", cmd => fun(#{sock_src := Sock, lsa := LSA}) -> sock_bind(Sock, LSA), ok end}, #{desc => "sockname src socket", cmd => fun(#{sock_src := Sock} = State) -> SASrc = sock_sockname(Sock), %% ei("src sockaddr: ~p", [SASrc]), {ok, State#{sa_src => SASrc}} end}, #{desc => "open dst socket", cmd => fun(#{domain := Domain} = State) -> Sock = sock_open(Domain, dgram, udp), {ok, State#{sock_dst => Sock}} end}, #{desc => "bind dst", cmd => fun(#{sock_dst := Sock, lsa := LSA}) -> sock_bind(Sock, LSA), ok end}, #{desc => "sockname dst socket", cmd => fun(#{sock_dst := Sock} = State) -> SADst = sock_sockname(Sock), %% ei("dst sockaddr: ~p", [SADst]), {ok, State#{sa_dst => SADst}} end}, #{desc => "send req (to dst)", cmd => fun(#{sock_src := Sock, sa_dst := Dst, send := Send}) -> ok = Send(Sock, ?BASIC_REQ, Dst) end}, #{desc => "recv req (from src)", cmd => fun(#{sock_dst := Sock, sa_src := Src, recv := Recv}) -> {ok, {Src, ?BASIC_REQ}} = Recv(Sock), ok end}, #{desc => "send rep (to src)", cmd => fun(#{sock_dst := Sock, sa_src := Src, send := Send}) -> ok = Send(Sock, ?BASIC_REP, Src) end}, #{desc => "recv rep (from dst)", cmd => fun(#{sock_src := Sock, sa_dst := Dst, recv := Recv}) -> {ok, {Dst, ?BASIC_REP}} = Recv(Sock), ok end}, #{desc => "close src socket", cmd => fun(#{sock_src := Sock}) -> ok = socket:close(Sock) end}, #{desc => "close dst socket", cmd => fun(#{sock_dst := Sock}) -> ok = socket:close(Sock), {ok, normal} end} ], Evaluator = evaluator_start("tester", Seq, InitState), ok = await_evaluator_finish([Evaluator]). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically send and receive using the "common" functions (send and recv) %% on an IPv4 TCP (stream) socket. api_b_send_and_recv_tcp4(suite) -> []; api_b_send_and_recv_tcp4(doc) -> []; api_b_send_and_recv_tcp4(_Config) when is_list(_Config) -> tc_begin(api_b_send_and_recv_tcp4), Send = fun(Sock, Data) -> socket:send(Sock, Data) end, Recv = fun(Sock) -> socket:recv(Sock) end, InitState = #{domain => inet, send => Send, recv => Recv}, ok = api_b_send_and_recv_tcp(InitState), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Basically send and receive using the msg functions (sendmsg and recvmsg) %% on an IPv4 TCP (stream) socket. api_b_sendmsg_and_recvmsg_tcp4(suite) -> []; api_b_sendmsg_and_recvmsg_tcp4(doc) -> []; api_b_sendmsg_and_recvmsg_tcp4(_Config) when is_list(_Config) -> tc_begin(api_b_sendmsg_and_recvmsg_tcp4), Send = fun(Sock, Data) -> MsgHdr = #{iov => [Data]}, socket:sendmsg(Sock, MsgHdr) end, Recv = fun(Sock) -> case socket:recvmsg(Sock) of {ok, #{addr := undefined, iov := [Data]}} -> {ok, Data}; {error, _} = ERROR -> ERROR end end, InitState = #{domain => inet, send => Send, recv => Recv}, ok = api_b_send_and_recv_tcp(InitState), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_b_send_and_recv_tcp(InitState) -> process_flag(trap_exit, true), ServerSeq = [ #{desc => "which local address", cmd => fun(#{domain := Domain} = State) -> LAddr = which_local_addr(Domain), LSA = #{family => Domain, addr => LAddr}, {ok, State#{lsa => LSA}} end}, #{desc => "create listen socket", cmd => fun(#{domain := Domain} = State) -> case socket:open(Domain, stream, tcp) of {ok, Sock} -> {ok, State#{lsock => Sock}}; {error, _} = ERROR -> ERROR end end}, #{desc => "bind to local address", cmd => fun(#{lsock := LSock, lsa := LSA} = State) -> case socket:bind(LSock, LSA) of {ok, Port} -> {ok, State#{lport => Port}}; {error, _} = ERROR -> ERROR end end}, #{desc => "make listen socket", cmd => fun(#{lsock := LSock}) -> socket:listen(LSock) end}, #{desc => "announce server port", cmd => fun(#{parent := Parent, lport := Port}) -> ei("announcing port to parent (~p)", [Parent]), Parent ! {server_port, self(), Port}, ok end}, #{desc => "await connection", cmd => fun(#{lsock := LSock} = State) -> case socket:accept(LSock) of {ok, Sock} -> ei("accepted: ~p", [Sock]), {ok, State#{tsock => Sock}}; {error, _} = ERROR -> ERROR end end}, #{desc => "await request", cmd => fun(#{tsock := Sock, recv := Recv}) -> case Recv(Sock) of {ok, ?BASIC_REQ} -> ok; {error, _} = ERROR -> ERROR end end}, #{desc => "send reply", cmd => fun(#{tsock := Sock, send := Send}) -> Send(Sock, ?BASIC_REP) end}, #{desc => "sleep some", cmd => fun(_) -> ?SLEEP(1000), ok end}, #{desc => "close traffic socket", cmd => fun(#{tsock := Sock}) -> socket:close(Sock) end}, #{desc => "close listen socket", cmd => fun(#{lsock := Sock}) -> socket:close(Sock) end}, #{desc => "finish", cmd => fun(_) -> {ok, normal} end} ], ClientSeq = [ #{desc => "which server (local) address", cmd => fun(#{domain := Domain, server_port := Port} = State) -> LAddr = which_local_addr(Domain), LSA = #{family => Domain, addr => LAddr}, SSA = LSA#{port => Port}, {ok, State#{lsa => LSA, ssa => SSA}} end}, #{desc => "create socket", cmd => fun(#{domain := Domain} = State) -> case socket:open(Domain, stream, tcp) of {ok, Sock} -> {ok, State#{sock => Sock}}; {error, _} = ERROR -> ERROR end end}, #{desc => "bind to local address", cmd => fun(#{sock := Sock, lsa := LSA} = State) -> case socket:bind(Sock, LSA) of {ok, Port} -> {ok, State#{port => Port}}; {error, _} = ERROR -> ERROR end end}, #{desc => "connect to server", cmd => fun(#{sock := Sock, ssa := SSA}) -> socket:connect(Sock, SSA) end}, #{desc => "send request (to server)", cmd => fun(#{sock := Sock, send := Send}) -> Send(Sock, ?BASIC_REQ) end}, #{desc => "recv reply (from server)", cmd => fun(#{sock := Sock, recv := Recv}) -> {ok, ?BASIC_REP} = Recv(Sock), ok end}, #{desc => "close socket", cmd => fun(#{sock := Sock}) -> socket:close(Sock) end}, #{desc => "finish", cmd => fun(_) -> {ok, normal} end} ], p("start server evaluator"), Server = evaluator_start("server", ServerSeq, InitState), p("await server (~p) port", [Server]), SPort = receive {server_port, Server, Port} -> Port end, p("start client evaluator"), Client = evaluator_start("client", ClientSeq, InitState#{server_port => SPort}), p("await evaluator(s)"), ok = await_evaluator_finish([Server, Client]). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Perform some simple getopt and setopt with the level = otp options api_opt_simple_otp_options(suite) -> []; api_opt_simple_otp_options(doc) -> []; api_opt_simple_otp_options(_Config) when is_list(_Config) -> tc_begin(api_opt_simple_otp_options), p("Create sockets"), S1 = sock_open(inet, stream, tcp), S2 = sock_open(inet, dgram, udp), Get = fun(S, Key) -> socket:getopt(S, otp, Key) end, Set = fun(S, Key, Val) -> socket:setopt(S, otp, Key, Val) end, p("Create dummy process"), Pid = spawn_link(fun() -> put(sname, "dummy"), receive die -> exit(normal) end end), F = fun(Sock) -> p("Test IOW"), {ok, IOW} = Get(Sock, iow), NotIOW = not IOW, ok = Set(Sock, iow, NotIOW), {ok, NotIOW} = Get(Sock, iow), p("Test rcvbuf"), {ok, RcvBuf} = Get(Sock, rcvbuf), RcvBuf2 = RcvBuf*2, ok = Set(Sock, rcvbuf, RcvBuf2), {ok, RcvBuf2} = Get(Sock, rcvbuf), ok = Set(Sock, rcvbuf, default), {ok, RcvBuf} = Get(Sock, rcvbuf), p("Test rcvctrlbuf"), {ok, RcvCtrlBuf} = Get(Sock, rcvctrlbuf), RcvCtrlBuf2 = RcvCtrlBuf*2, ok = Set(Sock, rcvctrlbuf, RcvCtrlBuf2), {ok, RcvCtrlBuf2} = Get(Sock, rcvctrlbuf), ok = Set(Sock, rcvctrlbuf, default), {ok, RcvCtrlBuf} = Get(Sock, rcvctrlbuf), p("Test sndctrlbuf"), {ok, SndCtrlBuf} = Get(Sock, sndctrlbuf), SndCtrlBuf2 = SndCtrlBuf*2, ok = Set(Sock, sndctrlbuf, SndCtrlBuf2), {ok, SndCtrlBuf2} = Get(Sock, sndctrlbuf), ok = Set(Sock, sndctrlbuf, default), {ok, RcvCtrlBuf} = Get(Sock, sndctrlbuf), p("Test controlling-process"), Self = self(), {ok, Self} = Get(Sock, controlling_process), ok = Set(Sock, controlling_process, Pid), {ok, Pid} = Get(Sock, controlling_process) end, p("Test stream/tcp "), F(S1), p("Test dgram/udp "), F(S2), p("kill dummy process"), %% This will also close its sockets (S1 and S2), %% This should really be tested explicitly... Pid ! die, %% p("close sockets"), %% sock_close(S1), %% sock_close(S2), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Perform some simple getopt and setopt with the level = otp options api_opt_simple_otp_controlling_process(suite) -> []; api_opt_simple_otp_controlling_process(doc) -> []; api_opt_simple_otp_controlling_process(_Config) when is_list(_Config) -> tc_begin(api_opt_simple_otp_controlling_process), p("Create sockets"), S1 = sock_open(inet, stream, tcp), S2 = sock_open(inet, dgram, udp), Get = fun(S, Key) -> socket:getopt(S, otp, Key) end, Set = fun(S, Key, Val) -> socket:setopt(S, otp, Key, Val) end, AwaitStart = fun() -> p("await start command"), receive {start, P, S} -> {P, S} end end, AwaitContinue = fun(Pid) -> p("await continue command"), receive {continue, Pid} -> ok end end, AwaitReady = fun(Pid) -> p("await ready confirmation from ~p", [Pid]), receive {ready, Pid} -> ok end end, AwaitDie = fun(Pid) -> p("await die command"), receive {die, Pid} -> ok end end, ClientStarter = fun() -> put(sname, "client"), Self = self(), {Parent, Sock} = AwaitStart(), p("verify parent ~p controlling", [Parent]), {ok, Parent} = Get(Sock, controlling_process), p("attempt invalid control transfer (to self)"), {error, not_owner} = Set(Sock, controlling_process, self()), p("verify parent ~p (still) controlling", [Parent]), {ok, Parent} = Get(Sock, controlling_process), p("announce ready"), Parent ! {ready, self()}, AwaitContinue(Parent), p("verify self controlling"), {ok, Self} = Get(Sock, controlling_process), p("transfer control to parent ~p", [Parent]), ok = Set(Sock, controlling_process, Parent), p("attempt invalid control transfer (to self)"), {error, not_owner} = Set(Sock, controlling_process, self()), p("verify parent ~p controlling", [Parent]), {ok, Parent} = Get(Sock, controlling_process), p("announce ready"), Parent ! {ready, self()}, AwaitDie(Parent), p("done"), exit(normal) end, Tester = fun(Sock, Client) -> p("start"), Self = self(), p("verify self controlling"), {ok, Self} = Get(Sock, controlling_process), p("announce start"), Client ! {start, Self, Sock}, AwaitReady(Client), p("transfer control to client ~p", [Client]), ok = Set(Sock, controlling_process, Client), p("verify client ~p controlling", [Client]), {ok, Client} = Get(Sock, controlling_process), p("attempt invalid control transfer (to self)"), {error, not_owner} = Set(Sock, controlling_process, self()), p("announce continue"), Client ! {continue, Self}, AwaitReady(Client), p("verify self controlling"), {ok, Self} = Get(Sock, controlling_process), p("announce die"), Client ! {die, Self}, p("done"), ok end, p("Create Worker Process(s)"), Pid1 = spawn_link(ClientStarter), Pid2 = spawn_link(ClientStarter), p("Test stream/tcp "), Tester(S1, Pid1), p("Test dgram/udp "), Tester(S2, Pid2), p("close sockets"), sock_close(S1), sock_close(S2), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the connect timeout option %% on an IPv4 TCP (stream) socket. api_to_connect_tcp4(suite) -> []; api_to_connect_tcp4(doc) -> []; api_to_connect_tcp4(_Config) when is_list(_Config) -> tc_begin(api_to_connect_tcp4), ok = api_to_connect_tcp(inet), tc_end(). %% not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the connect timeout option %% on an IPv6 TCP (stream) socket. api_to_connect_tcp6(suite) -> []; api_to_connect_tcp6(doc) -> []; api_to_connect_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_connect_tcp6), %% ok = api_to_connect_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% We use the backlog (listen) argument to test this. %% Note that the behaviour of the TCP "server side" can vary when %% a client connect to a "busy" server (full backlog). %% For instance, on FreeBSD (11.2) the reponse when the backlog is full %% is a econreset. api_to_connect_tcp(Domain) -> process_flag(trap_exit, true), p("init"), Client = self(), LocalAddr = which_local_addr(Domain), LocalSA = #{family => Domain, addr => LocalAddr}, ServerName = f("~s:server", [get_tc_name()]), Server = spawn_link(fun() -> put(sname, ServerName), p("open"), LSock = sock_open(Domain, stream, tcp), p("bind"), ServerLPort = sock_bind(LSock, LocalSA), p("listen on ~w", [ServerLPort]), sock_listen(LSock, 1), p("inform client"), Client ! {self(), ServerLPort}, p("await termination command"), receive die -> p("terminating"), exit(normal) end end), p("await server port"), ServerLPort = receive {Server, Port} -> Port end, p("open(s)"), CSock1 = sock_open(Domain, stream, tcp), CSock2 = sock_open(Domain, stream, tcp), CSock3 = sock_open(Domain, stream, tcp), p("bind(s)"), _ClientPort1 = sock_bind(CSock1, LocalSA), _ClientPort2 = sock_bind(CSock2, LocalSA), _ClientPort3 = sock_bind(CSock3, LocalSA), ServerSA = LocalSA#{port => ServerLPort}, api_to_connect_tcp_await_timeout([CSock1, CSock2, CSock3], ServerSA), p("terminate server"), Server ! die, receive {'EXIT', Server, _} -> p("server terminated"), ok end, ok. api_to_connect_tcp_await_timeout(Socks, ServerSA) -> api_to_connect_tcp_await_timeout(Socks, ServerSA, 1). api_to_connect_tcp_await_timeout([], _ServerSA, _ID) -> ?FAIL(unexpected_success); api_to_connect_tcp_await_timeout([Sock|Socks], ServerSA, ID) -> p("~w: try connect", [ID]), case socket:connect(Sock, ServerSA, 5000) of {error, timeout} -> p("expected timeout (~w)", [ID]), ok; {error, econnreset = Reason} -> p("failed connecting: ~p - giving up", [Reason]), ok; {error, Reason} -> p("failed connecting: ~p", [Reason]), ?FAIL({recv, Reason}); ok -> p("unexpected success (~w) - try next", [ID]), api_to_connect_tcp_await_timeout(Socks, ServerSA, ID+1) end. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the accept timeout option %% on an IPv4 TCP (stream) socket. api_to_accept_tcp4(suite) -> []; api_to_accept_tcp4(doc) -> []; api_to_accept_tcp4(_Config) when is_list(_Config) -> %% tc_begin(api_to_accept_tcp4), %% ok = api_to_accept_tcp(inet), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the accept timeout option %% on an IPv6 TCP (stream) socket. api_to_accept_tcp6(suite) -> []; api_to_accept_tcp6(doc) -> []; api_to_accept_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_accept_tcp6), %% ok = api_to_accept_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the send timeout option %% on an IPv4 TCP (stream) socket. api_to_send_tcp4(suite) -> []; api_to_send_tcp4(doc) -> []; api_to_send_tcp4(_Config) when is_list(_Config) -> %% tc_begin(api_to_send_tcp4), %% ok = api_to_send_tcp(inet), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the send timeout option %% on an IPv6 TCP (stream) socket. api_to_send_tcp6(suite) -> []; api_to_send_tcp6(doc) -> []; api_to_send_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_send_tcp6), %% ok = api_to_send_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the sendto timeout option %% on an IPv4 UDP (dgram) socket. api_to_sendapi_to_udp4(suite) -> []; api_to_sendapi_to_udp4(doc) -> []; api_to_sendapi_to_udp4(_Config) when is_list(_Config) -> %% tc_begin(api_to_sendapi_to_udp4), %% ok = api_to_sendapi_to_udp(inet), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the sendto timeout option %% on an IPv6 UDP (dgram) socket. api_to_sendapi_to_udp6(suite) -> []; api_to_sendapi_to_udp6(doc) -> []; api_to_sendapi_to_udp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_sendapi_to_udp6), %% ok = api_to_sendapi_to_udp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the sendmsg timeout option %% on an IPv4 TCP (stream) socket. api_to_sendmsg_tcp4(suite) -> []; api_to_sendmsg_tcp4(doc) -> []; api_to_sendmsg_tcp4(_Config) when is_list(_Config) -> %% tc_begin(api_to_sendmsg_tcp4), %% ok = api_to_sendmsg_tcp(inet), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the sendmsg timeout option %% on an IPv6 TCP (stream) socket. api_to_sendmsg_tcp6(suite) -> []; api_to_sendmsg_tcp6(doc) -> []; api_to_sendmsg_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_sendmsg_tcp6), %% ok = api_to_sendmsg_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recv timeout option %% on an IPv4 UDP (dgram) socket. To test this we must connect %% the socket. api_to_recv_udp4(suite) -> []; api_to_recv_udp4(doc) -> []; api_to_recv_udp4(_Config) when is_list(_Config) -> %% tc_begin(api_to_recv_udp4), %% ok = api_to_recv_udp(inet), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recv timeout option %% on an IPv6 UDP (dgram) socket. To test this we must connect %% the socket. api_to_recv_udp6(suite) -> []; api_to_recv_udp6(doc) -> []; api_to_recv_udp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_recv_udp6), %% ok = api_to_recv_udp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recv timeout option %% on an IPv4 TCP (stream) socket. api_to_recv_tcp4(suite) -> []; api_to_recv_tcp4(doc) -> []; api_to_recv_tcp4(_Config) when is_list(_Config) -> tc_begin(api_to_recv_tcp4), ok = api_to_recv_tcp(inet), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recv timeout option %% on an IPv6 TCP (stream) socket. api_to_recv_tcp6(suite) -> []; api_to_recv_tcp6(doc) -> []; api_to_recv_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_recv_tcp6), %% ok = api_to_recv_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_to_recv_tcp(Domain) -> process_flag(trap_exit, true), p("server -> open"), LSock = sock_open(Domain, stream, tcp), LocalAddr = which_local_addr(Domain), LocalSA = #{family => Domain, addr => LocalAddr}, p("server -> bind"), ServerLPort = sock_bind(LSock, LocalSA), p("server(~w) -> listen", [ServerLPort]), sock_listen(LSock), ClientName = f("~s:client", [get_tc_name()]), Client = spawn_link(fun() -> put(sname, ClientName), p("open"), CSock = sock_open(Domain, stream, tcp), p("bind"), ClientPort = sock_bind(CSock, LocalSA), p("[~w] connect to ~w", [ClientPort, ServerLPort]), sock_connect(CSock, LocalSA#{port => ServerLPort}), p("await termination command"), receive die -> p("terminating"), exit(normal) end end), p("server -> accept on ~w", [ServerLPort]), Sock = sock_accept(LSock), p("server -> recv"), %% The zero (0) represents "give me everything you have" case socket:recv(Sock, 0, 5000) of {error, timeout} -> p("server -> expected timeout"), ok; {ok, _Data} -> ?FAIL(unexpected_success); {error, Reason} -> ?FAIL({recv, Reason}) end, Client ! die, receive {'EXIT', Client, _} -> ok end, ok. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvfrom timeout option %% on an IPv4 UDP (dgram) socket. api_to_recvfrom_udp4(suite) -> []; api_to_recvfrom_udp4(doc) -> []; api_to_recvfrom_udp4(_Config) when is_list(_Config) -> tc_begin(api_to_recvfrom_udp4), ok = api_to_recvfrom_udp(inet), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvfrom timeout option %% on an IPv6 UDP (dgram) socket. api_to_recvfrom_udp6(suite) -> []; api_to_recvfrom_udp6(doc) -> []; api_to_recvfrom_udp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_recvfrom_udp6), %% ok = api_to_recvfrom_udp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_to_recvfrom_udp(Domain) -> process_flag(trap_exit, true), p("init"), LocalAddr = which_local_addr(Domain), LocalSA = #{family => Domain, addr => LocalAddr}, p("open"), Sock = sock_open(Domain, dgram, udp), p("bind"), _Port = sock_bind(Sock, LocalSA), p("recv"), case socket:recvfrom(Sock, 0, 5000) of {error, timeout} -> p("expected timeout"), ok; {ok, _SrcData} -> ?FAIL(unexpected_success); {error, Reason} -> ?FAIL({recv, Reason}) end, ok. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvmsg timeout option %% on an IPv4 UDP (dgram) socket. api_to_recvmsg_udp4(suite) -> []; api_to_recvmsg_udp4(doc) -> []; api_to_recvmsg_udp4(_Config) when is_list(_Config) -> %% not_yet_implemented(). tc_begin(api_to_recvmsg_udp4), ok = api_to_recvmsg_udp(inet), tc_end(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvmsg timeout option %% on an IPv6 UDP (dgram) socket. api_to_recvmsg_udp6(suite) -> []; api_to_recvmsg_udp6(doc) -> []; api_to_recvmsg_udp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_recvmsg_udp6), %% ok = api_to_recvmsg_udp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_to_recvmsg_udp(Domain) -> process_flag(trap_exit, true), p("init"), LocalAddr = which_local_addr(Domain), LocalSA = #{family => Domain, addr => LocalAddr}, p("open"), Sock = sock_open(Domain, dgram, udp), p("bind"), _Port = sock_bind(Sock, LocalSA), p("recv"), case socket:recvmsg(Sock, 5000) of {error, timeout} -> p("expected timeout"), ok; {ok, _MsgHdr} -> ?FAIL(unexpected_success); {error, Reason} -> ?FAIL({recv, Reason}) end, ok. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvmsg timeout option %% on an IPv4 TCP (stream) socket. api_to_recvmsg_tcp4(suite) -> []; api_to_recvmsg_tcp4(doc) -> []; api_to_recvmsg_tcp4(_Config) when is_list(_Config) -> tc_begin(api_to_recvmsg_tcp4), ok = api_to_recvmsg_tcp(inet), tc_end(). %% not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This test case is intended to test the recvmsg timeout option %% on an IPv6 TCP (stream) socket. api_to_recvmsg_tcp6(suite) -> []; api_to_recvmsg_tcp6(doc) -> []; api_to_recvmsg_tcp6(_Config) when is_list(_Config) -> %% tc_begin(api_to_recvmsg_tcp6), %% ok = api_to_recvmsg_tcp(inet6), %% tc_end(). not_yet_implemented(). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% api_to_recvmsg_tcp(Domain) -> process_flag(trap_exit, true), p("server -> open"), LSock = sock_open(Domain, stream, tcp), LocalAddr = which_local_addr(Domain), LocalSA = #{family => Domain, addr => LocalAddr}, p("server -> bind"), ServerLPort = sock_bind(LSock, LocalSA), p("server(~w) -> listen", [ServerLPort]), sock_listen(LSock), ClientName = f("~s:client", [get_tc_name()]), Client = spawn_link(fun() -> put(sname, ClientName), p("open"), CSock = sock_open(Domain, stream, tcp), p("bind"), ClientPort = sock_bind(CSock, LocalSA), p("[~w] connect to ~w", [ClientPort, ServerLPort]), sock_connect(CSock, LocalSA#{port => ServerLPort}), p("await termination command"), receive die -> p("terminating"), exit(normal) end end), p("server -> accept on ~w", [ServerLPort]), Sock = sock_accept(LSock), p("server -> recv"), %% The zero (0) represents "give me everything you have" case socket:recvmsg(Sock, 5000) of {error, timeout} -> p("server -> expected timeout"), ok; {ok, _Data} -> ?FAIL(unexpected_success); {error, Reason} -> ?FAIL({recv, Reason}) end, Client ! die, receive {'EXIT', Client, _} -> ok end, ok. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% This gets the local address (not 127.0...) %% We should really implement this using the (new) net module, %% but until that gets the necessary functionality... which_local_addr(Domain) -> case inet:getifaddrs() of {ok, IFL} -> which_addr(Domain, IFL); {error, Reason} -> ?FAIL({inet, getifaddrs, Reason}) end. which_addr(_Domain, []) -> ?FAIL(no_address); which_addr(Domain, [{Name, IFO}|_IFL]) when (Name =/= "lo") -> which_addr2(Domain, IFO); which_addr(Domain, [_|IFL]) -> which_addr(Domain, IFL). which_addr2(_Domain, []) -> ?FAIL(no_address); which_addr2(inet = _Domain, [{addr, Addr}|_IFO]) when (size(Addr) =:= 4) -> Addr; which_addr2(inet6 = _Domain, [{addr, Addr}|_IFO]) when (size(Addr) =:= 8) -> Addr; which_addr2(Domain, [_|IFO]) -> which_addr2(Domain, IFO). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% An evaluator is a process that executes a command sequence. %% A test case will consist of atleast one evaluator (one for %% each actor). %% The evaluator process *always* run locally. Which means that %% it will act as a "proxy" for remote nodes in necessary. %% When the command sequence has been processed, the final state %% will be used as exit reason. %% A successful command shall evaluate to ok | {ok, NewState} -spec evaluator_start(Name, Seq, Init) -> {Pid, MRef} when Name :: string(), Seq :: [command()], Init :: initial_evaluator_state(), Pid :: pid(), MRef :: reference(). evaluator_start(Name, Seq, Init) when is_list(Name) andalso is_list(Seq) andalso (Seq =/= []) -> Init2 = Init#{parent => self()}, {Pid, _} = erlang:spawn_monitor(fun() -> evaluator_init(Name, Seq, Init2) end), Pid. evaluator_init(Name, Seq, Init) -> put(sname, Name), evaluator_loop(1, Seq, Init). evaluator_loop(_ID, [], FinalState) -> exit(FinalState); evaluator_loop(ID, [#{desc := Desc, cmd := Cmd}|Cmds], State) when is_function(Cmd, 1) -> ei("evaluate command ~2w: ~s", [ID, Desc]), try Cmd(State) of ok -> evaluator_loop(ID + 1, Cmds, State); {ok, NewState} -> evaluator_loop(ID + 1, Cmds, NewState); {error, Reason} -> ee("command ~w failed: " "~n Reason: ~p", [ID, Reason]), exit({command_failed, ID, Reason, State}) catch C:E:S -> ee("command ~w crashed: " "~n Class: ~p" "~n Error: ~p" "~n Call Stack: ~p", [ID, C, E, S]), exit({command_crashed, ID, {C,E,S}, State}) end. await_evaluator_finish(Evs) -> await_evaluator_finish(Evs, []). await_evaluator_finish([], []) -> ok; await_evaluator_finish([], Fails) -> Fails; await_evaluator_finish(Evs, Fails) -> receive {'DOWN', _MRef, process, Pid, normal} -> case lists:delete(Pid, Evs) of Evs -> p("unknown process ~p died (normal)", [Pid]), await_evaluator_finish(Evs, Fails); NewEvs -> p("evaluator ~p success", [Pid]), await_evaluator_finish(NewEvs, Fails) end; {'DOWN', _MRef, process, Pid, Reason} -> case lists:delete(Pid, Evs) of Evs -> p("unknown process ~p died: " "~n ~p", [Pid, Reason]), await_evaluator_finish(Evs, Fails); NewEvs -> p("Evaluator ~p failed", [Pid]), await_evaluator_finish(NewEvs, [{Pid, Reason}|Fails]) end end. ei(F, A) -> eprint("", F, A). ee(F, A) -> eprint(" ", F, A). eprint(Prefix, F, A) -> io:format(user, "[~s][~p] ~s" ++ F ++ "~n", [get(sname), self(), Prefix | A]). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sock_open(Domain, Type, Proto) -> try socket:open(Domain, Type, Proto) of {ok, Socket} -> Socket; {error, Reason} -> ?FAIL({open, Reason}) catch C:E:S -> ?FAIL({open, C, E, S}) end. sock_bind(Sock, SockAddr) -> try socket:bind(Sock, SockAddr) of {ok, Port} -> Port; {error, Reason} -> p("sock_bind -> error: ~p", [Reason]), ?FAIL({bind, Reason}) catch C:E:S -> p("sock_bind -> failed: ~p, ~p, ~p", [C, E, S]), ?FAIL({bind, C, E, S}) end. sock_connect(Sock, SockAddr) -> try socket:connect(Sock, SockAddr) of ok -> ok; {error, Reason} -> ?FAIL({connect, Reason}) catch C:E:S -> ?FAIL({connect, C, E, S}) end. sock_sockname(Sock) -> try socket:sockname(Sock) of {ok, SockAddr} -> SockAddr; {error, Reason} -> ?FAIL({sockname, Reason}) catch C:E:S -> ?FAIL({sockname, C, E, S}) end. sock_listen(Sock) -> sock_listen2(fun() -> socket:listen(Sock) end). sock_listen(Sock, BackLog) -> sock_listen2(fun() -> socket:listen(Sock, BackLog) end). sock_listen2(Listen) -> try Listen() of ok -> ok; {error, Reason} -> ?FAIL({listen, Reason}) catch C:E:S -> ?FAIL({listen, C, E, S}) end. sock_accept(LSock) -> try socket:accept(LSock) of {ok, Sock} -> Sock; {error, Reason} -> p("sock_accept -> error: ~p", [Reason]), ?FAIL({accept, Reason}) catch C:E:S -> p("sock_accept -> failed: ~p, ~p, ~p", [C, E, S]), ?FAIL({accept, C, E, S}) end. sock_close(Sock) -> try socket:close(Sock) of ok -> ok; {error, Reason} -> p("sock_close -> error: ~p", [Reason]), ?FAIL({close, Reason}) catch C:E:S -> p("sock_close -> failed: ~p, ~p, ~p", [C, E, S]), ?FAIL({close, C, E, S}) end. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% not_yet_implemented() -> {skip, "not yet implemented"}. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% set_tc_name(N) when is_atom(N) -> set_tc_name(atom_to_list(N)); set_tc_name(N) when is_list(N) -> put(tc_name, N). get_tc_name() -> get(tc_name). tc_begin(TC) -> set_tc_name(TC), p("begin ***"). tc_end() -> p("done ***"), ok. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% f(F, A) -> lists:flatten(io_lib:format(F, A)). p(F) -> p(F, []). p(F, A) -> TcName = case get(tc_name) of undefined -> case get(sname) of undefined -> ""; SName when is_list(SName) -> SName end; Name when is_list(Name) -> Name end, i("*** ~s[~p] " ++ F, [TcName,self()|A]). %% i(F) -> %% i(F, []). i(F, A) -> io:format(user, F ++ "~n", A).