Merge branch 'bmk/20181101/nififying_inet_ping_pong/OTP-14831' into bmk/20180918/nififying_inet/OTP-14831

7 files changed, 2549 insertions, 69 deletions

diff --git a/erts/doc/src/socket.xml b/erts/doc/src/socket.xml
index 49c14869bf..ea2fde7dee 100644
--- a/erts/doc/src/socket.xml
+++ b/erts/doc/src/socket.xml
@@ -405,7 +405,8 @@
       <name name="recvmsg" arity="1"/>
       <name name="recvmsg" arity="2" clause_i="1"/>
       <name name="recvmsg" arity="2" clause_i="2"/>
-      <name name="recvmsg" arity="3"/>
+      <name name="recvmsg" arity="3" clause_i="1"/>
+      <name name="recvmsg" arity="3" clause_i="2"/>
       <name name="recvmsg" arity="5"/>
       <fsummary>Receive a message from a socket.</fsummary>
       <desc>
@@ -416,7 +417,7 @@
 	which may contain the source address (if socket not connected),
 	a list of <c>cmsghdr_recv()</c> (depends on what socket options have
 	been set and what the protocol and platform supports) and
-	also a set of flags, providing further info about the read . </p>
+	also a set of flags, providing further info about the read. </p>
 	
         <p>The <c>BufSz</c> argument basically defines the size of the
 	receive buffer. By setting the value to zero (0), the configured
@@ -458,6 +459,15 @@
 	which also contains the message to send,
 	The <c>MsgHdr</c> may also contain an list of optional <c>cmsghdr_send()</c>
 	(depends on what the protocol and platform supports).</p>
+
+	<p>Unlike the <seealso marker="#send"><c>send</c></seealso> function,
+	this one sends <em>one message</em>.
+	This means that if, for whatever reason, its not possible to send the
+	message in one go, the function will instead return with the
+	<em>remaining</em> data (<c>{ok, Remaining}</c>). Thereby leaving it
+	up to the caller to decide what to do (retry with the remaining data
+	of give up). </p>
+
       </desc>
     </func>
 
diff --git a/erts/emulator/nifs/common/socket_dbg.c b/erts/emulator/nifs/common/socket_dbg.c
index dd11fbca9b..fe9135e5a0 100644
--- a/erts/emulator/nifs/common/socket_dbg.c
+++ b/erts/emulator/nifs/common/socket_dbg.c
@@ -36,10 +36,32 @@
 #define TNAME(__T__)       enif_thread_name( __T__ )
 #define TSNAME()           TNAME(TSELF())
 
+static FILE* dbgout = NULL;
+
 static int realtime(struct timespec* tsP);
 static int timespec2str(char *buf, unsigned int len, struct timespec *ts);
 
 
+extern
+void esock_dbg_init(char* filename)
+{
+  if (filename != NULL) {
+    if (strcmp(filename, ESOCK_DBGOUT_DEFAULT) == 0) {
+      dbgout = stdout;
+    } else if (strcmp(filename, ESOCK_DBGOUT_UNIQUE) == 0) {
+      char template[] = "/tmp/esock-dbg-XXXXXX";
+      dbgout = fdopen(mkstemp(template), "w+");
+    } else {
+      dbgout = fopen(filename, "w+");
+    }
+  } else {
+    char template[] = "/tmp/esock-dbg-XXXXXX";
+    dbgout = fdopen(mkstemp(template), "w+");
+  }
+}
+
+
+
 /*
  * Print a debug format string *with* both a timestamp and the
  * the name of the *current* thread.
@@ -70,7 +92,7 @@ void esock_dbg_printf( const char* prefix, const char* format, ... )
 
     if (res > 0) {
       va_start (args, format);
-      enif_vfprintf (stdout, f, args);
+      enif_vfprintf (dbgout, f, args);
       va_end (args);
       fflush(stdout);
     }
diff --git a/erts/emulator/nifs/common/socket_dbg.h b/erts/emulator/nifs/common/socket_dbg.h
index ad0fcdada9..47739b46da 100644
--- a/erts/emulator/nifs/common/socket_dbg.h
+++ b/erts/emulator/nifs/common/socket_dbg.h
@@ -27,6 +27,10 @@
 #ifndef SOCKET_DBG_H__
 #define SOCKET_DBG_H__
 
+/* Used when calling the init function */
+#define ESOCK_DBGOUT_DEFAULT "stdout"
+#define ESOCK_DBGOUT_UNIQUE  "unique"
+
 
 /* Used in debug printouts */
 #ifdef __WIN32__
@@ -45,7 +49,7 @@ typedef unsigned long long llu_t;
     }
 
 
-extern
-void esock_dbg_printf( const char* prefix, const char* format, ... );
+extern void esock_dbg_init(char* filename);
+extern void esock_dbg_printf( const char* prefix, const char* format, ... );
 
 #endif // SOCKET_DBG_H__
diff --git a/erts/emulator/nifs/common/socket_nif.c b/erts/emulator/nifs/common/socket_nif.c
index 27395b5cf6..f657da3ace 100644
--- a/erts/emulator/nifs/common/socket_nif.c
+++ b/erts/emulator/nifs/common/socket_nif.c
@@ -4919,6 +4919,9 @@ ERL_NIF_TERM naccept_listening(ErlNifEnv*        env,
         accDescP->domain   = descP->domain;
         accDescP->type     = descP->type;
         accDescP->protocol = descP->protocol;
+        accDescP->rBufSz   = descP->rBufSz;  // Inherit buffer size
+        accDescP->rCtrlSz  = descP->rCtrlSz; // Inherit buffer siez
+        accDescP->wCtrlSz  = descP->wCtrlSz; // Inherit buffer size
 
         accRef = enif_make_resource(env, accDescP);
         enif_release_resource(accDescP); // We should really store a reference ...
@@ -5580,7 +5583,7 @@ ERL_NIF_TERM nsendmsg(ErlNifEnv*        env,
     if (IS_SOCKET_ERROR(written))
         save_errno = sock_errno();
     else
-        save_errno = -1; // The value does not actually matter in this case
+        save_errno = -1; // OK or not complete: this value should not matter in this case
 
     res = send_check_result(env, descP, written, dataSize, save_errno, sendRef);
 
@@ -9549,7 +9552,17 @@ ERL_NIF_TERM nsetopt_int_opt(ErlNifEnv*        env,
     int          val;
 
     if (GET_INT(env, eVal, &val)) {
-        int res = socket_setopt(descP->sock, level, opt, &val, sizeof(val));
+        int res;
+
+        /*
+        SSDBG( descP,
+               ("SOCKET", "nsetopt_int_opt -> set option"
+                "\r\n   opt: %d"
+                "\r\n   val: %d"
+                "\r\n", opt, val) );
+        */
+
+        res = socket_setopt(descP->sock, level, opt, &val, sizeof(val));
 
         if (res != 0)
             result = esock_make_error_errno(env, sock_errno());
@@ -13314,13 +13327,12 @@ ERL_NIF_TERM send_check_result(ErlNifEnv*        env,
 
             SSDBG( descP, ("SOCKET", "send_check_result -> try again\r\n") );
 
-            /* <KOLLA>
-             * SHOULD RESULT IN {error, eagain}!!!!
-             * </KOLLA>
-             */
-            written = 0;
+            SELECT(env, descP->sock, (ERL_NIF_SELECT_WRITE), descP, NULL, sendRef);
+
+            return esock_make_error(env, esock_atom_eagain);
 
         }
+
     }
 
     /* We failed to write the *entire* packet (anything less then size
@@ -13345,11 +13357,11 @@ ERL_NIF_TERM send_check_result(ErlNifEnv*        env,
 
     cnt_inc(&descP->writeWaits, 1);
 
-    SELECT(env, descP->sock, (ERL_NIF_SELECT_WRITE),
-           descP, NULL, sendRef);
+    SELECT(env, descP->sock, (ERL_NIF_SELECT_WRITE), descP, NULL, sendRef);
 
     SSDBG( descP,
-           ("SOCKET", "send_check_result -> not entire package written\r\n") );
+           ("SOCKET", "send_check_result -> "
+            "not entire package written (%d of %d)\r\n", written, dataSize) );
 
     return esock_make_ok2(env, MKI(env, written));
 
@@ -13687,15 +13699,26 @@ ERL_NIF_TERM recv_check_result(ErlNifEnv*        env,
 
         } else if ((saveErrno == ERRNO_BLOCK) ||
                    (saveErrno == EAGAIN)) {
+            int sres;
+
             SSDBG( descP, ("SOCKET",
                            "recv_check_result -> [%d] eagain\r\n", toRead) );
 
             if ((xres = recv_init_current_reader(env, descP, recvRef)) != NULL)
                 return esock_make_error_str(env, xres);
             
+            SSDBG( descP, ("SOCKET", "recv_check_result -> SELECT for more\r\n") );
+
+            /*
             SELECT(env, descP->sock, (ERL_NIF_SELECT_READ),
                    descP, NULL, recvRef);
+            */
+
+            sres = enif_select(env, descP->sock, (ERL_NIF_SELECT_READ),
+                               descP, NULL, recvRef);
 
+            SSDBG( descP, ("SOCKET", "recv_check_result -> SELECT res: %d\r\n", sres) );
+            
             return esock_make_error(env, esock_atom_eagain);
         } else {
             ERL_NIF_TERM res = esock_make_error_errno(env, saveErrno);
@@ -13802,6 +13825,7 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*        env,
         /* +++ Error handling +++ */
 
         if (saveErrno == ECONNRESET)  {
+            ERL_NIF_TERM res = esock_make_error(env, atom_closed);
 
             /* +++ Oups - closed +++ */
 
@@ -13819,12 +13843,14 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*        env,
             descP->closeLocal = FALSE;
             descP->state      = SOCKET_STATE_CLOSING;
 
+            recv_error_current_reader(env, descP, res);
+
             SELECT(env,
                    descP->sock,
                    (ERL_NIF_SELECT_STOP),
                    descP, NULL, recvRef);
 
-            return esock_make_error(env, atom_closed);
+            return res;
 
         } else if ((saveErrno == ERRNO_BLOCK) ||
                    (saveErrno == EAGAIN)) {
@@ -13839,12 +13865,15 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*        env,
 
             return esock_make_error(env, esock_atom_eagain);
         } else {
+            ERL_NIF_TERM res = esock_make_error_errno(env, saveErrno);
 
             SSDBG( descP,
                    ("SOCKET",
                     "recvfrom_check_result -> errno: %d\r\n", saveErrno) );
             
-            return esock_make_error_errno(env, saveErrno);
+            recv_error_current_reader(env, descP, res);
+
+            return res;
         }
 
     } else {
@@ -13871,6 +13900,8 @@ ERL_NIF_TERM recvfrom_check_result(ErlNifEnv*        env,
             data = MKSBIN(env, data, 0, read);
         }
 
+        recv_update_current_reader(env, descP);
+        
         return esock_make_ok2(env, MKT2(env, eSockAddr, data));
 
     }
@@ -13934,6 +13965,7 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*        env,
         /* +++ Error handling +++ */
 
         if (saveErrno == ECONNRESET)  {
+            ERL_NIF_TERM res = esock_make_error(env, atom_closed);
 
             /* +++ Oups - closed +++ */
 
@@ -13951,12 +13983,14 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*        env,
             descP->closeLocal = FALSE;
             descP->state      = SOCKET_STATE_CLOSING;
 
+            recv_error_current_reader(env, descP, res);
+
             SELECT(env,
                    descP->sock,
                    (ERL_NIF_SELECT_STOP),
                    descP, NULL, recvRef);
 
-            return esock_make_error(env, atom_closed);
+            return res;
 
         } else if ((saveErrno == ERRNO_BLOCK) ||
                    (saveErrno == EAGAIN)) {
@@ -13972,12 +14006,15 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*        env,
 
             return esock_make_error(env, esock_atom_eagain);
         } else {
+            ERL_NIF_TERM res = esock_make_error_errno(env, saveErrno);
 
             SSDBG( descP,
                    ("SOCKET",
                     "recvmsg_check_result -> errno: %d\r\n", saveErrno) );
             
-            return esock_make_error_errno(env, saveErrno);
+            recv_error_current_reader(env, descP, res);
+
+            return res;
         }
 
     } else {
@@ -14006,6 +14043,8 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*        env,
                     "recvmsg_check_result -> "
                     "(msghdr) encode failed: %s\r\n", xres) );
             
