Tools/Network Test - Tweaking

[tpg/acess2.git] / Tools / NetTest_Runner / test_tcp.c

diff --git a/Tools/NetTest_Runner/test_tcp.c b/Tools/NetTest_Runner/test_tcp.c
index 36942a5..10e9163 100644 (file)
--- a/Tools/NetTest_Runner/test_tcp.c
+++ b/Tools/NetTest_Runner/test_tcp.c
@@ -13,6 +13,15 @@
 #include "tcp.h"
 #include <string.h>
 
+#define TEST_TIMERS    0
+
+#define RX_HEADER \
+       size_t  rxlen, ofs, len; \
+       char rxbuf[MTU]
+#define TEST_HEADER \
+       TEST_SETNAME(__func__);\
+       RX_HEADER
+
 #define TEST_ASSERT_rx()       TEST_ASSERT( rxlen = Net_Receive(0, sizeof(rxbuf), rxbuf, ERX_TIMEOUT) )
 #define TEST_ASSERT_no_rx()    TEST_ASSERT( Net_Receive(0, sizeof(rxbuf), rxbuf, NRX_TIMEOUT) == 0 )
 const int      ERX_TIMEOUT = 1000;     // Expect RX timeout (timeout=failure)
@@ -24,9 +33,7 @@ const size_t  DACK_BYTES = 4096;      // OS PARAM - Threshold for delayed ACKs
 
 bool Test_TCP_Basic(void)
 {
-       TEST_SETNAME(__func__);
-       size_t  rxlen, ofs, len;
-       char rxbuf[MTU];
+       TEST_HEADER;
 
        tTCPConn        testconn = {
                .IFNum = 0, .AF = 4,
@@ -48,6 +55,7 @@ bool Test_TCP_Basic(void)
        // > RFC793 Pg.65
        
        // 1.1. Send SYN packet
+       TEST_STEP("1.1. Send SYN packet to CLOSED");
        TCP_SendC(&testconn, TCP_SYN, testblob_len, testblob);
        testconn.RSeq = 0;
        testconn.LSeq += testblob_len;
@@ -57,6 +65,7 @@ bool Test_TCP_Basic(void)
        TEST_ASSERT_REL(ofs, ==, rxlen);
        
        // 1.2. Send a SYN,ACK packet
+       TEST_STEP("1.2. Send SYN,ACK packet to CLOSED");
        testconn.RSeq = 12345;
        TCP_SendC(&testconn, TCP_SYN|TCP_ACK, 0, NULL);
        // Expect a TCP_RST with SEQ=ACK
@@ -66,6 +75,7 @@ bool Test_TCP_Basic(void)
        testconn.LSeq ++;
        
        // 1.3. Send a RST packet
+       TEST_STEP("1.2. Send RST packet to CLOSED");
        TCP_SendC(&testconn, TCP_RST, 0, NULL);
        // Expect nothing
        TEST_ASSERT_no_rx();
@@ -183,7 +193,7 @@ bool Test_TCP_Basic(void)
        // 2.6. Close connection (TCP FIN)
        TCP_SendC(&testconn, TCP_ACK|TCP_FIN, 0, NULL);
        testconn.LSeq ++;       // Empty = 1 byte
-       // Expect ACK? (Does acess do delayed ACKs here?)
+       // Expect ACK? (Does Acess do delayed ACKs here?)
        TEST_ASSERT_rx();
        TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK) );
        TEST_ASSERT_REL( len, ==, 0 );
@@ -206,20 +216,41 @@ bool Test_TCP_Basic(void)
        return true;
 }
 
