Fix tests

Author: mickel8

c_src/ex_dtls/native.c

@@ -331,13 +331,12 @@ UNIFEX_TERM handle_data(UnifexEnv *env, State *state, UnifexPayload *payload) {
 
 UNIFEX_TERM handle_regular_read(State *state, char data[], int ret) {
   if (ret > 0) {
-    UnifexPayload **packets = calloc(1, sizeof(UnifexPayload *));
-    packets[0] = calloc(1, sizeof(UnifexPayload));
-    unifex_payload_alloc(state->env, UNIFEX_PAYLOAD_BINARY, ret, packets[0]);
-    memcpy(packets[0]->data, data, ret);
-    packets[0]->size = (unsigned int)ret;
-    UNIFEX_TERM res_term = handle_data_result_ok(state->env, packets, 1);
-    free_payload_array(packets, 1);
+    UnifexPayload packets;
+    unifex_payload_alloc(state->env, UNIFEX_PAYLOAD_BINARY, ret, &packets);
+    memcpy(packets.data, data, ret);
+    packets.size = (unsigned int)ret;
+    UNIFEX_TERM res_term = handle_data_result_ok(state->env, &packets);
+    unifex_payload_release(&packets);
     return res_term;
   }
 

c_src/ex_dtls/native.spec.exs

@@ -28,7 +28,7 @@ spec handle_timeout(state) :: (:ok :: label) | {:retransmit :: label, packets ::
 spec write_data(state, packets :: payload) :: {:ok :: label, packets :: [payload]} | {:error :: label, :handshake_not_finished :: label}
 
 spec handle_data(state, packets :: payload) ::
-       {:ok :: label, packets :: [payload]}
+       {:ok :: label, packets :: payload}
        | (:handshake_want_read :: label)
        | {:handshake_packets :: label, packets :: [payload], timeout :: int}
        | {:handshake_finished :: label, client_keying_material :: payload,

lib/ex_dtls.ex

@@ -175,7 +175,7 @@ defmodule ExDTLS do
           | {:error, :handshake_error | :peer_closed_for_writing}
   def handle_data(dtls, packets) do
     case Native.handle_data(dtls, packets) do
-      {:handshake_finished, lkm, rkm, protection_profile, <<>>} ->
+      {:handshake_finished, lkm, rkm, protection_profile, []} ->
         {:handshake_finished, lkm, rkm, protection_profile}
 
       other ->

test/integration_test.exs

@@ -1,7 +1,6 @@
 defmodule ExDTLS.IntegrationTest do
   use ExUnit.Case, async: true
 
-  @tag :debug
   test "dtls_srtp" do
     rx_dtls = ExDTLS.init(mode: :server, dtls_srtp: true, verify_peer: true)
     tx_dtls = ExDTLS.init(mode: :client, dtls_srtp: true, verify_peer: true)
@@ -39,14 +38,12 @@ defmodule ExDTLS.IntegrationTest do
     assert :ok == loop({sr_dtls, false}, {cl_dtls, false}, packets)
 
     msg = <<1, 3, 2, 5>>
-    assert {:ok, data} = ExDTLS.write_data(cl_dtls, msg)
-    assert data != msg
-    assert {:ok, ^msg} = ExDTLS.handle_data(sr_dtls, data)
+    assert {:ok, packets} = ExDTLS.write_data(cl_dtls, msg)
+    assert {:ok, ^msg} = feed_packets(sr_dtls, packets)
 
     msg = <<1, 3, 8, 9>>
-    assert {:ok, data} = ExDTLS.write_data(sr_dtls, msg)
-    assert data != msg
-    assert {:ok, ^msg} = ExDTLS.handle_data(cl_dtls, data)
+    assert {:ok, packets} = ExDTLS.write_data(sr_dtls, msg)
+    assert {:ok, ^msg} = feed_packets(cl_dtls, packets)
   end
 
   test "expired cert" do
@@ -59,8 +56,8 @@ defmodule ExDTLS.IntegrationTest do
     tx_dtls = ExDTLS.init(mode: :client, dtls_srtp: true, verify_peer: true)
 
     {packets, _timeout} = ExDTLS.do_handshake(tx_dtls)
-    {:handshake_packets, packets, _timeout} = ExDTLS.handle_data(rx_dtls, packets)
-    assert {:error, :handshake_error} = ExDTLS.handle_data(tx_dtls, packets)
+    {:handshake_packets, packets, _timeout} = feed_packets(rx_dtls, packets)
+    assert {:error, :handshake_error} = feed_packets(tx_dtls, packets)
   end
 
   defp loop({_dtls1, true}, {_dtls2, true}, _packets) do
@@ -83,6 +80,9 @@ defmodule ExDTLS.IntegrationTest do
   defp feed_packets(dtls, [packet | packets]) do
     case ExDTLS.handle_data(dtls, packet) do
       :handshake_want_read -> feed_packets(dtls, packets)
+      # it seems that handshake error (e.g. when a certificate is too old)
+      # may appear before consuming all packets
+      {:error, :handshake_error} = msg -> msg
       other when packets == [] -> other
     end
   end

test/retransmission_test.exs

@@ -10,7 +10,7 @@ defmodule ExDTLS.RetransmissionTest do
     {:retransmit, packets, timeout} = wait_for_timeout(tx_dtls, :tx)
     Process.send_after(self(), {:handle_timeout, :tx}, timeout)
 
-    {:handshake_packets, _packets, timeout} = ExDTLS.handle_data(rx_dtls, packets)
+    {:handshake_packets, _packets, timeout} = feed_packets(rx_dtls, packets)
     Process.send_after(self(), {:handle_timeout, :rx}, timeout)
     {:retransmit, packets, _timeout} = wait_for_timeout(rx_dtls, :rx)
 
@@ -19,7 +19,7 @@ defmodule ExDTLS.RetransmissionTest do
     # and waiting for the old one and handling it can trigger retransmission
     # instead of noop
     Process.sleep(500)
-    {:handshake_packets, _packets, timeout} = ExDTLS.handle_data(tx_dtls, packets)
+    {:handshake_packets, _packets, timeout} = feed_packets(tx_dtls, packets)
     Process.send_after(self(), {:handle_timeout, :tx}, timeout)
     # wait for the old timeout
     :ok = wait_for_timeout(tx_dtls, :tx)
@@ -36,8 +36,18 @@ defmodule ExDTLS.RetransmissionTest do
   end
 
   defp finish_hsk(rx_dtls, tx_dtls, packets) do
-    {:handshake_finished, _lkm, _rkm, _p, packets} = ExDTLS.handle_data(rx_dtls, packets)
-    {:handshake_finished, _lkm, _rkm, _p} = ExDTLS.handle_data(tx_dtls, packets)
+    {:handshake_finished, _lkm, _rkm, _p, packets} = feed_packets(rx_dtls, packets)
+    {:handshake_finished, _lkm, _rkm, _p} = feed_packets(tx_dtls, packets)
     :ok
   end
+
+  defp feed_packets(dtls, [packet | packets]) do
+    case ExDTLS.handle_data(dtls, packet) do
+      :handshake_want_read -> feed_packets(dtls, packets)
+      # it seems that handshake error (e.g. when a certificate is too old)
+      # may appear before consuming all packets
+      {:error, :handshake_error} = msg -> msg
+      other when packets == [] -> other
+    end
+  end
 end