+            recv_update_current_reader(env, descP);
+        
             return esock_make_error_str(env, xres);
         } else {
 
@@ -14014,6 +14053,8 @@ ERL_NIF_TERM recvmsg_check_result(ErlNifEnv*        env,
                     "recvmsg_check_result -> "
                     "(msghdr) encode ok: %T\r\n", eMsgHdr) );
             
+            recv_update_current_reader(env, descP);
+
             return esock_make_ok2(env, eMsgHdr);
         }
 
@@ -16717,12 +16758,12 @@ int esock_monitor(const char*       slogan,
 {
     int res;
 
-    SSDBG( descP, ("SOCKET", "[%d] %s: try monitor", descP->sock, slogan) );
+    SSDBG( descP, ("SOCKET", "[%d] %s: try monitor\r\n", descP->sock, slogan) );
     /* esock_dbg_printf("MONP", "[%d] %s\r\n", descP->sock, slogan); */
     res = enif_monitor_process(env, descP, pid, &monP->mon);
 
     if (res != 0) {
-        SSDBG( descP, ("SOCKET", "[%d] monitor failed: %d", descP->sock, res) );
+        SSDBG( descP, ("SOCKET", "[%d] monitor failed: %d\r\n", descP->sock, res) );
         // esock_dbg_printf("MONP", "[%d] failed: %d\r\n", descP->sock, res);
     } /* else {
         esock_dbg_printf("MONP",
@@ -16890,18 +16931,22 @@ void socket_stop(ErlNifEnv* env, void* obj, int fd, int is_direct_call)
         SSDBG( descP, ("SOCKET", "socket_stop -> handle current writer\r\n") );
         if (!compare_pids(env,
                           &descP->closerPid,
-                          &descP->currentWriter.pid) &&
-            send_msg_nif_abort(env,
-                               descP->currentWriter.ref,
-                               atom_closed,
-                               &descP->currentWriter.pid) != NULL) {
-            /* Shall we really do this? 
-             * This happens if the controlling process has been killed!
-             */
-            esock_warning_msg("Failed sending abort (%T) message to "
-                              "current writer %T\r\n",
-                              descP->currentWriter.ref,
-                              descP->currentWriter.pid);
+                          &descP->currentWriter.pid)) {
+            SSDBG( descP, ("SOCKET", "socket_stop -> "
+                           "send abort message to current writer %T\r\n",
+                           descP->currentWriter.pid) );
+            if (send_msg_nif_abort(env,
+                                   descP->currentWriter.ref,
+                                   atom_closed,
+                                   &descP->currentWriter.pid) != NULL) {
+                /* Shall we really do this? 
+                 * This happens if the controlling process has been killed!
+                 */
+                esock_warning_msg("Failed sending abort (%T) message to "
+                                  "current writer %T\r\n",
+                                  descP->currentWriter.ref,
+                                  descP->currentWriter.pid);
+            }
         }
         
         /* And also deal with the waiting writers (in the same way) */
@@ -16925,18 +16970,22 @@ void socket_stop(ErlNifEnv* env, void* obj, int fd, int is_direct_call)
         SSDBG( descP, ("SOCKET", "socket_stop -> handle current reader\r\n") );
         if (!compare_pids(env,
                           &descP->closerPid,
-                          &descP->currentReader.pid) &&
-            send_msg_nif_abort(env,
-                               descP->currentReader.ref,
-                               atom_closed,
-                               &descP->currentReader.pid) != NULL) {
-            /* Shall we really do this? 
-             * This happens if the controlling process has been killed!
-             */
-            esock_warning_msg("Failed sending abort (%T) message to "
-                              "current reader %T\r\n",
-                              descP->currentReader.ref,
-                              descP->currentReader.pid);
+                          &descP->currentReader.pid)) {
+            SSDBG( descP, ("SOCKET", "socket_stop -> "
+                           "send abort message to current reader %T\r\n",
+                           descP->currentReader.pid) );
+            if (send_msg_nif_abort(env,
+                                   descP->currentReader.ref,
+                                   atom_closed,
+                                   &descP->currentReader.pid) != NULL) {
+                /* Shall we really do this? 
+                 * This happens if the controlling process has been killed!
+                 */
+                esock_warning_msg("Failed sending abort (%T) message to "
+                                  "current reader %T\r\n",
+                                  descP->currentReader.ref,
+                                  descP->currentReader.pid);
+            }
         }
         
         /* And also deal with the waiting readers (in the same way) */
@@ -16959,18 +17008,22 @@ void socket_stop(ErlNifEnv* env, void* obj, int fd, int is_direct_call)
         SSDBG( descP, ("SOCKET", "socket_stop -> handle current acceptor\r\n") );
         if (!compare_pids(env,
                           &descP->closerPid,
-                          &descP->currentAcceptor.pid) &&
-            send_msg_nif_abort(env,
-                               descP->currentAcceptor.ref,
-                               atom_closed,
-                               &descP->currentAcceptor.pid) != NULL) {
-            /* Shall we really do this? 
-             * This happens if the controlling process has been killed!
-             */
-            esock_warning_msg("Failed sending abort (%T) message to "
-                              "current acceptor %T\r\n",
-                              descP->currentAcceptor.ref,
-                              descP->currentAcceptor.pid);
+                          &descP->currentAcceptor.pid)) {
+            SSDBG( descP, ("SOCKET", "socket_stop -> "
+                           "send abort message to current acceptor %T\r\n",
+                           descP->currentWriter.pid) );
+            if (send_msg_nif_abort(env,
+                                   descP->currentAcceptor.ref,
+                                   atom_closed,
+                                   &descP->currentAcceptor.pid) != NULL) {
+                /* Shall we really do this? 
+                 * This happens if the controlling process has been killed!
+                 */
+                esock_warning_msg("Failed sending abort (%T) message to "
+                                  "current acceptor %T\r\n",
+                                  descP->currentAcceptor.ref,
+                                  descP->currentAcceptor.pid);
+            }
         }
         
         /* And also deal with the waiting acceptors (in the same way) */
@@ -17082,6 +17135,7 @@ void inform_waiting_procs(ErlNifEnv*          env,
                                                   currentP->data.ref,
                                                   reason,
                                                   &currentP->data.pid)) );
+
         DEMONP("inform_waiting_procs -> current 'request'",
                env, descP, &currentP->data.mon);
         nextP = currentP->nextP;
@@ -17576,6 +17630,9 @@ BOOLEAN_T extract_iow(ErlNifEnv*   env,
 static
 int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
+    esock_dbg_init(ESOCK_DBGOUT_DEFAULT);
+    // esock_dbg_init(ESOCK_DBGOUT_UNIQUE);
+
     data.dbg = extract_debug(env, load_info);
     data.iow = extract_iow(env, load_info);
 
diff --git a/erts/emulator/test/socket_SUITE.erl b/erts/emulator/test/socket_SUITE.erl
index 7a1a362181..4a381843a9 100644
--- a/erts/emulator/test/socket_SUITE.erl
+++ b/erts/emulator/test/socket_SUITE.erl
@@ -18,6 +18,8 @@
 %% %CopyrightEnd%
 %%
 
+%% ts:run(emulator, socket_SUITE, [batch]).
+
 -module(socket_SUITE).
 
 -include_lib("common_test/include/ct.hrl").
@@ -88,8 +90,31 @@
 
          %% Traffic
          traffic_send_and_recv_chunks_tcp4/1,
-         traffic_send_and_recv_chunks_tcp6/1
-
+         traffic_send_and_recv_chunks_tcp6/1,
+
+         traffic_ping_pong_small_send_and_recv_tcp4/1,
+         traffic_ping_pong_small_send_and_recv_tcp6/1,
+         traffic_ping_pong_medium_send_and_recv_tcp4/1,
+         traffic_ping_pong_medium_send_and_recv_tcp6/1,
+         traffic_ping_pong_large_send_and_recv_tcp4/1,
+         traffic_ping_pong_large_send_and_recv_tcp6/1,
+
+         traffic_ping_pong_small_sendto_and_recvfrom_udp4/1,
+         traffic_ping_pong_small_sendto_and_recvfrom_udp6/1,
+         traffic_ping_pong_medium_sendto_and_recvfrom_udp4/1,
+         traffic_ping_pong_medium_sendto_and_recvfrom_udp6/1,
+
+         traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4/1,
+         traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6/1,
+         traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4/1,
+         traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6/1,
+         traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4/1,
+         traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6/1,
+
+         traffic_ping_pong_small_sendmsg_and_recvmsg_udp4/1,
+         traffic_ping_pong_small_sendmsg_and_recvmsg_udp6/1,
+         traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4/1,
+         traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6/1
 
          %% Tickets
         ]).
@@ -115,6 +140,16 @@
 
 -define(TT(T),   ct:timetrap(T)).
 
+-define(LIB,     socket_test_lib).
+
+-define(TPP_SMALL,  lists:seq(1, 8)).
+-define(TPP_MEDIUM, lists:flatten(lists:duplicate(1024, ?TPP_SMALL))).
+-define(TPP_LARGE,  lists:flatten(lists:duplicate(1024, ?TPP_MEDIUM))).
+
+-define(TPP_SMALL_NUM,  100000).
+-define(TPP_MEDIUM_NUM, 100000).
+-define(TPP_LARGE_NUM,  1000).
+
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -243,7 +278,31 @@ sc_rc_cases() ->
 traffic_cases() ->
     [
      traffic_send_and_recv_chunks_tcp4,
-     traffic_send_and_recv_chunks_tcp6
+     traffic_send_and_recv_chunks_tcp6,
+
+     traffic_ping_pong_small_send_and_recv_tcp4,
+     traffic_ping_pong_small_send_and_recv_tcp6,
+     traffic_ping_pong_medium_send_and_recv_tcp4,
+     traffic_ping_pong_medium_send_and_recv_tcp6,
+     traffic_ping_pong_large_send_and_recv_tcp4,
+     traffic_ping_pong_large_send_and_recv_tcp6,
+
+     traffic_ping_pong_small_sendto_and_recvfrom_udp4,
+     traffic_ping_pong_small_sendto_and_recvfrom_udp6,
+     traffic_ping_pong_medium_sendto_and_recvfrom_udp4,
+     traffic_ping_pong_medium_sendto_and_recvfrom_udp6,
+
+     traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4,
+     traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6,
+     traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4,
+     traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6,
+     traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4,
+     traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6,
+
+     traffic_ping_pong_small_sendmsg_and_recvmsg_udp4,
+     traffic_ping_pong_small_sendmsg_and_recvmsg_udp6,
+     traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4,
+     traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6
     ].
 
 