+bool Test_TCP_int_OpenConnection(tTCPConn *Conn)
+{
+       RX_HEADER;
+       // >> SYN
+       TCP_SendC(Conn, TCP_SYN, 0, NULL);
+       Conn->LSeq ++;
+       TEST_ASSERT_rx();
+       // << SYN|ACK (save remote sequence number)
+       TCP_SkipCheck_Seq(true);
+       TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, Conn, TCP_SYN|TCP_ACK) );
+       TEST_ASSERT_REL(len, ==, 0);
+       Conn->RSeq = TCP_Pkt_GetSeq(rxlen, rxbuf, Conn->AF) + 1;
+       // >> ACK
+       TCP_SendC(Conn, TCP_ACK, 0, NULL);
+       TEST_ASSERT_no_rx();
+       return true;
+}
+
+#if 0
 bool Test_TCP_SYN_RECEIVED(void)
 {
-       TEST_SETNAME(__func__);
+       TEST_HEADER;
+       
        // 1. Get into SYN-RECEIVED
+       TCP_SendC(&testconn, TCP_SYN, 0, NULL);
        
        // 2. Send various non-ACK packets
        return false;
 }
+#endif
 
-bool Test_TCP_WindowSizes(void)
+bool Test_TCP_Reset(void)
 {
-       TEST_SETNAME(__func__);
-       size_t  rxlen, ofs, len;
-       char rxbuf[MTU];
+       TEST_HEADER;
+       
        tTCPConn        testconn = {
                .IFNum = 0,
                .AF = 4,
@@ -231,20 +262,71 @@ bool Test_TCP_WindowSizes(void)
                .RSeq = 0x600,
                .Window = 128
        };
-       char    testdata[152];
-       memset(testdata, 0xAB, sizeof(testdata));
-       
+
        Stack_SendCommand("tcp_echo_server %i", testconn.RPort);
-       // > Open Connection
+
+       // 1. Response in listen-based SYN-RECEIVED
+       // >> SYN
        TCP_SendC(&testconn, TCP_SYN, 0, NULL);
        testconn.LSeq ++;
+       // << SYN|ACK :: Now in SYN-RECEIVED
        TEST_ASSERT_rx();
        TCP_SkipCheck_Seq(true);
        TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_SYN|TCP_ACK) );
        TEST_ASSERT_REL(len, ==, 0);
        testconn.RSeq = TCP_Pkt_GetSeq(rxlen, rxbuf, testconn.AF) + 1;
+       // >> RST (not ACK)
+       TCP_SendC(&testconn, TCP_RST, 0, NULL);
+       // << nothing (connection should now be dead)
+       TEST_ASSERT_no_rx();
+       // >> ACK (this should be to a closed conneciton, see LISTEN[ACK] above)
        TCP_SendC(&testconn, TCP_ACK, 0, NULL);
+       // << RST
+       TEST_ASSERT_rx();
+       TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_RST) );
+       TEST_ASSERT_REL(len, ==, 0);
+       
+       // 2. Response in open-based SYN-RECEIVED? (What is that?)
+       TEST_WARN("TODO: RFC793 pg70 mentions OPEN-based SYN-RECEIVED");
+       
+       testconn.LPort += 1234;
+       // ESTABLISHED[RST] - RFC793:Pg70
+       // 2. Response in ESTABLISHED 
+       TEST_ASSERT( Test_TCP_int_OpenConnection(&testconn) );
+       // >> RST
+       TCP_SendC(&testconn, TCP_RST, 0, NULL);
+       // << no response, connection closed
        TEST_ASSERT_no_rx();
+       // >> ACK (LISTEN[ACK])
+       TCP_SendC(&testconn, TCP_ACK, 0, NULL);
+       // << RST
+       TEST_ASSERT_rx();
+       TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_RST) );
+       TEST_ASSERT_REL(len, ==, 0);
+       
+       return true;
+}
+
+bool Test_TCP_WindowSizes(void)
+{
+       TEST_HEADER;
+       tTCPConn        testconn = {
+               .IFNum = 0,
+               .AF = 4,
+               .LAddr = BLOB(HOST_IP),
+               .RAddr = BLOB(TEST_IP),
+               .LPort = 44359,
+               .RPort = 9,
+               .LSeq = 0x600,
+               .RSeq = 0x600,
+               .Window = 128
+       };
+       char    testdata[152];
+       memset(testdata, 0xAB, sizeof(testdata));
+       
+       Stack_SendCommand("tcp_echo_server %i", testconn.RPort);
+       // > Open Connection
+       TEST_ASSERT( Test_TCP_int_OpenConnection(&testconn) );
        
        // 1. Test remote respecting our transmission window (>=1 byte)
        // > Send more data than our RX window