}
}
+void TCP_SendC(const tTCPConn *Conn, uint8_t flags, size_t data_len, const void *data)
+{
+ TCP_Send(Conn->IFNum, Conn->AF, Conn->RAddr, Conn->LPort, Conn->RPort,
+ Conn->LSeq, Conn->RSeq, flags, Conn->Window, data_len, data);
+}
void TCP_Send(int IF, int AF, const void *IP, short sport, short dport,
uint32_t seq, uint32_t ack, uint8_t flags, uint16_t window,
size_t data_len, const void *data
gTCP_Skips.Seq = Skip;
}
+
+bool TCP_Pkt_CheckC(size_t len, const void *data, size_t *out_ofs, size_t *len_out,
+ const tTCPConn *conn, uint8_t flags)
+{
+ return TCP_Pkt_Check(len, data, out_ofs, len_out,
+ conn->AF, conn->RAddr, conn->RPort, conn->LPort, conn->RSeq, conn->LSeq, flags
+ );
+}
+
bool TCP_Pkt_Check(size_t len, const void *data, size_t *out_ofs, size_t *len_out,
int AF, const void *IP, short sport, short dport,
uint32_t seq, uint32_t ack, uint8_t flags)
size_t ofs, rlen;
if( !IP_Pkt_Check(len, data, &ofs, &rlen, AF, IP, BLOB(HOST_IP), IPPROTO_TCP) )
return false;
- // TODO: IP has its own length field, use that?
tTCPHeader hdr;
TEST_ASSERT_REL(rlen, >=, sizeof(hdr));
if( !gTCP_Skips.SPort ) TEST_ASSERT_REL( ntohs(hdr.SPort), ==, sport );
TEST_ASSERT_REL( ntohs(hdr.DPort), ==, dport );
if( !gTCP_Skips.Seq ) TEST_ASSERT_REL( ntohl(hdr.Seq), ==, seq );
- if( !gTCP_Skips.Ack ) TEST_ASSERT_REL( ntohl(hdr.Ack), ==, ack );
+ if( flags & TCP_ACK ) TEST_ASSERT_REL( ntohl(hdr.Ack), ==, ack );
TEST_ASSERT_REL( hdr.Flags, ==, flags);
uint16_t real_cksum = htons(hdr.Checksum);
return true;
}
-uint32_t TCP_Pkt_GetSeq(size_t len, const void *data, int AF) {
+uint32_t TCP_Pkt_GetSeq(size_t len, const void *data, int AF)
+{
size_t ofs, rlen;
IP_Pkt_Check(len, data, &ofs, &rlen, AF, NULL, NULL, IPPROTO_TCP);
char rxbuf[MTU];
const int ERX_TIMEOUT = 1000; // Expect RX timeout (timeout=failure)
const int NRX_TIMEOUT = 250; // Not expect RX timeout (timeout=success)
-
+ const int RETX_TIMEOUT = 1000; // OS PARAM - Retransmit timeout
+ const int LOST_TIMEOUT = 1000; // OS PARAM - Time before sending an ACK
+ const int DACK_TIMEOUT = 500; // OS PARAM - Timeout for delayed ACKs
+ const size_t DACK_BYTES = 4096; // OS PARAM - Threshold for delayed ACKs
+
+ tTCPConn testconn = {
+ .IFNum = 0, .AF = 4,
+ .RAddr = BLOB(TEST_IP),
+ .LAddr = BLOB(HOST_IP),
+ .RPort = 80,
+ .LPort = 11200,
+ .Window = 0x1000,
+ .LSeq = 0x1000,
+ .RSeq = 0,
+ };
+
const char testblob[] = "HelloWorld, this is some random testing data for TCP\xFF\x00\x66\x12\x12";
const size_t testblob_len = sizeof(testblob);
// 1. Test packets to closed port
// > RFC793 Pg.65
- const uint16_t our_window = 0x1000;
- uint32_t seq_tx = 0x1000;
- uint32_t seq_exp = 0x33456;
// 1.1. Send SYN packet
- TCP_Send(0, 4, BLOB(TEST_IP), 1234, 80, seq_tx, seq_exp, TCP_SYN, 0x1000, testblob_len, testblob);
- // Expect a TCP_RST|TCP_ACK with SEQ=0,ACK=SEQ+LEN
+ TCP_SendC(&testconn, TCP_SYN, testblob_len, testblob);
+ testconn.RSeq = 0;
+ testconn.LSeq += testblob_len;
+ // Expect RST,ACK with SEQ=0
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP), 80, 1234,
- 0, seq_tx+testblob_len, TCP_RST|TCP_ACK) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_RST|TCP_ACK) );
TEST_ASSERT_REL(ofs, ==, rxlen);
// 1.2. Send a SYN,ACK packet
- TCP_Send(0, 4, BLOB(TEST_IP), 1234, 80, seq_tx, seq_exp, TCP_SYN|TCP_ACK, 0x1000, 0, NULL);
+ testconn.RSeq = 12345;
+ TCP_SendC(&testconn, TCP_SYN|TCP_ACK, 0, NULL);
// Expect a TCP_RST with SEQ=ACK
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP), 80, 1234, seq_exp, seq_tx+0, TCP_RST) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_RST) );
TEST_ASSERT_REL(ofs, ==, rxlen);
+ testconn.LSeq ++;
// 1.3. Send a RST packet
- TCP_Send(0, 4, BLOB(TEST_IP), 1234, 80, seq_tx, seq_exp, TCP_RST, 0x1000, 0, NULL);
+ TCP_SendC(&testconn, TCP_RST, 0, NULL);
// Expect nothing
TEST_ASSERT_no_rx();
+ testconn.LSeq ++;
// 1.3. Send a RST,ACK packet
- TCP_Send(0, 4, BLOB(TEST_IP), 1234, 80, seq_tx, seq_exp, TCP_RST|TCP_ACK, 0x1000, 0, NULL);
+ TCP_SendC(&testconn, TCP_RST|TCP_ACK, 0, NULL);
// Expect nothing
TEST_ASSERT_no_rx();
+ testconn.LSeq ++;
// 2. Establishing connection with a server
- const int server_port = 7;
- const int local_port = 11234;
- Stack_SendCommand("tcp_echo_server %i", server_port);
+ testconn.RPort = 7;
+ testconn.LPort = 11239;
+ Stack_SendCommand("tcp_echo_server %i", testconn.RPort);
// >>> STATE: LISTEN
// 2.1. Send RST
- TCP_Send(0, 4, BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp, TCP_RST, our_window, 0, NULL);
+ TCP_SendC(&testconn, TCP_RST, 0, NULL);
// - Expect nothing
TEST_ASSERT_no_rx();
// 2.2. Send ACK
- TCP_Send(0, 4, BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp, TCP_ACK, our_window, 0, NULL);
+ TCP_SendC(&testconn, TCP_ACK, 0, NULL);
// - Expect RST
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, seq_exp, seq_tx+0, TCP_RST) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_RST) );
+ TEST_ASSERT_REL(ofs, ==, rxlen);
// 2.3. Begin hanshake (SYN)
- // TODO: "If the SYN bit is set, check the security."
- TCP_Send(0, 4, BLOB(TEST_IP), local_port, server_port, seq_tx, 0, TCP_SYN, our_window, 0, NULL);
+ // TODO: Test "If the SYN bit is set, check the security."
+ TCP_SendC(&testconn, TCP_SYN, 0, NULL);
+ testconn.LSeq ++;
// - Expect SYN,ACK with ACK == SEQ+1
TEST_ASSERT_rx();
TCP_SkipCheck_Seq(true);
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, 0, seq_tx+1, TCP_SYN|TCP_ACK) );
- seq_exp = TCP_Pkt_GetSeq(rxlen, rxbuf, 4);
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_SYN|TCP_ACK) );
+ testconn.RSeq = TCP_Pkt_GetSeq(rxlen, rxbuf, testconn.AF) + 1;
// >>> STATE: SYN-RECEIVED
// TODO: Test other transitions from SYN-RECEIVED
-
+
// 2.4. Complete handshake, TCP ACK
- seq_exp ++;
- seq_tx ++;
- TCP_Send(0,4,BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp, TCP_ACK, our_window, 0, NULL);
+ TCP_SendC(&testconn, TCP_ACK, 0, NULL);
// - Expect nothing
TEST_ASSERT_no_rx();
// >>> STATE: ESTABLISHED
// 2.5. Send data
- TCP_Send(0,4,BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp,
- TCP_ACK|TCP_PSH, our_window, testblob_len, testblob);
- seq_tx += testblob_len;
- // Expect burst delayed ACK
- TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, seq_exp, seq_tx, TCP_ACK) );
- TEST_ASSERT_REL( len, ==, 0 );
+ TCP_SendC(&testconn, TCP_ACK|TCP_PSH, testblob_len, testblob);
+ testconn.LSeq += testblob_len;
// Expect echoed reponse with ACK
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, seq_exp, seq_tx, TCP_ACK|TCP_PSH) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK|TCP_PSH) );
TEST_ASSERT_REL( len, ==, testblob_len );
TEST_ASSERT( memcmp(rxbuf + ofs, testblob, testblob_len) == 0 );
- seq_exp += testblob_len;
+ testconn.RSeq += testblob_len;
+
+ // Send something short
+ const char testblob2[] = "test blob two.";
+ const size_t testblob2_len = sizeof(testblob2);
+ TCP_SendC(&testconn, TCP_ACK|TCP_PSH, testblob2_len, testblob2);
+ testconn.LSeq += testblob2_len;
+ // Expect response with data and ACK
+ TEST_ASSERT_rx();
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK|TCP_PSH) );
+ TEST_ASSERT_REL( len, ==, testblob2_len );
+ TEST_ASSERT( memcmp(rxbuf + ofs, testblob2, testblob2_len) == 0 );
+
+ // Wait for just under retransmit time, expecting nothing
+ #if TEST_TIMERS
+ TEST_ASSERT( 0 == Net_Receive(0, sizeof(rxbuf), rxbuf, RETX_TIMEOUT-100) );
+ // Now expect the previous message
+ TEST_ASSERT_rx();
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK|TCP_PSH) );
+ TEST_ASSERT_REL( len, ==, testblob2_len );
+ TEST_ASSERT( memcmp(rxbuf + ofs, testblob2, testblob2_len) == 0 );
+ #else
+ TEST_WARN("Not testing retransmit timer");
+ #endif
+ testconn.RSeq += testblob2_len;
+
+ // Send explicit acknowledgement
+ TCP_SendC(&testconn, TCP_ACK, 0, NULL);
+ TEST_ASSERT_no_rx();
+
+ // TODO: Test delayed ACKs (Timeout and data)
+ // > Requires inhibiting the server's echo response?
+
+ // === Test out-of-order packets ===
+ testconn.LSeq += testblob2_len; // raise sequence number
+ TCP_SendC(&testconn, TCP_ACK|TCP_PSH, testblob_len, testblob);
+ // - previous data has not been sent, expect no response for ()
+ // TODO: Should this ACK be delayed?
+ //TEST_ASSERT_no_rx();
+ // - Expect an ACK of the highest received packet
+ testconn.LSeq -= testblob2_len;
+ TEST_ASSERT_rx();
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK) );
+ TEST_ASSERT_REL( len, ==, 0 );
+ // - Send missing data
+ TCP_SendC(&testconn, TCP_ACK, testblob2_len, testblob2);
+ testconn.LSeq += testblob_len+testblob2_len; // raise sequence number
+ // - Expect echo response with all sent data
+ TEST_ASSERT_rx();
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK|TCP_PSH) );
+ TEST_ASSERT_REL( len, ==, testblob_len+testblob2_len );
+ TEST_ASSERT( memcmp(rxbuf + ofs, testblob2, testblob2_len) == 0 );
+ TEST_ASSERT( memcmp(rxbuf + ofs+testblob2_len, testblob, testblob_len) == 0 );
+ testconn.RSeq += len;
// 2.6. Close connection (TCP FIN)
- TCP_Send(0,4,BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp,
- TCP_ACK|TCP_FIN, our_window, 0, NULL);
- seq_tx ++; // Empty = 1 byte
+ TCP_SendC(&testconn, TCP_ACK|TCP_FIN, 0, NULL);
+ testconn.LSeq ++; // Empty = 1 byte
// Expect ACK? (Does acess do delayed ACKs here?)
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, seq_exp, seq_tx, TCP_ACK) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_ACK) );
TEST_ASSERT_REL( len, ==, 0 );
// >>> STATE: CLOSE WAIT
// Expect FIN
TEST_ASSERT_rx();
- TEST_ASSERT( TCP_Pkt_Check(rxlen, rxbuf, &ofs, &len, 4, BLOB(TEST_IP),
- server_port, local_port, seq_exp, 0, TCP_FIN) );
+ TEST_ASSERT( TCP_Pkt_CheckC(rxlen, rxbuf, &ofs, &len, &testconn, TCP_FIN) );
TEST_ASSERT_REL( len, ==, 0 );
// >>> STATE: LAST-ACK
// 2.7 Send ACK of FIN
- TCP_Send(0,4,BLOB(TEST_IP), local_port, server_port, seq_tx, seq_exp,
- TCP_ACK, our_window, 0, NULL);
+ TCP_SendC(&testconn, TCP_ACK, 0, NULL);
// Expect no response
TEST_ASSERT_no_rx();
PUTERR("38", "D")
}
+char _prn(char byte)
+{
+ return (' ' <= byte && byte <= 'z') ? byte : '.';
+}
void Debug_HexDump(const char *Prefix, const void *Data, size_t Length)
{
const uint8_t *data = Data;
fprintf(stderr, "[HexDump ]d %s: %i bytes\n", Prefix, (int)Length);
for( ofs = 0; ofs + 16 <= Length; ofs += 16 )
{
+ const uint8_t *d = data + ofs;
fprintf(stderr, "[HexDump ]d %s:", Prefix);
fprintf(stderr, " %02x %02x %02x %02x %02x %02x %02x %02x",
- data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
- data += 8;
+ d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7]);
fprintf(stderr, " %02x %02x %02x %02x %02x %02x %02x %02x",
- data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
- data += 8;
+ d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
+ fprintf(stderr, " |%c%c%c%c""%c%c%c%c %c%c%c%c""%c%c%c%c",
+ _prn(d[ 0]), _prn(d[ 1]), _prn(d[ 2]), _prn(d[ 3]),
+ _prn(d[ 4]), _prn(d[ 5]), _prn(d[ 6]), _prn(d[ 7]),
+ _prn(d[ 8]), _prn(d[ 9]), _prn(d[10]), _prn(d[11]),
+ _prn(d[12]), _prn(d[13]), _prn(d[14]), _prn(d[15])
+ );
fprintf(stderr, "\n");
}
- fprintf(stderr, "[HexDump ]d %s:", Prefix);
- for( ; ofs < Length; ofs ++ )
+ if( ofs < Length )
{
- if( ofs % 8 == 0 ) fprintf(stderr, " ");
- fprintf(stderr, " %02x", data[ofs%16]);
+ const uint8_t *d = data + ofs;
+ fprintf(stderr, "[HexDump ]d %s: ", Prefix);
+ for( int i = 0; i < Length - ofs; i ++ )
+ {
+ if( i == 8 ) fprintf(stderr, " ");
+ fprintf(stderr, " %02x", d[i]);
+ }
+ for( int i = Length - ofs; i < 16; i ++ )
+ {
+ if( i == 8 ) fprintf(stderr, " ");
+ fprintf(stderr, " ");
+ }
+ fprintf(stderr, " |");
+ for( int i = 0; i < Length - ofs; i ++ )
+ {
+ if( i == 8 ) fprintf(stderr, " ");
+ fprintf(stderr, "%c", _prn(d[i]));
+ }
+
+ fprintf(stderr, "\n");
}
- fprintf(stderr, "\n");
LOG_LOCK_RELEASE();
}
git.ucc.asn.au / tpg / acess2.git / commitdiff
UCC git Repository :: git.ucc.asn.au