@@ -5713,6 +5772,8 @@ traffic_send_and_recv_chunks_tcp6(_Config) when is_list(_Config) ->
            end).
 
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
 traffic_send_and_recv_chunks_tcp(InitState) ->
     ServerSeq =
         [
@@ -6663,7 +6724,2275 @@ traffic_snr_tcp_client_await_terminate(Parent) ->
     end.
 
 
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv4.
+
+traffic_ping_pong_small_send_and_recv_tcp4(suite) ->
+    [];
+traffic_ping_pong_small_send_and_recv_tcp4(doc) ->
+    [];
+traffic_ping_pong_small_send_and_recv_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_send_and_recv_tcp4,
+           fun() ->
+                   ?TT(?SECS(15)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv6.
+
+traffic_ping_pong_small_send_and_recv_tcp6(suite) ->
+    [];
+traffic_ping_pong_small_send_and_recv_tcp6(doc) ->
+    [];
+traffic_ping_pong_small_send_and_recv_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_send_and_recv_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(15)),
+                   InitState = #{domain => inet6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv4.
+
+traffic_ping_pong_medium_send_and_recv_tcp4(suite) ->
+    [];
+traffic_ping_pong_medium_send_and_recv_tcp4(doc) ->
+    [];
+traffic_ping_pong_medium_send_and_recv_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_send_and_recv_tcp4,
+           fun() ->
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv6.
+
+traffic_ping_pong_medium_send_and_recv_tcp6(suite) ->
+    [];
+traffic_ping_pong_medium_send_and_recv_tcp6(doc) ->
+    [];
+traffic_ping_pong_medium_send_and_recv_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_send_and_recv_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'large' message test case, for IPv4.
+
+traffic_ping_pong_large_send_and_recv_tcp4(suite) ->
+    [];
+traffic_ping_pong_large_send_and_recv_tcp4(doc) ->
+    [];
+traffic_ping_pong_large_send_and_recv_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_LARGE),
+    Num = ?TPP_LARGE_NUM,
+    tc_try(traffic_ping_pong_large_send_and_recv_tcp4,
+           fun() ->
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the send and recv functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'large' message test case, for IPv6.
+
+traffic_ping_pong_large_send_and_recv_tcp6(suite) ->
+    [];
+traffic_ping_pong_large_send_and_recv_tcp6(doc) ->
+    [];
+traffic_ping_pong_large_send_and_recv_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_LARGE),
+    Num = ?TPP_LARGE_NUM,
+    tc_try(traffic_ping_pong_large_send_and_recv_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_send_and_recv_tcp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendto and recvfrom 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for two different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv4.
+
+traffic_ping_pong_small_sendto_and_recvfrom_udp4(suite) ->
+    [];
+traffic_ping_pong_small_sendto_and_recvfrom_udp4(doc) ->
+    [];
+traffic_ping_pong_small_sendto_and_recvfrom_udp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendto_and_recvfrom_udp4,
+           fun() ->
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendto_and_recvfrom_udp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendto and recvfrom 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for two different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv6.
+
+traffic_ping_pong_small_sendto_and_recvfrom_udp6(suite) ->
+    [];
+traffic_ping_pong_small_sendto_and_recvfrom_udp6(doc) ->
+    [];
+traffic_ping_pong_small_sendto_and_recvfrom_udp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendto_and_recvfrom_udp6,
+           fun() ->
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendto_and_recvfrom_udp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendto and recvfrom 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for two different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv4.
+
+traffic_ping_pong_medium_sendto_and_recvfrom_udp4(suite) ->
+    [];
+traffic_ping_pong_medium_sendto_and_recvfrom_udp4(doc) ->
+    [];
+traffic_ping_pong_medium_sendto_and_recvfrom_udp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendto_and_recvfrom_udp4,
+           fun() ->
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendto_and_recvfrom_udp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendto and recvfrom 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for two different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv6.
+
+traffic_ping_pong_medium_sendto_and_recvfrom_udp6(suite) ->
+    [];
+traffic_ping_pong_medium_sendto_and_recvfrom_udp6(doc) ->
+    [];
+traffic_ping_pong_medium_sendto_and_recvfrom_udp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendto_and_recvfrom_udp6,
+           fun() ->
+                   ?TT(?SECS(45)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendto_and_recvfrom_udp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv4.
+
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4(suite) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4(doc) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendmsg_and_recvmsg_tcp4,
+           fun() ->
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv6.
+
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6(suite) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6(doc) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendmsg_and_recvmsg_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv4.
+
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4(suite) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4(doc) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp4,
+           fun() ->
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv6.
+
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6(suite) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6(doc) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendmsg_and_recvmsg_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => ine6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'large' message test case, for IPv4.
+
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4(suite) ->
+    [];
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4(doc) ->
+    [];
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_LARGE),
+    Num = ?TPP_LARGE_NUM,
+    tc_try(traffic_ping_pong_large_sendmsg_and_recvmsg_tcp4,
+           fun() ->
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes), medium (8K) and large (8M).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'large' message test case, for IPv6.
+
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6(suite) ->
+    [];
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6(doc) ->
+    [];
+traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_LARGE),
+    Num = ?TPP_LARGE_NUM,
+    tc_try(traffic_ping_pong_large_sendmsg_and_recvmsg_tcp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv4.
+
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp4(suite) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp4(doc) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendmsg_and_recvmsg_udp4,
+           fun() ->
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_udp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg functions
+%% by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'small' message test case, for IPv6.
+
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp6(suite) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp6(doc) ->
+    [];
+traffic_ping_pong_small_sendmsg_and_recvmsg_udp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_SMALL),
+    Num = ?TPP_SMALL_NUM,
+    tc_try(traffic_ping_pong_small_sendmsg_and_recvmsg_udp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_udp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv4.
+
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4(suite) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4(doc) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendmsg_and_recvmsg_udp4,
+           fun() ->
+                   ?TT(?SECS(30)),
+                   InitState = #{domain => inet,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_udp(InitState)
+           end).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This test case is intended to test that the sendmsg and recvmsg 
+%% functions by repeatedly sending a meassage between two entities.
+%% The same basic test case is used for three different message sizes; 
+%% small (8 bytes) and medium (8K).
+%% The message is sent from A to B and then back again. This is 
+%% repeated a set number of times (more times the small the message).
+%% This is the 'medium' message test case, for IPv6.
+
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6(suite) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6(doc) ->
+    [];
+traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6(_Config) when is_list(_Config) ->
+    Msg = l2b(?TPP_MEDIUM),
+    Num = ?TPP_MEDIUM_NUM,
+    tc_try(traffic_ping_pong_medium_sendmsg_and_recvmsg_udp6,
+           fun() ->
+                   not_yet_implemented(),
+                   ?TT(?SECS(20)),
+                   InitState = #{domain => ine6,
+                                 msg    => Msg,
+                                 num    => Num},
+                   ok = traffic_ping_pong_sendmsg_and_recvmsg_udp(InitState)
+           end).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% Ping-Pong for TCP
+
+traffic_ping_pong_send_and_recv_tcp(InitState) ->
+    Send = fun(Sock, Data) -> socket:send(Sock, Data) end,
+    Recv = fun(Sock, Sz)   -> socket:recv(Sock, Sz) end,
+    InitState2 = InitState#{send => Send, % Send function
+                            recv => Recv  % Receive function
+                           },
+    traffic_ping_pong_send_and_receive_tcp(InitState2).
+
+traffic_ping_pong_sendmsg_and_recvmsg_tcp(InitState) ->
+    Send = fun(Sock, Data) when is_binary(Data) ->
+                   MsgHdr = #{iov => [Data]},
+                   socket:sendmsg(Sock, MsgHdr);
+              (Sock, Data) when is_list(Data) -> %% We assume iovec...
+                   MsgHdr = #{iov => Data},
+                   socket:sendmsg(Sock, MsgHdr)
+           end,
+    Recv = fun(Sock, Sz)   -> 
+                   case socket:recvmsg(Sock, Sz, 0) of
+                       {ok, #{addr  := undefined,
+                              iov   := [Data]}} ->
+                           {ok, Data};
+                       {error, _} = ERROR ->
+                           ERROR
+                   end
+           end,
+    InitState2 = InitState#{send => Send, % Send function
+                            recv => Recv  % Receive function
+                           },
+    traffic_ping_pong_send_and_receive_tcp(InitState2).
+
+
+traffic_ping_pong_send_and_receive_tcp(#{msg := Msg} = InitState) ->
+    Fun = fun(Sock) -> 
+                  {ok, RcvSz} = socket:getopt(Sock, socket, rcvbuf),
+                  if (RcvSz < size(Msg)) ->
+                          ok = socket:setopt(Sock, socket, rcvbuf, 1024+size(Msg));
+                     true ->
+                          ok
+                  end,
+                  {ok, SndSz} = socket:getopt(Sock, socket, sndbuf),
+                  if (SndSz < size(Msg)) ->
+                          ok = socket:setopt(Sock, socket, sndbuf, 1024+size(Msg));
+                     true ->
+                          ok
+                  end,
+                  ok = socket:setopt(Sock, otp, rcvbuf, 8*1024)
+          end,
+    traffic_ping_pong_send_and_receive_tcp2(InitState#{buf_init => Fun}).
+
+traffic_ping_pong_send_and_receive_tcp2(InitState) ->
+    ServerSeq =
+        [
+         %% *** Wait for start order part ***
+         #{desc => "await start",
+           cmd  => fun(State) ->
+                           Tester = ?SEV_AWAIT_START(),
+                           {ok, State#{tester => Tester}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+
+         %% *** Init part ***
+         #{desc => "which local address",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           LAddr = which_local_addr(Domain),
+                           LSA   = #{family => Domain, addr => LAddr},
+                           {ok, State#{local_sa => 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, local_sa := LSA} = State) ->
+                           case socket:bind(LSock, LSA) of
+                               {ok, Port} ->
+                                   {ok, State#{lport => Port}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "maybe init buffers",
+           cmd  => fun(#{lsock := LSock, buf_init := BufInit} = _State) ->
+                           BufInit(LSock)
+                   end},
+         #{desc => "make listen socket",
+           cmd  => fun(#{lsock := LSock}) ->
+                           socket:listen(LSock)
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester, local_sa := LSA, lport := Port}) ->
+                           ServerSA = LSA#{port => Port},
+                           ?SEV_ANNOUNCE_READY(Tester, init, ServerSA),
+                           ok
+                   end},
+
+         %% The actual test
+         #{desc => "await continue (accept)",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
+                   end},
+         #{desc => "accept",
+           cmd  => fun(#{lsock := LSock} = State) ->
+                           case socket:accept(LSock) of
+                               {ok, Sock} ->
+                                   {ok, State#{csock => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "create handler",
+           cmd  => fun(State) ->
+                           Handler = tpp_tcp_handler_create(),
+                           ?SEV_IPRINT("handler created: ~p", [Handler]),
+                           {ok, State#{handler => Handler}}
+                   end},
+         #{desc => "monitor handler",
+           cmd  => fun(#{handler := Handler} = _State) ->
+                           _MRef = erlang:monitor(process, Handler),
+                           ok
+                   end},
+         #{desc => "transfer connection socket ownership to handler",
+           cmd  => fun(#{handler := Handler, csock := Sock} = _State) ->
+                           socket:setopt(Sock, otp, controlling_process, Handler)
+                   end},
+         #{desc => "start handler",
+           cmd  => fun(#{handler  := Handler,
+                         csock    := Sock,
+                         send     := Send,
+                         recv     := Recv} = _State) ->
+                           ?SEV_ANNOUNCE_START(Handler, {Sock, Send, Recv}),
+                           ok
+                   end},
+         #{desc => "await handler ready (init)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_READY(Handler, handler, init, 
+                                                 [{tester, Tester}]) of
+                               ok ->
+                                   {ok, maps:remove(csock, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (accept)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, accept),
+                           ok
+                   end},
+         #{desc => "await continue (recv)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, recv, 
+                                               [{handler, Handler}])
+                   end},
+         #{desc => "order handler to recv",
+           cmd  => fun(#{handler := Handler} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Handler, recv),
+                           ok
+                   end},
+         #{desc => "await handler ready (recv)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_READY(Handler, handler, recv, 
+                                                 [{tester, Tester}]) of
+                               {ok, Result} ->
+                                   %% ?SEV_IPRINT("Result: ~p", [Result]),
+                                   {ok, State#{result => Result}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (recv)",
+           cmd  => fun(#{tester := Tester, 
+                         result := Result} = State) ->
+                           ?SEV_ANNOUNCE_READY(Tester, recv, Result),
+                           {ok, maps:remove(result, State)}
+                   end},
+
+         %% Termination
+         #{desc => "await terminate (from tester)",
+           cmd  => fun(#{tester := Tester} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester) of
+                               ok ->
+                                   {ok, maps:remove(tester, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "stop handler",
+           cmd  => fun(#{handler := Handler}) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Handler),
+                           ok
+                   end},
+         #{desc => "await handler termination",
+           cmd  => fun(#{handler := Handler} = State) ->
+                           ?SEV_AWAIT_TERMINATION(Handler),
+                           State1 = maps:remove(handler, State),
+                           {ok, State1}
+                   end},
+         #{desc => "close listen socket",
+           cmd  => fun(#{lsock := Sock} = State) ->
+                           (catch socket:close(Sock)),
+                            {ok, maps:remove(lsock, State)}
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    ClientSeq =
+        [
+         %% *** Wait for start order part ***
+         #{desc => "await start",
+           cmd  => fun(State) ->
+                           {Tester, ServerSA} = ?SEV_AWAIT_START(),
+                           {ok, State#{tester    => Tester, 
+                                       server_sa => ServerSA}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+
+         %% *** Init part ***
+         #{desc => "create node",
+           cmd  => fun(#{host := Host} = State) ->
+                           case start_node(Host, client) of
+                               {ok, Node} ->
+                                   ?SEV_IPRINT("(remote) client node ~p started", 
+                                               [Node]),
+                                   {ok, State#{node => Node}};
+                               {error, Reason, _} ->
+                                   {error, Reason}
+                           end
+                   end},
+         #{desc => "monitor client node",
+           cmd  => fun(#{node := Node} = _State) ->
+                           true = erlang:monitor_node(Node, true),
+                           ok
+                   end},
+         #{desc => "create remote client",
+           cmd  => fun(#{node := Node} = State) ->
+                           Pid = tpp_tcp_client_create(Node),
+                           ?SEV_IPRINT("remote client created: ~p", [Pid]),
+                           {ok, State#{rclient => Pid}}
+                   end},
+         #{desc => "monitor remote client",
+           cmd  => fun(#{rclient := Pid}) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "order remote client to start",
+           cmd  => fun(#{rclient   := RClient,
+                         server_sa := ServerSA,
+                         buf_init  := BufInit,
+                         send      := Send,
+                         recv      := Recv}) ->
+                           ?SEV_ANNOUNCE_START(RClient, 
+                                               {ServerSA, BufInit, Send, Recv}),
+                           ok
+                   end},
+         #{desc => "await remote client ready",
+           cmd  => fun(#{tester  := Tester,
+                         rclient := RClient} = _State) ->
+                           ?SEV_AWAIT_READY(RClient, rclient, init, 
+                                            [{tester, Tester}])
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, init),
+                           ok
+                   end},
+
+         %% The actual test
+         #{desc => "await continue (connect)",
+           cmd  => fun(#{tester  := Tester,
+                         rclient := RClient} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, connect, 
+                                               [{rclient, RClient}]),
+                           ok
+                   end},
+         #{desc => "order remote client to continue (connect)",
+           cmd  => fun(#{rclient := RClient}) ->
+                           ?SEV_ANNOUNCE_CONTINUE(RClient, connect),
+                           ok
+                   end},
+         #{desc => "await remote client ready (connect)",
+           cmd  => fun(#{tester  := Tester,
+                         rclient := RClient} = _State) ->
+                           ?SEV_AWAIT_READY(RClient, rclient, connect, 
+                                            [{tester, Tester}])
+                   end},
+         #{desc => "announce ready (connect)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, connect),
+                           ok
+                   end},
+         #{desc => "await continue (send)",
+           cmd  => fun(#{tester  := Tester,
+                         rclient := RClient} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, 
+                                               send, 
+                                               [{rclient, RClient}])
+                   end},
+         #{desc => "order remote client to continue (send)",
+           cmd  => fun(#{rclient := RClient,
+                         msg     := Msg,
+                         num     := Num} = State) ->
+                           Data = {Msg, Num},
+                           ?SEV_ANNOUNCE_CONTINUE(RClient, send, Data),
+                           {ok, maps:remove(data, State)}
+                   end},
+         #{desc => "await remote client ready (send)",
+           cmd  => fun(#{tester  := Tester,
+                         rclient := RClient} = State) ->
+                           case ?SEV_AWAIT_READY(RClient, rclient, send, 
+                                                 [{tester, Tester}]) of
+                               {ok, Result} ->
+                                   %% ?SEV_IPRINT("remote client result: "
+                                   %%             "~n   ~p", [Result]),
+                                   {ok, State#{result => Result}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (send)",
+           cmd  => fun(#{tester := Tester, result := Result} = State) ->
+                           ?SEV_ANNOUNCE_READY(Tester, send, Result),
+                           {ok, maps:remove(result, State)}
+                   end},
+
+         %% Termination
+         #{desc => "await terminate (from tester)",
+           cmd  => fun(#{tester  := Tester, 
+                         rclient := RClient} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester,
+                                                     [{rclient, RClient}]) of
+                               ok ->
+                                   {ok, maps:remove(tester, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "stop remote client",
+           cmd  => fun(#{rclient := RClient}) ->
+                           ?SEV_ANNOUNCE_TERMINATE(RClient),
+                           ok
+                   end},
+         #{desc => "await remote client termination",
+           cmd  => fun(#{rclient := RClient} = State) ->
+                           ?SEV_AWAIT_TERMINATION(RClient),
+                           State1 = maps:remove(rclient, State),
+                           {ok, State1}
+                   end},
+         #{desc => "stop client node",
+           cmd  => fun(#{node := Node} = _State) ->
+                           stop_node(Node)
+                   end},
+         #{desc => "await client node termination",
+           cmd  => fun(#{node := Node} = State) ->
+                           receive
+                               {nodedown, Node} ->
+                                   {ok, maps:remove(node, State)}
+                           end
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    TesterSeq =
+        [
+         %% *** Init part ***
+         #{desc => "monitor server",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "monitor client",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+
+         %% Start the server
+         #{desc => "order server start",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid),
+                           ok
+                   end},
+         #{desc => "await server ready (init)",
+           cmd  => fun(#{server := Pid} = State) ->
+                           {ok, ServerSA} = ?SEV_AWAIT_READY(Pid, server, init),
+                           {ok, State#{server_sa => ServerSA}}
+                   end},
+
+         %% Start the client
+         #{desc => "order client start",
+           cmd  => fun(#{client    := Pid, 
+                         server_sa := ServerSA} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid, ServerSA),
+                           ok
+                   end},
+         #{desc => "await client ready (init)",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, client, init)
+                   end},
+ 
+         %% The actual test
+         #{desc => "order server continue (accept)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
+                           ok
+                   end},
+         ?SEV_SLEEP(?SECS(1)),
+         #{desc => "order client continue (connect)",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, connect),
+                           ok
+                   end},
+         #{desc => "await server ready (accept)",
+           cmd  => fun(#{server := Server,
+                         client := Client} = _State) ->
+                           ?SEV_AWAIT_READY(Server, server, accept,
+                                            [{client, Client}]),
+                           ok
+                   end},
+         #{desc => "await client ready (connect)",
+           cmd  => fun(#{server := Server,
+                         client := Client} = _State) ->
+                           ?SEV_AWAIT_READY(Client, client, connect, 
+                                            [{server, Server}])
+                   end},
+         #{desc => "order server continue (recv)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
+                           ok
+                   end},
+         ?SEV_SLEEP(?SECS(1)),
+         #{desc => "order client continue (send)",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, send),
+                           ok
+                   end},
+         #{desc => "await client ready (send)",
+           cmd  => fun(#{server := Server,
+                         client := Client} = State) ->
+                           case ?SEV_AWAIT_READY(Client, client, send, 
+                                                 [{server, Server}]) of
+                               {ok, {_, _, _, _} = Result} ->
+                                   ?SEV_IPRINT("client result: "
+                                               "~n   ~p", [Result]),
+                                   {ok, State#{client_result => Result}};
+                               {ok, BadResult} ->
+                                   ?SEV_EPRINT("client result: "
+                                               "~n   ~p", [BadResult]),
+                                   {error, {invalid_client_result, BadResult}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "await server ready (recv)",
+           cmd  => fun(#{server := Server,
+                         client := Client,
+                         num    := Num} = State) ->
+                           case ?SEV_AWAIT_READY(Server, server, recv,
+                                                 [{client, Client}]) of
+                               {ok, {Num, _, _, _, _} = Result} ->
+                                   ?SEV_IPRINT("server result: "
+                                               "~n   ~p", [Result]),
+                                   Result2 = erlang:delete_element(1, Result),
+                                   {ok, State#{server_result => Result2}};
+                               {ok, BadResult} ->
+                                   ?SEV_EPRINT("bad sever result: "
+                                               "~n   ~p", [BadResult]),
+                                   {error, {invalid_server_result, BadResult}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "present result",
+           cmd  => fun(#{server_result := SRes,
+                         client_result := CRes,
+                         num           := Num} = State) ->
+                           {SSent, SReceived, SStart, SStop} = SRes,
+                           {CSent, CReceived, CStart, CStop} = CRes,
+                           STime = tdiff(SStart, SStop),
+                           CTime = tdiff(CStart, CStop),
+                           %% Note that the sizes we are counting is only 
+                           %% the "data" part of the messages. There is also
+                           %% fixed header for each message, which of cource
+                           %% is small for the large messages, but comparatively
+                           %% big for the small messages!
+                           ?SEV_IPRINT("Results: ~w messages exchanged"
+                                       "~n   Server: ~w msec"
+                                       "~n      ~.2f msec/message (roundtrip)"
+                                       "~n      ~.2f messages/msec (roundtrip)"
+                                       "~n      ~w bytes/msec sent"
+                                       "~n      ~w bytes/msec received"
+                                       "~n   Client: ~w msec"
+                                       "~n      ~.2f msec/message (roundtrip)"
+                                       "~n      ~.2f messages/msec (roundtrip)"
+                                       "~n      ~w bytes/msec sent"
+                                       "~n      ~w bytes/msec received",
+                                       [Num,
+                                        STime,
+                                        STime / Num,
+                                        Num / STime,
+                                        SSent div STime,
+                                        SReceived div STime,
+                                        CTime,
+                                        CTime / Num,
+                                        Num / CTime,
+                                        CSent div CTime,
+                                        CReceived div CTime]),
+                           State1 = maps:remove(server_result, State),
+                           State2 = maps:remove(client_result, State1),
+                           {ok, State2}
+                   end},
+
+         %% Terminations
+         #{desc => "order client to terminate",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await client termination",
+           cmd  => fun(#{client := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(client, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "order server to terminate",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await server termination",
+           cmd  => fun(#{server := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(server, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    i("start server evaluator"),
+    ServerInitState = #{domain   => maps:get(domain,   InitState),
+                        recv     => maps:get(recv,     InitState),
+                        send     => maps:get(send,     InitState),
+                        buf_init => maps:get(buf_init, InitState)},
+    Server = ?SEV_START("server", ServerSeq, ServerInitState),
+
+    i("start client evaluator(s)"),
+    ClientInitState = InitState#{host => local_host()},
+    Client = ?SEV_START("client", ClientSeq, ClientInitState),
+
+    i("start 'tester' evaluator"),
+    TesterInitState = #{server => Server#ev.pid,
+                        client => Client#ev.pid,
+                        num    => maps:get(num, InitState)},
+    Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
+
+    i("await evaluator"),
+    ok = ?SEV_AWAIT_FINISH([Server, Client, Tester]).
+    
+
+tpp_tcp_handler_create() ->
+    Self = self(),
+    erlang:spawn(fun() -> tpp_tcp_handler(Self) end).
+
+tpp_tcp_handler(Parent) ->
+    tpp_tcp_handler_init(Parent),
+    {Sock, Send, Recv} = tpp_tcp_handler_await_start(Parent),
+    tpp_tcp_handler_announce_ready(Parent, init),
+    tpp_tcp_handler_await_continue(Parent, recv),
+    Result = tpp_tcp_handler_msg_exchange(Sock, Send, Recv),
+    tpp_tcp_handler_announce_ready(Parent, recv, Result),
+    Reason = tpp_tcp_handler_await_terminate(Parent),
+    ?SEV_IPRINT("terminating"),
+    exit(Reason).
+
+tpp_tcp_handler_init(Parent) ->
+    put(sname, "handler"),
+    ?SEV_IPRINT("init"),
+    _MRef = erlang:monitor(process, Parent),
+    ok.
+
+tpp_tcp_handler_await_start(Parent) ->
+    ?SEV_IPRINT("await start"),
+    ?SEV_AWAIT_START(Parent).
+
+tpp_tcp_handler_announce_ready(Parent, Slogan) ->
+    ?SEV_IPRINT("announce ready (~p)", [Slogan]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan).
+tpp_tcp_handler_announce_ready(Parent, Slogan, Extra) ->
+    ?SEV_IPRINT("announce ready (~p)", [Slogan]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan, Extra).
+
+tpp_tcp_handler_await_continue(Parent, Slogan) ->
+    ?SEV_IPRINT("await continue (~p)", [Slogan]),
+    case ?SEV_AWAIT_CONTINUE(Parent, parent, Slogan) of
+        ok ->
+            %% ?SEV_IPRINT("continue (~p): ok", [Slogan]),
+            ok;
+        {error, Reason} ->
+            ?SEV_EPRINT("continue (~p): error"
+                        "~n   ~p", [Slogan, Reason]),
+            exit({continue, Slogan, Reason})
+    end.
+
+tpp_tcp_handler_await_terminate(Parent) ->
+    ?SEV_IPRINT("await terminate"),
+    case ?SEV_AWAIT_TERMINATE(Parent, parent) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            Reason
+    end.
+
+tpp_tcp_handler_msg_exchange(Sock, Send, Recv) ->
+    tpp_tcp_handler_msg_exchange_loop(Sock, Send, Recv, 0, 0, 0, undefined).
+
+tpp_tcp_handler_msg_exchange_loop(Sock, Send, Recv, N, Sent, Received, Start) ->
+    %% ?SEV_IPRINT("[~w] try receive", [N]),
+    case tpp_tcp_recv_req(Sock, Recv) of
+        {ok, Msg, RecvSz} ->
+            NewStart = if (Start =:= undefined) -> ?LIB:timestamp(); 
+                          true -> Start end,
+            %% ?SEV_IPRINT("[~w] received - now try send", [N]),
+            case tpp_tcp_send_rep(Sock, Send, Msg) of
+                {ok, SendSz} ->
+                    tpp_tcp_handler_msg_exchange_loop(Sock, Send, Recv,
+                                                      N+1,
+                                                      Sent+SendSz,
+                                                      Received+RecvSz,
+                                                      NewStart);
+                {error, SReason} ->
+                    ?SEV_EPRINT("send (~w): ~p", [N, SReason]),
+                    exit({send, SReason, N})
+            end;
+        %% {error, timeout} ->
+        %%     ?SEV_IPRINT("timeout(~w) - try again", [N]),
+        %%     case Send(Sock, list_to_binary("ping")) of
+        %%         ok ->
+        %%             exit({'ping-send', ok, N});
+        %%         {error, Reason} ->
+        %%             exit({'ping-send', Reason, N})
+        %%     end;
+        {error, closed} ->
+            ?SEV_IPRINT("closed - we are done: ~w, ~w, ~w", [N, Sent, Received]),
+            Stop = ?LIB:timestamp(),
+            {N, Sent, Received, Start, Stop};
+        {error, RReason} ->
+            ?SEV_EPRINT("recv (~w): ~p", [N, RReason]),
+            exit({recv, RReason, N})
+    end.
+            
+%% The (remote) client process
+
+tpp_tcp_client_create(Node) ->
+    Self = self(),
+    GL   = group_leader(),
+    Fun  = fun() -> tpp_tcp_client(Self, GL) end,
+    erlang:spawn(Node, Fun).
+
+tpp_tcp_client(Parent, GL) ->
+    tpp_tcp_client_init(Parent, GL),
+    {ServerSA, BufInit, Send, Recv} = tpp_tcp_client_await_start(Parent),
+    Domain   = maps:get(family, ServerSA),
+    Sock     = tpp_tcp_client_sock_open(Domain, BufInit),
+    tpp_tcp_client_sock_bind(Sock, Domain),
+    tpp_tcp_client_announce_ready(Parent, init),
+    tpp_tcp_client_await_continue(Parent, connect),
+    tpp_tcp_client_sock_connect(Sock, ServerSA),
+    tpp_tcp_client_announce_ready(Parent, connect),
+    {InitMsg, Num} = tpp_tcp_client_await_continue(Parent, send),
+    Result = tpp_tcp_client_msg_exchange(Sock, Send, Recv, InitMsg, Num),
+    tpp_tcp_client_announce_ready(Parent, send, Result),
+    Reason = tpp_tcp_client_await_terminate(Parent),
+    tpp_tcp_client_sock_close(Sock),
+    ?SEV_IPRINT("terminating"),
+    exit(Reason).
+
+tpp_tcp_client_init(Parent, GL) ->
+    put(sname, "rclient"),
+    ?SEV_IPRINT("init"),
+    _MRef = erlang:monitor(process, Parent),
+    group_leader(self(), GL),
+    ok.
+
+tpp_tcp_client_await_start(Parent) ->
+    ?SEV_IPRINT("await start"),
+    ?SEV_AWAIT_START(Parent).
+
+tpp_tcp_client_announce_ready(Parent, Slogan) ->
+    ?SEV_IPRINT("announce ready (~p)", [Slogan]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan).
+tpp_tcp_client_announce_ready(Parent, Slogan, Extra) ->
+    ?SEV_IPRINT("announce ready (~p): ~p", [Slogan, Extra]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan, Extra).
+
+tpp_tcp_client_await_continue(Parent, Slogan) ->
+    ?SEV_IPRINT("await continue (~p)", [Slogan]),
+    case ?SEV_AWAIT_CONTINUE(Parent, parent, Slogan) of
+        ok ->
+            %% ?SEV_IPRINT("continue (~p): ok", [Slogan]),
+            ok;
+        {ok, Data} ->
+            %% ?SEV_IPRINT("continue (~p): ok with data", [Slogan]),
+            Data;
+        {error, Reason} ->
+            ?SEV_EPRINT("continue (~p): error"
+                        "~n   ~p", [Slogan, Reason]),
+            exit({continue, Slogan, Reason})
+    end.
+
+tpp_tcp_client_await_terminate(Parent) ->
+    ?SEV_IPRINT("await terminate"),
+    case ?SEV_AWAIT_TERMINATE(Parent, parent) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            Reason
+    end.
+
+tpp_tcp_client_msg_exchange(Sock, Send, Recv, InitMsg, Num) ->
+    Start = ?LIB:timestamp(),
+    tpp_tcp_client_msg_exchange_loop(Sock, Send, Recv, InitMsg, 
+                                     Num, 0, 0, 0, Start).
+
+tpp_tcp_client_msg_exchange_loop(Sock, _Send, _Recv, _Msg,
+                                 Num, Num, Sent, Received,
+                                 Start) ->
+    Stop = ?LIB:timestamp(),
+    case socket:close(Sock) of
+        ok ->
+            {Sent, Received, Start, Stop};
+        {error, Reason} ->
+            exit({failed_closing, Reason})
+    end;
+tpp_tcp_client_msg_exchange_loop(Sock, Send, Recv, Data, 
+                                 Num, N, Sent, Received, Start) ->
+    %% d("tpp_tcp_client_msg_exchange_loop(~w,~w) try send", [Num,N]),
+    case tpp_tcp_send_req(Sock, Send, Data) of
+        {ok, SendSz} ->
+            %% d("tpp_tcp_client_msg_exchange_loop(~w,~w) sent - "
+            %%   "now try recv", [Num,N]),
+            case tpp_tcp_recv_rep(Sock, Recv) of
+                {ok, NewData, RecvSz} ->
+                    tpp_tcp_client_msg_exchange_loop(Sock, Send, Recv,
+                                                     NewData, Num, N+1,
+                                                     Sent+SendSz, 
+                                                     Received+RecvSz, 
+                                                     Start);
+                {error, RReason} ->
+                    ?SEV_EPRINT("recv (~w of ~w): ~p", [N, Num, RReason]),
+                    exit({recv, RReason, N})
+            end;
+        {error, SReason} ->
+            ?SEV_EPRINT("send (~w of ~w): ~p", [N, Num, SReason]),
+            exit({send, SReason, N})
+    end.
+
+tpp_tcp_client_sock_open(Domain, BufInit) ->
+    case socket:open(Domain, stream, tcp) of
+        {ok, Sock} ->
+            ok = BufInit(Sock),
+            Sock;
+        {error, Reason} ->
+            exit({open_failed, Reason})
+    end.
+
+tpp_tcp_client_sock_bind(Sock, Domain) ->
+    LAddr = which_local_addr(Domain),
+    LSA   = #{family => Domain, 
+              addr   => LAddr},
+    case socket:bind(Sock, LSA) of
+        {ok, _} ->
+            ok;
+        {error, Reason} ->
+            exit({bind, Reason})
+    end.
+
+tpp_tcp_client_sock_connect(Sock, ServerSA) ->
+    case socket:connect(Sock, ServerSA) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            exit({connect, Reason})
+    end.
+
+tpp_tcp_client_sock_close(Sock) ->
+    case socket:close(Sock) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            exit({close, Reason})
+    end.
+
+-define(TPP_REQUEST, 1).
+-define(TPP_REPLY,   2).
+
+tpp_tcp_recv_req(Sock, Recv) ->
+    tpp_tcp_recv(Sock, Recv, ?TPP_REQUEST).
+
+tpp_tcp_recv_rep(Sock, Recv) ->
+    tpp_tcp_recv(Sock, Recv, ?TPP_REPLY).
+
+tpp_tcp_recv(Sock, Recv, Tag) ->
+    case Recv(Sock, 0) of
+        {ok, <<Tag:32/integer, Sz:32/integer, Data/binary>> = Msg} 
+          when (Sz =:= size(Data)) ->
+            %% We got it all
+            {ok, Data, size(Msg)};
+        {ok, <<Tag:32/integer, Sz:32/integer, Data/binary>> = Msg} ->
+            Remains = Sz - size(Data),
+            tpp_tcp_recv(Sock, Recv, Tag, Remains, size(Msg), [Data]);
+        {ok, <<Tag:32/integer, _/binary>>} ->
+            {error, {invalid_msg_tag, Tag}};
+        {error, _} = ERROR ->
+            ERROR
+    end.
+
+tpp_tcp_recv(Sock, Recv, Tag, Remaining, AccSz, Acc) ->
+    case Recv(Sock, Remaining) of
+        {ok, Data} when (Remaining =:= size(Data)) ->
+            %% We got the rest
+            TotSz = AccSz + size(Data),
+            {ok, erlang:iolist_to_binary(lists:reverse([Data | Acc])), TotSz};
+        {ok, Data} when (Remaining > size(Data)) ->
+            tpp_tcp_recv(Sock, Recv, Tag, 
+                         Remaining - size(Data), AccSz + size(Data),     
+                         [Data | Acc]);
+        {error, _} = ERROR ->
+            ERROR
+    end.
+                                                         
+            
+tpp_tcp_send_req(Sock, Send, Data) ->
+    tpp_tcp_send(Sock, Send, ?TPP_REQUEST, Data).
+
+tpp_tcp_send_rep(Sock, Send, Data) ->
+    tpp_tcp_send(Sock, Send, ?TPP_REPLY, Data).
+
+tpp_tcp_send(Sock, Send, Tag, Data) ->
+    DataSz = size(Data),
+    Msg    = <<Tag:32/integer, DataSz:32/integer, Data/binary>>,
+    tpp_tcp_send_msg(Sock, Send, Msg, 0).
+
+tpp_tcp_send_msg(Sock, Send, Msg, AccSz) when is_binary(Msg) ->
+    case Send(Sock, Msg) of
+        ok ->
+            {ok, AccSz+size(Msg)};
+        {ok, Rest} -> % This is an IOVec
+            RestBin = list_to_binary(Rest),
+            tpp_tcp_send_msg(Sock, Send, RestBin, AccSz+(size(Msg)-size(RestBin)));
+        {error, _} = ERROR ->
+            ERROR
+    end.
+    
+
+%% size_of_data(Data) when is_binary(Data) ->
+%%     size(Data);
+%% size_of_data(Data) when is_list(Data) ->
+%%     size_of_iovec(Data, 0).
+
+%% size_of_iovec([], Sz) ->
+%%     Sz;
+%% size_of_iovec([B|IOVec], Sz) ->
+%%     size_of_iovec(IOVec, Sz+size(B)).
+
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% Ping-Pong for UDP
+
+traffic_ping_pong_sendto_and_recvfrom_udp(InitState) ->
+    Send = fun(Sock, Data, Dest) ->
+                   socket:sendto(Sock, Data, Dest)
+           end,
+    Recv = fun(Sock, Sz)         ->
+                   socket:recvfrom(Sock, Sz)
+           end,
+    InitState2 = InitState#{send => Send, % Send function
+                            recv => Recv  % Receive function
+                           },
+    traffic_ping_pong_send_and_receive_udp(InitState2).
+
+traffic_ping_pong_sendmsg_and_recvmsg_udp(InitState) ->
+    Send = fun(Sock, Data, Dest) when is_binary(Data) ->
+                   MsgHdr = #{addr => Dest, iov => [Data]},
+                   socket:sendmsg(Sock, MsgHdr);
+              (Sock, Data, Dest) when is_list(Data) -> %% We assume iovec...
+                   MsgHdr = #{addr => Dest, iov => Data},
+                   socket:sendmsg(Sock, MsgHdr)
+           end,
+    Recv = fun(Sock, Sz)   -> 
+                   case socket:recvmsg(Sock, Sz, 0) of
+                       {ok, #{addr  := Source,
+                              iov   := [Data]}} ->
+                           {ok, {Source, Data}};
+                       {error, _} = ERROR ->
+                           ERROR
+                   end
+           end,
+    InitState2 = InitState#{send => Send, % Send function
+                            recv => Recv  % Receive function
+                           },
+    traffic_ping_pong_send_and_receive_udp(InitState2).
+
+
+traffic_ping_pong_send_and_receive_udp(#{msg := Msg} = InitState) ->
+    Fun = fun(Sock) -> 
+                  {ok, RcvSz} = socket:getopt(Sock, socket, rcvbuf),
+                  if (RcvSz < size(Msg)) ->
+                          ok = socket:setopt(Sock, socket, rcvbuf, 1024+size(Msg));
+                     true ->
+                          ok
+                  end,
+                  {ok, SndSz} = socket:getopt(Sock, socket, sndbuf),
+                  if (SndSz < size(Msg)) ->
+                          ok = socket:setopt(Sock, socket, sndbuf, 1024+size(Msg));
+                     true ->
+                          ok
+                  end,
+                  {ok, OtpRcvBuf} = socket:getopt(Sock, otp, rcvbuf),
+                  if
+                      (OtpRcvBuf < size(Msg)) ->
+                          ok = socket:setopt(Sock, otp, rcvbuf, 1024+size(Msg));
+                      true ->
+                          ok
+                  end
+          end,
+    traffic_ping_pong_send_and_receive_udp2(InitState#{buf_init => Fun}).
+
+traffic_ping_pong_send_and_receive_udp2(InitState) ->
+    ServerSeq =
+        [
+         %% *** Wait for start order part ***
+         #{desc => "await start",
+           cmd  => fun(State) ->
+                           Tester = ?SEV_AWAIT_START(),
+                           {ok, State#{tester => Tester}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+
+         %% *** Init part ***
+         #{desc => "which local address",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           LAddr = which_local_addr(Domain),
+                           LSA   = #{family => Domain, addr => LAddr},
+                           {ok, State#{local_sa => LSA}}
+                   end},
+         #{desc => "create listen socket",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case socket:open(Domain, dgram, udp) of
+                               {ok, Sock} ->
+                                   {ok, State#{sock => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "bind to local address",
+           cmd  => fun(#{sock := Sock, local_sa := LSA} = State) ->
+                           case socket:bind(Sock, LSA) of
+                               {ok, Port} ->
+                                   {ok, State#{port => Port}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "maybe init buffers",
+           cmd  => fun(#{sock := Sock, buf_init := BufInit} = _State) ->
+                           BufInit(Sock)
+                   end},
+         #{desc => "create handler",
+           cmd  => fun(State) ->
+                           Handler = tpp_udp_server_handler_create(),
+                           ?SEV_IPRINT("handler created: ~p", [Handler]),
+                           {ok, State#{handler => Handler}}
+                   end},
+         #{desc => "monitor handler",
+           cmd  => fun(#{handler := Handler} = _State) ->
+                           _MRef = erlang:monitor(process, Handler),
+                           ok
+                   end},
+         #{desc => "start handler",
+           cmd  => fun(#{handler := Handler,
+                         sock    := Sock,
+                         send    := Send,
+                         recv    := Recv} = _State) ->
+                           ?SEV_ANNOUNCE_START(Handler, {Sock, Send, Recv}),
+                           ok
+                   end},
+         #{desc => "await handler ready (init)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_READY(Handler, handler, init, 
+                                                 [{tester, Tester}]) of
+                               ok ->
+                                   {ok, maps:remove(csock, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester, local_sa := LSA, port := Port}) ->
+                           ServerSA = LSA#{port => Port},
+                           ?SEV_ANNOUNCE_READY(Tester, init, ServerSA),
+                           ok
+                   end},
+
+         %% The actual test
+         #{desc => "await continue (recv)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, recv, 
+                                               [{handler, Handler}])
+                   end},
+         #{desc => "order handler to recv",
+           cmd  => fun(#{handler := Handler} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Handler, recv),
+                           ok
+                   end},
+         #{desc => "await continue (close)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, close, 
+                                               [{handler, Handler}])
+                   end},
+
+         ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "close socket",
+           cmd  => fun(#{sock := Sock} = State) ->
+                           %% socket:setopt(Sock, otp, debug, true),
+                           case socket:close(Sock) of
+                               ok ->
+                                   {ok, maps:remove(sock, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (close)",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           ?SEV_ANNOUNCE_READY(Tester, close),
+                           ok
+                   end},
+         #{desc => "await handler ready (recv)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_READY(Handler, handler, recv, 
+                                                 [{tester, Tester}]) of
+                               {ok, Result} ->
+                                   %% ?SEV_IPRINT("Result: ~p", [Result]),
+                                   {ok, State#{result => Result}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (recv)",
+           cmd  => fun(#{tester := Tester, 
+                         result := Result} = State) ->
+                           ?SEV_ANNOUNCE_READY(Tester, recv, Result),
+                           {ok, maps:remove(result, State)}
+                   end},
+
+         %% Termination
+         #{desc => "await terminate (from tester)",
+           cmd  => fun(#{tester := Tester} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester) of
+                               ok ->
+                                   {ok, maps:remove(tester, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "stop handler",
+           cmd  => fun(#{handler := Handler}) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Handler),
+                           ok
+                   end},
+         #{desc => "await handler termination",
+           cmd  => fun(#{handler := Handler} = State) ->
+                           ?SEV_AWAIT_TERMINATION(Handler),
+                           State1 = maps:remove(handler, State),
+                           {ok, State1}
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    ClientSeq =
+        [
+         %% *** Wait for start order part ***
+         #{desc => "await start",
+           cmd  => fun(State) ->
+                           {Tester, ServerSA} = ?SEV_AWAIT_START(),
+                           {ok, State#{tester    => Tester, 
+                                       server_sa => ServerSA}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+
+         %% *** Init part ***
+         #{desc => "create node",
+           cmd  => fun(#{host := Host} = State) ->
+                           case start_node(Host, client) of
+                               {ok, Node} ->
+                                   ?SEV_IPRINT("(remote) client node ~p started", 
+                                               [Node]),
+                                   {ok, State#{node => Node}};
+                               {error, Reason, _} ->
+                                   {error, Reason}
+                           end
+                   end},
+         #{desc => "monitor client node",
+           cmd  => fun(#{node := Node} = _State) ->
+                           true = erlang:monitor_node(Node, true),
+                           ok
+                   end},
+         #{desc => "create (remote) handler",
+           cmd  => fun(#{node := Node} = State) ->
+                           Pid = tpp_udp_client_handler_create(Node),
+                           ?SEV_IPRINT("handler created: ~p", [Pid]),
+                           {ok, State#{handler => Pid}}
+                   end},
+         #{desc => "monitor remote handler",
+           cmd  => fun(#{handler := Pid}) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "order remote handler to start",
+           cmd  => fun(#{handler   := Handler,
+                         server_sa := ServerSA,
+                         buf_init  := BufInit,
+                         send      := Send,
+                         recv      := Recv}) ->
+                           ?SEV_ANNOUNCE_START(Handler, 
+                                               {ServerSA, BufInit, Send, Recv}),
+                           ok
+                   end},
+         #{desc => "await (remote) handler ready",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = _State) ->
+                           ?SEV_AWAIT_READY(Handler, handler, init, 
+                                            [{tester, Tester}])
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, init),
+                           ok
+                   end},
+
+         %% The actual test
+         #{desc => "await continue (send)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, 
+                                               send, 
+                                               [{handler, Handler}])
+                   end},
+         #{desc => "order handler to continue (send)",
+           cmd  => fun(#{handler := Handler,
+                         msg     := Msg,
+                         num     := Num} = State) ->
+                           Data = {Msg, Num},
+                           ?SEV_ANNOUNCE_CONTINUE(Handler, send, Data),
+                           {ok, maps:remove(data, State)}
+                   end},
+         #{desc => "await remote handler ready (send)",
+           cmd  => fun(#{tester  := Tester,
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_READY(Handler, handler, send, 
+                                                 [{tester, Tester}]) of
+                               {ok, Result} ->
+                                   %% ?SEV_IPRINT("remote client result: "
+                                   %%             "~n   ~p", [Result]),
+                                   {ok, State#{result => Result}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (send)",
+           cmd  => fun(#{tester := Tester, result := Result} = State) ->
+                           ?SEV_ANNOUNCE_READY(Tester, send, Result),
+                           {ok, maps:remove(result, State)}
+                   end},
+
+         %% Termination
+         #{desc => "await terminate (from tester)",
+           cmd  => fun(#{tester  := Tester, 
+                         handler := Handler} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester,
+                                                     [{handler, Handler}]) of
+                               ok ->
+                                   {ok, maps:remove(tester, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "stop (remote) handler",
+           cmd  => fun(#{handler := Handler}) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Handler),
+                           ok
+                   end},
+         #{desc => "await (remote) handler termination",
+           cmd  => fun(#{handler := Handler} = State) ->
+                           ?SEV_AWAIT_TERMINATION(Handler),
+                           State1 = maps:remove(handler, State),
+                           {ok, State1}
+                   end},
+         #{desc => "stop client node",
+           cmd  => fun(#{node := Node} = _State) ->
+                           stop_node(Node)
+                   end},
+         #{desc => "await client node termination",
+           cmd  => fun(#{node := Node} = State) ->
+                           receive
+                               {nodedown, Node} ->
+                                   {ok, maps:remove(node, State)}
+                           end
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    TesterSeq =
+        [
+         %% *** Init part ***
+         #{desc => "monitor server",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "monitor client",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+
+         %% Start the server
+         #{desc => "order server start",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid),
+                           ok
+                   end},
+         #{desc => "await server ready (init)",
+           cmd  => fun(#{server := Pid} = State) ->
+                           {ok, ServerSA} = ?SEV_AWAIT_READY(Pid, server, init),
+                           {ok, State#{server_sa => ServerSA}}
+                   end},
+
+         %% Start the client
+         #{desc => "order client start",
+           cmd  => fun(#{client    := Pid, 
+                         server_sa := ServerSA} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid, ServerSA),
+                           ok
+                   end},
+         #{desc => "await client ready (init)",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, client, init)
+                   end},
+ 
+         %% The actual test
+         #{desc => "order server continue (recv)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, recv),
+                           ok
+                   end},
+         ?SEV_SLEEP(?SECS(1)),
+         #{desc => "order client continue (send)",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, send),
+                           ok
+                   end},
+         #{desc => "await client ready (send)",
+           cmd  => fun(#{server := Server,
+                         client := Client} = State) ->
+                           case ?SEV_AWAIT_READY(Client, client, send, 
+                                                 [{server, Server}]) of
+                               {ok, {_, _, _, _} = Result} ->
+                                   ?SEV_IPRINT("client result: "
+                                               "~n   ~p", [Result]),
+                                   {ok, State#{client_result => Result}};
+                               {ok, BadResult} ->
+                                   ?SEV_EPRINT("client result: "
+                                               "~n   ~p", [BadResult]),
+                                   {error, {invalid_client_result, BadResult}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "order server continue (close)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, close),
+                           ok
+                   end},
+         #{desc => "await server ready (close)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, server, close)
+                   end},
+         %% Because of the way we control the server, there is no real 
+         %% point in collecting statistics from it (the time will include
+         %% our communication with it).
+         #{desc => "await server ready (recv)",
+           cmd  => fun(#{server := Server,
+                         client := Client} = _State) ->
+                           case ?SEV_AWAIT_READY(Server, server, recv,
+                                                 [{client, Client}]) of
+                               {ok, _Result} ->
+                                   ok;
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "present result",
+           cmd  => fun(#{client_result := CRes,
+                         num           := Num} = State) ->
+                           {CSent, CReceived, CStart, CStop} = CRes,
+                           CTime = tdiff(CStart, CStop),
+                           %% Note that the sizes we are counting is only 
+                           %% the "data" part of the messages. There is also
+                           %% fixed header for each message, which of cource
+                           %% is small for the large messages, but comparatively
+                           %% big for the small messages!
+                           ?SEV_IPRINT("Results: ~w messages exchanged"
+                                       "~n   Client: ~w msec"
+                                       "~n      ~.2f msec/message (roundtrip)"
+                                       "~n      ~.2f messages/msec (roundtrip)"
+                                       "~n      ~w bytes/msec sent"
+                                       "~n      ~w bytes/msec received",
+                                       [Num,
+                                        CTime,
+                                        CTime / Num,
+                                        Num / CTime,
+                                        CSent div CTime,
+                                        CReceived div CTime]),
+                           State1 = maps:remove(client_result, State),
+                           {ok, State1}
+                   end},
+
+         %% Terminations
+         #{desc => "order client to terminate",
+           cmd  => fun(#{client := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await client termination",
+           cmd  => fun(#{client := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(client, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "order server to terminate",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await server termination",
+           cmd  => fun(#{server := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(server, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    i("start server evaluator"),
+    ServerInitState = #{domain   => maps:get(domain,   InitState),
+                        recv     => maps:get(recv,     InitState),
+                        send     => maps:get(send,     InitState),
+                        buf_init => maps:get(buf_init, InitState)},
+    Server = ?SEV_START("server", ServerSeq, ServerInitState),
+
+    i("start client evaluator(s)"),
+    ClientInitState = InitState#{host => local_host()},
+    Client = ?SEV_START("client", ClientSeq, ClientInitState),
+
+    i("start 'tester' evaluator"),
+    TesterInitState = #{server => Server#ev.pid,
+                        client => Client#ev.pid,
+                        num    => maps:get(num, InitState)},
+    Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
+
+    i("await evaluator"),
+    ok = ?SEV_AWAIT_FINISH([Server, Client, Tester]).
+
+
+
+%% Server side handler process
+%% We don't actually need a separate process for this socket, 
+%% but we do it anyway to simplify the sequence.
+tpp_udp_server_handler_create() ->
+    Self = self(),
+    erlang:spawn(fun() -> tpp_udp_server_handler(Self) end).
+
+tpp_udp_server_handler(Parent) ->
+    tpp_udp_server_handler_init(Parent),
+    {Sock, Send, Recv} = tpp_udp_handler_await_start(Parent),
+    tpp_udp_handler_announce_ready(Parent, init),
+    tpp_udp_handler_await_continue(Parent, recv),
+    Result = tpp_udp_server_handler_msg_exchange(Sock, Send, Recv),
+    tpp_udp_handler_announce_ready(Parent, recv, Result),
+    Reason = tpp_udp_handler_await_terminate(Parent),
+    ?SEV_IPRINT("terminating"),
+    exit(Reason).
+
+tpp_udp_server_handler_init(Parent) ->
+    put(sname, "shandler"),
+    ?SEV_IPRINT("init"),
+    _MRef = erlang:monitor(process, Parent),
+    ok.
+
+tpp_udp_server_handler_msg_exchange(Sock, Send, Recv) ->
+    tpp_udp_server_handler_msg_exchange_loop(Sock, Send, Recv, 0, 0, 0, undefined).
+
+tpp_udp_server_handler_msg_exchange_loop(Sock, Send, Recv, 
+                                         N, Sent, Received, Start) ->
+    %% ?SEV_IPRINT("[~w] try receive", [N]),
+    %% if 
+    %%     (N =:= (?TPP_SMALL_NUM-2)) -> 
+    %%         ?SEV_IPRINT("[~w] try receive", [N]),
+    %%         socket:setopt(Sock, otp, debug, true); 
+    %%     true -> ok
+    %% end,
+    case tpp_udp_recv_req(Sock, Recv) of
+        {ok, Msg, RecvSz, From} ->
+            NewStart = if (Start =:= undefined) -> ?LIB:timestamp(); 
+                          true -> Start end,
+            %% ?SEV_IPRINT("[~w] received - now try send", [N]),
+            case tpp_udp_send_rep(Sock, Send, Msg, From) of
+                {ok, SendSz} ->
+                    tpp_udp_server_handler_msg_exchange_loop(Sock, Send, Recv,
+                                                             N+1,
+                                                             Sent+SendSz,
+                                                             Received+RecvSz,
+                                                             NewStart);
+                {error, SReason} ->
+                    ?SEV_EPRINT("send (~w): ~p", [N, SReason]),
+                    exit({send, SReason, N})
+            end;
+        %% {error, timeout} ->
+        %%     ?SEV_IPRINT("timeout(~w) - try again", [N]),
+        %%     case Send(Sock, list_to_binary("ping")) of
+        %%         ok ->
+        %%             exit({'ping-send', ok, N});
+        %%         {error, Reason} ->
+        %%             exit({'ping-send', Reason, N})
+        %%     end;
+        {error, closed} ->
+            ?SEV_IPRINT("closed - we are done: ~w, ~w, ~w", [N, Sent, Received]),
+            Stop = ?LIB:timestamp(),
+            {N, Sent, Received, Start, Stop};
+        {error, RReason} ->
+            ?SEV_EPRINT("recv (~w): ~p", [N, RReason]),
+            exit({recv, RReason, N})
+    end.
+  
+
+%% The (remote) client side handler process
+
+tpp_udp_client_handler_create(Node) ->
+    Self = self(),
+    GL   = group_leader(),
+    Fun  = fun() -> tpp_udp_client_handler(Self, GL) end,
+    erlang:spawn(Node, Fun).
+
+tpp_udp_client_handler(Parent, GL) ->
+    tpp_udp_client_handler_init(Parent, GL),
+    {ServerSA, BufInit, Send, Recv} = tpp_udp_handler_await_start(Parent),
+    Domain   = maps:get(family, ServerSA),
+    Sock     = tpp_udp_sock_open(Domain, BufInit),
+    tpp_udp_sock_bind(Sock, Domain),
+    tpp_udp_handler_announce_ready(Parent, init),
+    {InitMsg, Num} = tpp_udp_handler_await_continue(Parent, send),
+    Result = tpp_udp_client_handler_msg_exchange(Sock, ServerSA, 
+                                                 Send, Recv, InitMsg, Num),
+    tpp_udp_handler_announce_ready(Parent, send, Result),
+    Reason = tpp_udp_handler_await_terminate(Parent),
+    tpp_udp_sock_close(Sock),
+    ?SEV_IPRINT("terminating"),
+    exit(Reason).
+
+tpp_udp_client_handler_init(Parent, GL) ->
+    put(sname, "chandler"),
+    ?SEV_IPRINT("init"),
+    _MRef = erlang:monitor(process, Parent),
+    group_leader(self(), GL),
+    ok.
+
+tpp_udp_client_handler_msg_exchange(Sock, ServerSA, Send, Recv, InitMsg, Num) ->
+    Start = ?LIB:timestamp(),
+    tpp_udp_client_handler_msg_exchange_loop(Sock, ServerSA, Send, Recv, InitMsg, 
+                                             Num, 0, 0, 0, Start).
+
+tpp_udp_client_handler_msg_exchange_loop(_Sock, _Dest, _Send, _Recv, _Msg,
+                                         Num, Num, Sent, Received,
+                                         Start) ->
+    Stop = ?LIB:timestamp(),
+    {Sent, Received, Start, Stop};
+tpp_udp_client_handler_msg_exchange_loop(Sock, Dest, Send, Recv, Data, 
+                                         Num, N, Sent, Received, Start) ->
+    %% d("tpp_udp_client_handler_msg_exchange_loop(~w,~w) try send", [Num,N]),
+    case tpp_udp_send_req(Sock, Send, Data, Dest) of
+        {ok, SendSz} ->
+            %% d("tpp_tcp_client_msg_exchange_loop(~w,~w) sent - "
+            %%   "now try recv", [Num,N]),
+            case tpp_udp_recv_rep(Sock, Recv) of
+                {ok, NewData, RecvSz, Dest} ->
+                    tpp_udp_client_handler_msg_exchange_loop(Sock, Dest, Send, Recv,
+                                                             NewData, Num, N+1,
+                                                             Sent+SendSz, 
+                                                             Received+RecvSz, 
+                                                             Start);
+                {error, RReason} ->
+                    ?SEV_EPRINT("recv (~w of ~w): ~p", [N, Num, RReason]),
+                    exit({recv, RReason, N})
+            end;
+        {error, SReason} ->
+            ?SEV_EPRINT("send (~w of ~w): ~p", [N, Num, SReason]),
+            exit({send, SReason, N})
+    end.
+
+
+tpp_udp_recv_req(Sock, Recv) ->
+    tpp_udp_recv(Sock, Recv, ?TPP_REQUEST).
+
+tpp_udp_recv_rep(Sock, Recv) ->
+    tpp_udp_recv(Sock, Recv, ?TPP_REPLY).
+
+tpp_udp_recv(Sock, Recv, Tag) ->
+    case Recv(Sock, 0) of
+        {ok, {Source, <<Tag:32/integer, Sz:32/integer, Data/binary>> = Msg}} 
+          when (Sz =:= size(Data)) ->
+            %% We got it all
+            %% ?SEV_IPRINT("tpp_udp_recv -> got all: "
+            %%             "~n   Source:     ~p"
+            %%             "~n   Tag:        ~p"
+            %%             "~n   Sz:         ~p"
+            %%             "~n   size(Data): ~p", [Source, Tag, Sz, size(Data)]),
+            {ok, Data, size(Msg), Source};
+        {ok, {Source, <<Tag:32/integer, Sz:32/integer, Data/binary>> = Msg}} ->
+            %% ?SEV_IPRINT("tpp_udp_recv -> got part: "
+            %%             "~n   Source:     ~p"
+            %%             "~n   Tag:        ~p"
+            %%             "~n   Sz:         ~p"
+            %%             "~n   size(Data): ~p", [Source, Tag, Sz, size(Data)]),
+            Remains = Sz - size(Data),
+            tpp_tcp_recv(Sock, Source, Recv, Tag, Remains, size(Msg), [Data]);
+        {ok, {_, <<Tag:32/integer, _/binary>>}} ->
+            {error, {invalid_msg_tag, Tag}};
+        {error, _} = ERROR ->
+            ERROR
+    end.
+
+%% We match against Source since we only communicate with one peer
+tpp_tcp_recv(Sock, Source, Recv, Tag, Remaining, AccSz, Acc) ->
+    %% ?SEV_IPRINT("tpp_tcp_recv -> entry with"
+    %%             "~n   Tag:       ~p"
+    %%             "~n   Remaining: ~p"
+    %%             "~n   AccSz:     ~p"
+    %%             "~n   RcvBuf:    ~p"
+    %%             "~n   SndBuf:    ~p", 
+    %%             [Tag, Remaining, AccSz, 
+    %%              socket:getopt(Sock, socket, rcvbuf),
+    %%              socket:getopt(Sock, socket, sndbuf)]),
+    case Recv(Sock, Remaining) of
+        {ok, {Source, Data}} when (Remaining =:= size(Data)) ->
+            %% ?SEV_IPRINT("tpp_udp_recv -> got rest: "
+            %%             "~n   Source:     ~p"
+            %%             "~n   size(Data): ~p", [Source, size(Data)]),
+            %% We got the rest
+            TotSz = AccSz + size(Data),
+            {ok, 
+             erlang:iolist_to_binary(lists:reverse([Data | Acc])), 
+             TotSz, Source};
+        {ok, {Source, Data}} when (Remaining > size(Data)) ->
+            %% ?SEV_IPRINT("tpp_udp_recv -> got part of rest: "
+            %%             "~n   Source:     ~p"
+            %%             "~n   size(Data): ~p", [Source, size(Data)]),
+            tpp_tcp_recv(Sock, Source, Recv, Tag, 
+                         Remaining - size(Data), AccSz + size(Data),     
+                         [Data | Acc]);
+        {error, _} = ERROR ->
+            ERROR
+    end.
+
+
+tpp_udp_send_req(Sock, Send, Data, Dest) ->
+    tpp_udp_send(Sock, Send, ?TPP_REQUEST, Data, Dest).
+
+tpp_udp_send_rep(Sock, Send, Data, Dest) ->
+    tpp_udp_send(Sock, Send, ?TPP_REPLY, Data, Dest).
+
+tpp_udp_send(Sock, Send, Tag, Data, Dest) ->
+    DataSz = size(Data),
+    Msg    = <<Tag:32/integer, DataSz:32/integer, Data/binary>>,
+    tpp_udp_send_msg(Sock, Send, Msg, Dest, 0).
+
+tpp_udp_send_msg(Sock, Send, Msg, Dest, AccSz) when is_binary(Msg) ->
+    %% d("tpp_udp_send_msg -> entry with"
+    %%   "~n   size(Msg): ~p"
+    %%   "~n   Dest:      ~p"
+    %%   "~n   AccSz:     ~p"
+    %%   "~n   RcvBuf:    ~p"
+    %%   "~n   SndBuf:    ~p", 
+    %%   [size(Msg), Dest, AccSz, 
+    %%    socket:getopt(Sock, socket, rcvbuf),
+    %%    socket:getopt(Sock, socket, sndbuf)]),
+    case Send(Sock, Msg, Dest) of
+        ok ->
+            {ok, AccSz+size(Msg)};
+        {ok, Rest} -> % This is an IOVec
+            RestBin = list_to_binary(Rest),
+            tpp_udp_send_msg(Sock, Send, RestBin, Dest,
+                             AccSz+(size(Msg)-size(RestBin)));
+        {error, _} = ERROR ->
+            ERROR
+    end.
+    
+
+tpp_udp_handler_await_start(Parent) ->
+    ?SEV_IPRINT("await start"),
+    ?SEV_AWAIT_START(Parent).
+
+tpp_udp_handler_announce_ready(Parent, Slogan) ->
+    ?SEV_IPRINT("announce ready (~p)", [Slogan]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan).
+tpp_udp_handler_announce_ready(Parent, Slogan, Extra) ->
+    ?SEV_IPRINT("announce ready (~p)", [Slogan]),
+    ?SEV_ANNOUNCE_READY(Parent, Slogan, Extra).
+
+tpp_udp_handler_await_continue(Parent, Slogan) ->
+    ?SEV_IPRINT("await continue (~p)", [Slogan]),
+    case ?SEV_AWAIT_CONTINUE(Parent, parent, Slogan) of
+        ok ->
+            ?SEV_IPRINT("continue (~p): ok", [Slogan]),
+            ok;
+        {ok, Data} ->
+            ?SEV_IPRINT("continue (~p): ok with data", [Slogan]),
+            Data;
+        {error, Reason} ->
+            ?SEV_EPRINT("continue (~p): error"
+                        "~n   ~p", [Slogan, Reason]),
+            exit({continue, Slogan, Reason})
+    end.
+
+tpp_udp_handler_await_terminate(Parent) ->
+    ?SEV_IPRINT("await terminate"),
+    case ?SEV_AWAIT_TERMINATE(Parent, parent) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            Reason
+    end.
+
+
+tpp_udp_sock_open(Domain, BufInit) ->
+    case socket:open(Domain, dgram, udp) of
+        {ok, Sock} ->
+            ok = BufInit(Sock),
+            Sock;
+        {error, Reason} ->
+            exit({open_failed, Reason})
+    end.
+
+tpp_udp_sock_bind(Sock, Domain) ->
+    LAddr = which_local_addr(Domain),
+    LSA   = #{family => Domain, 
+              addr   => LAddr},
+    case socket:bind(Sock, LSA) of
+        {ok, _} ->
+            ok;
+        {error, Reason} ->
+            exit({bind, Reason})
+    end.
+
+tpp_udp_sock_close(Sock) ->
+    case socket:close(Sock) of
+        ok ->
+            ok;
+        {error, Reason} ->
+            exit({close, Reason})
+    end.
+
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 %% This gets the local address (not 127.0...)
@@ -6698,7 +9027,7 @@ which_addr2(Domain, [_|IFO]) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 start_node(Host, NodeName) ->
-    UniqueNodeName = f("~w_~w", [NodeName, erlang:unique_integer([positive])]),
+    UniqueNodeName = f("~w_~w", [NodeName, erlang:system_time(millisecond)]),
     case do_start_node(Host, UniqueNodeName) of
         {ok, _} = OK ->
             OK;
