feat(dgram): improve send err handling

Author: qzhuyan

src/quicer.erl

@@ -71,6 +71,7 @@
     async_send/2,
     async_send/3,
     recv/2,
+    async_send_dgram/2,
     send_dgram/2,
     shutdown_stream/1,
     shutdown_stream/2,
@@ -844,33 +845,39 @@ do_recv(Stream, Count, Buff) ->
             E
     end.
 
-%% @doc Sending Unreliable Datagram
+%% @doc Sending Unreliable Datagram.
+%% Caller should handle the async signals for the send results
 %%
-%% ref: [https://datatracker.ietf.org/doc/html/draft-ietf-quic-datagram]
-%% @see send/2
+%% ref: [https://datatracker.ietf.org/doc/html/rfc9221]
+%% @see send/2 send_dgram/2
+-spec async_send_dgram(connection_handle(), binary()) ->
+    {ok, non_neg_integer()}
+    | {error, badarg | not_enough_mem | closed}
+    | {error, dgram_send_error, atom_reason()}.
+async_send_dgram(Conn, Data) ->
+    quicer_nif:send_dgram(Conn, Data, _IsSyncRel = 1).
+
+%% @doc Sending Unreliable Datagram, returns the end state.
+%%
+%% %% ref: [https://datatracker.ietf.org/doc/html/rfc9221]
+%% @see send/2, async_send_dgram
 -spec send_dgram(connection_handle(), binary()) ->
-    {ok, BytesSent :: pos_integer()}
+    {ok, BytesSent :: non_neg_integer()}
     | {error, badarg | not_enough_mem | closed}
     | {error, dgram_send_error, atom_reason()}.
 send_dgram(Conn, Data) ->
     case quicer_nif:send_dgram(Conn, Data, _IsSync = 1) of
-        %% @todo we need find tuned event mask
         {ok, _Len} = OK ->
-            receive
-                {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_SENT}} ->
-                    receive
-                        {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_ACKNOWLEDGED}} ->
-                            OK;
-                        {quic, dgram_send_state, Conn, #{state := Other}} ->
-                            {error, dgram_send_error, Other}
-                    end;
-                {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_ACKNOWLEDGED}} ->
+            case quicer_lib:handle_dgram_send_states(Conn) of
+                ok ->
                     OK;
-                {quic, dgram_send_state, Conn, #{state := Other}} ->
-                    {error, dgram_send_error, Other}
+                {error, E} ->
+                    {error, dgram_send_error, E}
             end;
-        E ->
-            E
+        {error, _, _} = E ->
+            E;
+        {error, E} ->
+            {error, dgram_send_error, E}
     end.
 
 %% @doc Shutdown stream gracefully, with infinity timeout

src/quicer_lib.erl

@@ -41,7 +41,10 @@
 
 -type action() :: hibernate | timeout() | {continue, Continue :: term()}.
 
--export([default_cb_ret/2]).
+-export([
+    default_cb_ret/2,
+    handle_dgram_send_states/1
+]).
 
 -spec default_cb_ret(cb_ret(), State :: term()) ->
     {reply, NewState :: term()}
@@ -69,3 +72,43 @@ default_cb_ret({reply, Reply, NewCBState, Action}, State) ->
     {reply, Reply, State#{callback_state := NewCBState}, Action};
 default_cb_ret({reply, Reply, NewCBState}, State) ->
     {reply, Reply, State#{callback_state := NewCBState}}.
+
+-spec handle_dgram_send_states(connection_handle()) ->
+    ok
+    | {error,
+        dgram_send_canceled
+        | dgram_send_unknown
+        | dgram_send_lost_discarded}.
+handle_dgram_send_states(Conn) ->
+    handle_dgram_send_states(init, Conn).
+handle_dgram_send_states(init, Conn) ->
+    receive
+        {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_SENT}} ->
+            handle_dgram_send_states(sent, Conn);
+        {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_ACKNOWLEDGED}} ->
+            %% @TODO unsure if it will hit here
+            ok;
+        {quic, dgram_send_state, Conn, #{state := E}} ->
+            {error, E}
+    end;
+handle_dgram_send_states(sent, Conn) ->
+    receive
+        {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_ACKNOWLEDGED}} ->
+            %% Happy Track
+            ok;
+        {quic, dgram_send_state, Conn, #{state := ?QUIC_DATAGRAM_SEND_LOST_SUSPECT}} ->
+            %% Lost suspected
+            receive
+                {quic, dgram_send_state, Conn, #{
+                    state := ?QUIC_DATAGRAM_SEND_ACKNOWLEDGED_SPURIOUS
+                }} ->
+                    %% Lost recovered
+                    ok;
+                {quic, dgram_send_state, Conn, #{state := EState}} ->
+                    %% Unrecoverable Errors.
+                    {error, EState}
+            end;
+        {quic, dgram_send_state, Conn, #{state := EState}} ->
+            %% Unrecoverable Errors.
+            {error, EState}
+    end.

test/quicer_SUITE.erl

@@ -75,6 +75,7 @@
 
     tc_dgram_client_send/1,
     tc_dgram_client_send_iolist/1,
+    tc_dgram_client_send_fail/1,
 
     % , tc_getopt_raw/1
     tc_getopt/1,
@@ -859,7 +860,7 @@ tc_stream_controlling_process_demon(Config) ->
             ok = quicer:setopt(Stm, active, true),
             {ok, _Len} = quicer:send(Stm, <<"owner_changed">>),
             receive
-                {quic, <<"owner_changed">>, Stm, _} ->
+                {quic, <<"owner_changed">>, _Stm, _} ->
                     ok
             end,
             %% Set controlling_process again
@@ -883,6 +884,15 @@ tc_stream_controlling_process_demon(Config) ->
         ct:fail("timeout")
     end.
 
+tc_dgram_client_send_fail(_) ->
+    Opts = default_conn_opts() ++ [{datagram_receive_enabled, 1}],
+    {ok, Conn} = quicer:async_connect("localhost", 65535, Opts),
+    ?assertEqual(
+        {error, dgram_send_error, dgram_send_canceled},
+        quicer:send_dgram(Conn, <<"ping">>)
+    ),
+    ok.
+
 tc_dgram_client_send(Config) ->
     Port = select_port(),
     Owner = self(),