@@ -6923,6 +9252,9 @@ tc_which_name() ->
 l2a(S) when is_list(S) ->
     list_to_atom(S).
 
+l2b(L) when is_list(L) ->
+    list_to_binary(L).
+
 b2l(B) when is_binary(B) ->
     binary_to_list(B).
 
@@ -6953,6 +9285,22 @@ f(F, A) ->
 %%     i(Before ++ FStr ++ After, []).
 
 
+d(F, A) ->
+    d(get(dbg_fd), F, A).
+
+d(undefined, F, A) ->
+    [NodeNameStr|_] = string:split(atom_to_list(node()), [$@]),
+    DbgFileName = f("~s-dbg.txt", [NodeNameStr]),
+    case file:open(DbgFileName, [write]) of
+        {ok, FD} ->
+            put(dbg_fd, FD),
+            d(FD, F, A);
+        {error, Reason} ->
+            exit({failed_open_dbg_file, Reason})
+    end;
+d(FD, F, A) ->
+    io:format(FD, "~s~n", [f("[~s] " ++ F, [formated_timestamp()|A])]).
+
 i(F) ->
     i(F, []).
 
diff --git a/erts/preloaded/ebin/socket.beam b/erts/preloaded/ebin/socket.beam
index 480f86334c..25046e6aad 100644
--- a/erts/preloaded/ebin/socket.beam
+++ b/erts/preloaded/ebin/socket.beam
diff --git a/erts/preloaded/src/socket.erl b/erts/preloaded/src/socket.erl
index 5ebc2074e0..a40692881b 100644
--- a/erts/preloaded/src/socket.erl
+++ b/erts/preloaded/src/socket.erl
@@ -1573,12 +1573,13 @@ sendmsg(Socket, MsgHdr, Timeout)
     sendmsg(Socket, MsgHdr, ?SOCKET_SENDMSG_FLAGS_DEFAULT, Timeout).
 
 
--spec sendmsg(Socket, MsgHdr, Flags, Timeout) -> ok | {error, Reason} when
-      Socket  :: socket(),
-      MsgHdr  :: msghdr(),
-      Flags   :: send_flags(),
-      Timeout :: timeout(),
-      Reason  :: term().
+-spec sendmsg(Socket, MsgHdr, Flags, Timeout) -> ok | {ok, Remaining} | {error, Reason} when
+      Socket    :: socket(),
+      MsgHdr    :: msghdr(),
+      Flags     :: send_flags(),
+      Timeout   :: timeout(),
+      Remaining :: erlang:iovec(),
+      Reason    :: term().
 
 sendmsg(#socket{ref = SockRef}, #{iov := IOV} = MsgHdr, Flags, Timeout)
   when is_list(IOV) andalso 
@@ -1603,6 +1604,18 @@ do_sendmsg(SockRef, MsgHdr, EFlags, Timeout) ->
             %% We are done
             ok;
 
+        {ok, Written} when is_integer(Written) andalso (Written > 0) ->
+
+            %% We should not retry here since the protocol may not
+            %% be able to handle a message being split. Leave it to
+            %% the caller to figure out (call again with the rest).
+            %%
+            %% We should really not need to cancel, since this is
+            %% accepted for sendmsg!
+            %%
+            cancel(SockRef, sendmsg, SendRef),
+            {ok, do_sendmsg_rest(maps:get(iov, MsgHdr), Written)};
+
         {error, eagain} ->
             receive
                 {select, SockRef, SendRef, ready_output} ->
@@ -1617,6 +1630,12 @@ do_sendmsg(SockRef, MsgHdr, EFlags, Timeout) ->
             ERROR
     end.
 
+do_sendmsg_rest([B|IOVec], Written) when (Written >= size(B)) ->
+    do_sendmsg_rest(IOVec, Written - size(B));
+do_sendmsg_rest([B|IOVec], Written) ->
+    <<_:Written/binary, Rest/binary>> = B,
+    [Rest|IOVec].
+
 ensure_msghdr(#{ctrl := []} = M) ->
     ensure_msghdr(maps:remove(ctrl, M));
 ensure_msghdr(#{iov := IOV} = M) when is_list(IOV) andalso (IOV =/= []) ->
@@ -1625,6 +1644,8 @@ ensure_msghdr(_) ->
     einval().
 
 
+
+
 %% ===========================================================================
 %%
 %% writev - write data into multiple buffers
@@ -1937,6 +1958,7 @@ do_recvfrom(SockRef, BufSz, EFlags, Timeout)  ->
                                 next_timeout(TS, Timeout));
 
                 {nif_abort, RecvRef, Reason} ->
+                    %% p("received nif-abort: ~p", [Reason]),
                     {error, Reason}
 
             after NewTimeout ->
@@ -1949,6 +1971,13 @@ do_recvfrom(SockRef, BufSz, EFlags, Timeout)  ->
 
     end.
 
+%% pi(Item) ->
+%%     pi(self(), Item).
+
+%% pi(Pid, Item) ->
+%%     {Item, Info} = process_info(Pid, Item),
+%%     Info.
+
 
 %% ---------------------------------------------------------------------------
 %%
@@ -1983,10 +2012,20 @@ recvmsg(Socket, Timeout) ->
       Flags   :: recv_flags(),
       Timeout :: timeout(),
       MsgHdr  :: msghdr(),
+      Reason  :: term()
+                 ; (Socket, BufSz, CtrlSz) -> {ok, MsgHdr} | {error, Reason} when
+      Socket  :: socket(),
+      BufSz   :: non_neg_integer(),
+      CtrlSz  :: non_neg_integer(),
+      MsgHdr  :: msghdr(),
       Reason  :: term().
 
-recvmsg(Socket, Flags, Timeout) ->
-    recvmsg(Socket, 0, 0, Flags, Timeout).
+recvmsg(Socket, Flags, Timeout) when is_list(Flags) ->
+    recvmsg(Socket, 0, 0, Flags, Timeout);
+recvmsg(Socket, BufSz, CtrlSz) when is_integer(BufSz) andalso is_integer(CtrlSz) ->
+    recvmsg(Socket, BufSz, CtrlSz,
+            ?SOCKET_RECV_FLAGS_DEFAULT, ?SOCKET_RECV_TIMEOUT_DEFAULT).
+
 
 -spec recvmsg(Socket, 
               BufSz, CtrlSz,