test_tcp_state.c File Reference

#include "test_tcp_state.h"
#include "lwip/priv/tcp_priv.h"
#include "lwip/stats.h"
#include "tcp_helper.h"
#include "lwip/inet_chksum.h"

Include dependency graph for test_tcp_state.c:

Go to the source code of this file.

Macros
#define	SEQNO1   (0xFFFFFF00 - TCP_MSS)
#define	ISS   6510

Functions
static void	test_tcp_tmr (void)
static u8_t	get_tcp_flags_from_packet (struct pbuf *p, u16_t tcp_hdr_offset)
static struct tcp_pcb_listen *	create_listening_pcb (u16_t local_port, struct test_tcp_counters *counters)
static void	tcp_state_setup (void)
static void	tcp_state_teardown (void)
static void	test_rst_generation_with_incoming_packet (struct pbuf *p, struct netif *netif, struct test_tcp_txcounters *tx_counters)
	START_TEST (test_tcp_new_max_num)
END_TEST	START_TEST (test_tcp_new_max_num_remove_TIME_WAIT)
END_TEST	START_TEST (test_tcp_connect_active_open)
END_TEST	START_TEST (test_tcp_active_close)
END_TEST	START_TEST (test_tcp_imultaneous_close)
END_TEST	START_TEST (test_tcp_gen_rst_in_CLOSED)
END_TEST	START_TEST (test_tcp_gen_rst_in_LISTEN)
END_TEST	START_TEST (test_tcp_gen_rst_in_TIME_WAIT)
END_TEST	START_TEST (test_tcp_process_rst_seqno)
END_TEST	START_TEST (test_tcp_gen_rst_in_SYN_SENT_ackseq)
END_TEST	START_TEST (test_tcp_gen_rst_in_SYN_SENT_non_syn_ack)
END_TEST	START_TEST (test_tcp_gen_rst_in_SYN_RCVD)
END_TEST	START_TEST (test_tcp_receive_rst_SYN_RCVD_to_LISTEN)
END_TEST Suite *	tcp_state_suite (void)

Variables
static struct netif	test_netif = {0}
static struct test_tcp_txcounters	test_txcounters = {0}
static u8_t	test_tcp_timer
static struct netif *	old_netif_list
static struct netif *	old_netif_default

Macro Definition Documentation

ISS

#define ISS   6510

Definition at line 20 of file test_tcp_state.c.

SEQNO1

#define SEQNO1   (0xFFFFFF00 - TCP_MSS)

Definition at line 19 of file test_tcp_state.c.

Function Documentation

create_listening_pcb()

static struct tcp_pcb_listen * create_listening_pcb ( u16_t  local_port, struct test_tcp_counters *  counters  )

static

Definition at line 48 of file test_tcp_state.c.

{
  struct tcp_pcb *pcb;
  struct tcp_pcb_listen *lpcb=NULL;
  err_t err;
  u16_t port = local_port?local_port:1234;
 
  if (counters) {
    pcb = test_tcp_new_counters_pcb(counters);
  } else {
    pcb = tcp_new();
  }
  EXPECT(pcb != NULL);
 
  if (pcb) {
    err = tcp_bind(pcb, &test_netif.ip_addr, port);
    EXPECT(err == ERR_OK);
    lpcb = (struct tcp_pcb_listen *)tcp_listen(pcb);
  }
 
  return lpcb;
}

Referenced by START_TEST().

get_tcp_flags_from_packet()

static u8_t get_tcp_flags_from_packet ( struct pbuf *  p, u16_t  tcp_hdr_offset  )

static

Definition at line 35 of file test_tcp_state.c.

{
  struct tcp_hdr tcphdr;
  u16_t ret;
  EXPECT_RETX(p != NULL, 0);
  EXPECT_RETX(p->len >= tcp_hdr_offset + sizeof(struct tcp_hdr), 0);
  ret = pbuf_copy_partial(p, &tcphdr, sizeof(struct tcp_hdr), tcp_hdr_offset);
  EXPECT(ret == sizeof(struct tcp_hdr));
  return TCPH_FLAGS(&tcphdr);
}

Referenced by START_TEST(), and test_rst_generation_with_incoming_packet().

START_TEST() [1/13]

END_TEST START_TEST

(

test_tcp_active_close

)

Definition at line 253 of file test_tcp_state.c.

{
  struct tcp_pcb *pcb, *pcbl;
  struct test_tcp_counters counters;
  struct pbuf *p;
  err_t err;
  u32_t i;
  LWIP_UNUSED_ARG(_i);
 
  /* create TCP in LISTEN state */
  memset(&counters, 0, sizeof(counters));
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  err = tcp_bind(pcb, &test_netif.ip_addr, 1234);
  EXPECT_RET(err == ERR_OK);
  pcbl = tcp_listen(pcb);
  EXPECT_RET(pcbl != NULL);
  EXPECT_RET(pcbl->state == LISTEN);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 1);
 
  memset(&test_txcounters, 0, sizeof(test_txcounters));
  err = tcp_close(pcbl);
  EXPECT_RET(err == ERR_OK);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 0);
  EXPECT(test_txcounters.num_tx_calls == 0);
 
  /* close TCP in SYN_SENT state */
  memset(&counters, 0, sizeof(counters));
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  err = tcp_connect(pcb, &test_netif.gw, 1234, NULL);
  EXPECT_RET(err == ERR_OK);
  EXPECT_RET(pcb->state == SYN_SENT);
  EXPECT(test_txcounters.num_tx_calls == 1);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
 
  memset(&test_txcounters, 0, sizeof(test_txcounters));
  err = tcp_close(pcb);
  EXPECT_RET(err == ERR_OK);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
  EXPECT(test_txcounters.num_tx_calls == 0);
 
  /* close TCP in ESTABLISHED state */
  memset(&counters, 0, sizeof(counters));
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
 
  memset(&test_txcounters, 0, sizeof(test_txcounters));
  err = tcp_close(pcb);
  EXPECT_RET(err == ERR_OK);
  EXPECT_RET(pcb->state == FIN_WAIT_1);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  /* test_tcp_tmr(); */
  EXPECT(test_txcounters.num_tx_calls == 1);
  /* create a segment ACK and pass it to tcp_input */
  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 1, TCP_ACK);
  EXPECT_RET(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT_RET(pcb->state == FIN_WAIT_2);
  /* create a segment FIN and pass it to tcp_input */
  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_FIN);
  EXPECT_RET(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT_RET(pcb->state == TIME_WAIT);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  for (i = 0; i < 2 * TCP_MSL / TCP_TMR_INTERVAL + 1; i++) {
    test_tcp_tmr();
  }
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
}

START_TEST() [2/13]

END_TEST START_TEST

(

test_tcp_connect_active_open

)

Definition at line 203 of file test_tcp_state.c.

{
  struct test_tcp_counters counters;
  struct tcp_pcb *pcb;
  struct pbuf *p;
  err_t err;
  u16_t test_port = 1234;
  u32_t seqno = 0;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize the pcb */
  tcp_ticks = SEQNO1 - ISS;
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  
  /* Get seqno from SYN packet */
  test_txcounters.copy_tx_packets = 1;
  err = tcp_connect(pcb, &test_remote_ip, test_port, NULL);
  test_txcounters.copy_tx_packets = 0;
  EXPECT(err == ERR_OK);
  EXPECT(pcb->state == SYN_SENT);
  EXPECT(test_txcounters.num_tx_calls == 1);
  EXPECT_RET(test_txcounters.tx_packets != NULL);
  if (test_txcounters.tx_packets != NULL) {
    struct tcp_hdr tcphdr;
    u16_t ret;
    ret = pbuf_copy_partial(test_txcounters.tx_packets, &tcphdr, 20, 20);
    EXPECT(ret == 20);
    EXPECT(TCPH_FLAGS(&tcphdr) & TCP_SYN);
    pbuf_free(test_txcounters.tx_packets);
    test_txcounters.tx_packets = NULL;
    seqno = lwip_htonl(tcphdr.seqno);
    EXPECT(seqno == pcb->lastack);
  }
 
  /* check correct syn packet */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, test_port,
    pcb->local_port, NULL, 0, 12345, seqno + 1, TCP_SYN|TCP_ACK);
  EXPECT_RET(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT_RET(pcb->state == ESTABLISHED);
  EXPECT_RET(test_txcounters.num_tx_calls == 2);
 
  /* make sure the pcb is freed */
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  tcp_abort(pcb);
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
}

START_TEST() [3/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_CLOSED

)

Definition at line 375 of file test_tcp_state.c.

{
  struct pbuf *p;
  ip_addr_t src_addr = test_remote_ip;
  ip_addr_t dst_addr = test_local_ip;
  LWIP_UNUSED_ARG(_i);
 
  /* Do not create any pcb */
 
  /* create a segment */
  p = tcp_create_segment(&src_addr, &dst_addr, TEST_REMOTE_PORT,
    TEST_LOCAL_PORT, NULL, 0, 12345, 54321, TCP_ACK);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
  EXPECT(test_txcounters.num_tx_calls == 1);
 
}

START_TEST() [4/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_LISTEN

)

Definition at line 395 of file test_tcp_state.c.

{
  struct tcp_pcb_listen *lpcb;
  struct pbuf *p;
  ip_addr_t src_addr = test_remote_ip;
  LWIP_UNUSED_ARG(_i);
 
  /* create a pcb in LISTEN state */
  lpcb = create_listening_pcb(TEST_LOCAL_PORT, NULL);
  EXPECT_RET(lpcb != NULL);
 
  /* create a segment */
  p = tcp_create_segment(&src_addr,&lpcb->local_ip, TEST_REMOTE_PORT,
    lpcb->local_port, NULL, 0, 12345, 54321, TCP_ACK);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
  EXPECT(test_txcounters.num_tx_calls == 1);
 
  /* the PCB still in LISTEN state */
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 1);
  if (MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) != 0) {
    /* can not use tcp_abort() */
    tcp_close((struct tcp_pcb *)lpcb);
  }
 
}

START_TEST() [5/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_SYN_RCVD

)

Definition at line 559 of file test_tcp_state.c.

{
  struct tcp_pcb_listen *lpcb;
  struct pbuf *p;
  u32_t ack_seqno = 0;
  ip_addr_t src_addr = test_remote_ip;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize a pcb in listen state */
  lpcb = create_listening_pcb(TEST_LOCAL_PORT, NULL);
  EXPECT_RET(lpcb != NULL);
 
  /* LISTEN -> SYN_RCVD */
  p = tcp_create_segment(&src_addr, &lpcb->local_ip, TEST_REMOTE_PORT,
    lpcb->local_port, NULL, 0, 1000, 54321, TCP_SYN);
  EXPECT(p != NULL);
  memset(&test_txcounters, 0, sizeof(struct test_tcp_txcounters));
  test_tcp_input(p, &test_netif);
  EXPECT(test_txcounters.num_tx_calls == 1);
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  if (MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1) {
    ack_seqno = tcp_active_pcbs[0].lastack;
  }
 
  /* create a ACK segment with incorrect seqno */
  p = tcp_create_segment(&src_addr, &lpcb->local_ip, TEST_REMOTE_PORT,
    lpcb->local_port, NULL, 0, 1001, ack_seqno+1111, TCP_ACK);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
  EXPECT(test_txcounters.num_tx_calls == 1);
 
  /* the active pcb still exists */
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 1);
  if (MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) != 0) {
    /* can not use tcp_abort() */
    tcp_close((struct tcp_pcb *)lpcb);
  }
}

START_TEST() [6/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_SYN_SENT_ackseq

)

Definition at line 505 of file test_tcp_state.c.

{
  struct tcp_pcb *pcb;
  struct pbuf *p;
  u16_t test_port = 1234;
  err_t err;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize a pcb in listen state */
  pcb = tcp_new();
  EXPECT_RET(pcb != NULL);
  err = tcp_connect(pcb, &test_remote_ip, test_port, NULL);
  EXPECT_RET(err == ERR_OK);
 
  /* create a SYN+ACK segment with incorrect seqno */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port,
    pcb->local_port, NULL, 0, 12345,  pcb->lastack-10, TCP_SYN|TCP_ACK);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
 
  /* LWIP: send RST then re-send SYN immediately */
  EXPECT(test_txcounters.num_tx_calls == 2);
 
}

START_TEST() [7/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_SYN_SENT_non_syn_ack

)

Definition at line 532 of file test_tcp_state.c.

{
  struct tcp_pcb *pcb;
  struct pbuf *p;
  u16_t test_port = 1234;
  err_t err;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize a pcb in listen state */
  pcb = tcp_new();
  EXPECT_RET(pcb != NULL);
  err = tcp_connect(pcb, &test_remote_ip, test_port, NULL);
  EXPECT_RET(err == ERR_OK);
 
  /* create a SYN+ACK segment with incorrect seqno */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port,
    pcb->local_port, NULL, 0, 12345,  pcb->lastack, TCP_ACK);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
 
  /* LWIP: send RST then re-send SYN immediately */
  EXPECT(test_txcounters.num_tx_calls == 2);
 
}

START_TEST() [8/13]

END_TEST START_TEST

(

test_tcp_gen_rst_in_TIME_WAIT

)

Definition at line 425 of file test_tcp_state.c.

{
  struct tcp_pcb *pcb;
  struct pbuf *p;
  LWIP_UNUSED_ARG(_i);
 
  /* create a pcb in LISTEN state */
  pcb = tcp_new();
  EXPECT_RET(pcb != NULL);
  tcp_set_state(pcb, TIME_WAIT, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
 
  /* create a segment */
  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_SYN);
  EXPECT(p != NULL);
  test_rst_generation_with_incoming_packet(p, &test_netif, &test_txcounters);
  EXPECT(test_txcounters.num_tx_calls == 1);
 
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  EXPECT(pcb->state == TIME_WAIT);
}

START_TEST() [9/13]

END_TEST START_TEST

(

test_tcp_imultaneous_close

)

Definition at line 330 of file test_tcp_state.c.

{
  struct test_tcp_counters counters;
  struct tcp_pcb* pcb;
  struct pbuf* p;
  char data = 0x0f;
  err_t err;
  u32_t i;
  LWIP_UNUSED_ARG(_i);
 
  /* initialize counter struct */
  memset(&counters, 0, sizeof(counters));
  counters.expected_data_len = 1;
  counters.expected_data = &data;
 
  /* create and initialize the pcb */
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
  err = tcp_close(pcb);
  EXPECT_RET(err == ERR_OK);
  EXPECT_RET(pcb->state == FIN_WAIT_1);
  /* create a FIN segment */
  p = tcp_create_rx_segment(pcb, &data, 0, 0, 0, TCP_FIN);
  EXPECT(p != NULL);
  if (p != NULL) {
    test_tcp_input(p, &test_netif);
  }
  EXPECT_RET(pcb->state == CLOSING);
  /* create an ACK segment */
  p = tcp_create_rx_segment(pcb, &data, 0, 0, 1, TCP_ACK);
  EXPECT(p != NULL);
  if (p != NULL) {
    test_tcp_input(p, &test_netif);
  }
  EXPECT_RET(pcb->state == TIME_WAIT);
  for (i = 0; i < 2 * TCP_MSL / TCP_TMR_INTERVAL + 1; i++) {
    test_tcp_tmr();
  }
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
}

START_TEST() [10/13]

START_TEST

(

test_tcp_new_max_num

)

Definition at line 135 of file test_tcp_state.c.

{
  struct tcp_pcb* pcb[MEMP_NUM_TCP_PCB + 1];
  int i;
  LWIP_UNUSED_ARG(_i);
 
  fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
 
  for(i = 0;i < MEMP_NUM_TCP_PCB; i++) {
    pcb[i] = tcp_new();
    fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == (i + 1));
  }
  fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == MEMP_NUM_TCP_PCB);
  /* Trying to remove the oldest pcb in TIME_WAIT,LAST_ACK,CLOSING state when pcb full */
  pcb[MEMP_NUM_TCP_PCB] = tcp_new();
  fail_unless(pcb[MEMP_NUM_TCP_PCB] == NULL);
  tcp_set_state(pcb[0], TIME_WAIT, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
  pcb[MEMP_NUM_TCP_PCB] = tcp_new();
  fail_unless(pcb[MEMP_NUM_TCP_PCB] != NULL);
  fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == MEMP_NUM_TCP_PCB);
 
  for (i = 1; i <= MEMP_NUM_TCP_PCB; i++)
  {
    tcp_abort(pcb[i]);
  }
  fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
}

START_TEST() [11/13]

END_TEST START_TEST

(

test_tcp_new_max_num_remove_TIME_WAIT

)

Definition at line 166 of file test_tcp_state.c.

{
  struct tcp_pcb* pcb;
  struct tcp_pcb* pcb_list[MEMP_NUM_TCP_PCB + 1];
  int i;
  LWIP_UNUSED_ARG(_i);
 
  /* create a pcb in TIME_WAIT state */
  pcb = tcp_new();
  EXPECT_RET(pcb != NULL);
  tcp_set_state(pcb, TIME_WAIT, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
  EXPECT_RET(pcb->state == TIME_WAIT);
 
  /* Create max number pcbs */
  for(i = 0;i < MEMP_NUM_TCP_PCB-1; i++) {
    pcb_list[i] = tcp_new();
    EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == (i + 2));
  }
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == MEMP_NUM_TCP_PCB);
 
  /* Create one more pcb, and expect that the pcb in the TIME_WAIT state is deleted */
  pcb_list[MEMP_NUM_TCP_PCB-1] = tcp_new();
  EXPECT_RET(pcb_list[MEMP_NUM_TCP_PCB-1] != NULL);
  EXPECT_RET(MEMP_STATS_GET(used, MEMP_TCP_PCB) == MEMP_NUM_TCP_PCB);
 
  for (i = 0; i <= MEMP_NUM_TCP_PCB-1; i++)
  {
    tcp_abort(pcb_list[i]);
  }
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
 
}

START_TEST() [12/13]

END_TEST START_TEST

(

test_tcp_process_rst_seqno

)

Definition at line 448 of file test_tcp_state.c.

{
  struct test_tcp_counters counters;
  struct tcp_pcb *pcb;
  struct pbuf *p;
  err_t err;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize a pcb in SYN_SENT state */
  memset(&counters, 0, sizeof(counters));
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  err = tcp_connect(pcb, &test_remote_ip, TEST_REMOTE_PORT, NULL);
  EXPECT_RET(err == ERR_OK);
 
  /* a RST segment with incorrect seqno will not be accepted */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, TEST_REMOTE_PORT,
    pcb->local_port, NULL, 0, 12345,  pcb->snd_nxt-10, TCP_RST);
  EXPECT(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT(counters.err_calls == 0);
 
  /* a RST segment with correct seqno will be accepted */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, TEST_REMOTE_PORT,
    pcb->local_port, NULL, 0, 12345,  pcb->snd_nxt, TCP_RST);
  EXPECT(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT(counters.err_calls == 1);
  counters.err_calls = 0;
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
 
  /* create another pcb in ESTABLISHED state */
  memset(&counters, 0, sizeof(counters));
  pcb = test_tcp_new_counters_pcb(&counters);
  EXPECT_RET(pcb != NULL);
  tcp_set_state(pcb, ESTABLISHED, &test_local_ip, &test_remote_ip, TEST_LOCAL_PORT, TEST_REMOTE_PORT);
 
  /* a RST segment with incorrect seqno will not be accepted */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port,
    pcb->local_port, NULL, 0, pcb->rcv_nxt-10, 54321, TCP_RST);
  EXPECT(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT(counters.err_calls == 0);
 
  /* a RST segment with correct seqno will be accepted */
  p = tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, TEST_REMOTE_PORT,
    pcb->local_port, NULL, 0, pcb->rcv_nxt, 54321, TCP_RST);
  EXPECT(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT(counters.err_calls == 1);
  counters.err_calls = 0;
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
 
}

START_TEST() [13/13]

END_TEST START_TEST

(

test_tcp_receive_rst_SYN_RCVD_to_LISTEN

)

Definition at line 601 of file test_tcp_state.c.

{
  struct tcp_pcb_listen *lpcb;
  struct pbuf *p;
  u16_t tcp_flags;
  ip_addr_t src_addr = test_remote_ip;
  LWIP_UNUSED_ARG(_i);
 
  /* create and initialize a pcb in listen state */
  lpcb = create_listening_pcb(TEST_LOCAL_PORT, NULL);
  EXPECT_RET(lpcb != NULL);
 
  /* create a SYN segment */
  p = tcp_create_segment(&src_addr, &lpcb->local_ip, TEST_REMOTE_PORT,
    lpcb->local_port, NULL, 0, 1000, 54321, TCP_SYN);
  EXPECT(p != NULL);
  /* pass the segment to tcp_input */
  memset(&test_txcounters, 0, sizeof(struct test_tcp_txcounters));
  test_txcounters.copy_tx_packets = 1;
  test_tcp_input(p, &test_netif);
  test_txcounters.copy_tx_packets = 0;
  /* check if packets are as expected */
  EXPECT(test_txcounters.num_tx_calls == 1);
  tcp_flags = get_tcp_flags_from_packet(test_txcounters.tx_packets, 20);
  pbuf_free(test_txcounters.tx_packets);
  test_txcounters.tx_packets = NULL;
  EXPECT((tcp_flags & TCP_SYN) && (tcp_flags & TCP_ACK));
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 1);
 
  /* create a RST segment */
  p = tcp_create_segment(&src_addr, &lpcb->local_ip, TEST_REMOTE_PORT,
    lpcb->local_port, NULL, 0, 1001, 54321, TCP_RST);
  EXPECT(p != NULL);
  test_tcp_input(p, &test_netif);
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
  EXPECT(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 1);
 
  if (MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) != 0) {
    /* can not use tcp_abort() */
    tcp_close((struct tcp_pcb *)lpcb);
  }
}

tcp_state_setup()

static void tcp_state_setup ( void  )

static

Definition at line 76 of file test_tcp_state.c.

{
  struct tcp_pcb dummy_pcb; /* we need this for tcp_next_iss() only */
 
  /* reset iss to default (6510) */
  tcp_ticks = 0;
  tcp_ticks = 0 - (tcp_next_iss(&dummy_pcb) - 6510);
  tcp_next_iss(&dummy_pcb);
  tcp_ticks = 0;
 
  test_tcp_timer = 0;
 
  old_netif_list = netif_list;
  old_netif_default = netif_default;
  netif_list = NULL;
  netif_default = NULL;
  tcp_remove_all();
  test_tcp_init_netif(&test_netif, &test_txcounters, &test_local_ip, &test_netmask);
  lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
}

Referenced by tcp_state_suite().

tcp_state_suite()

END_TEST Suite * tcp_state_suite

(

void

)

Create the suite including all tests for this module

Definition at line 647 of file test_tcp_state.c.

{
  testfunc tests[] = {
    TESTFUNC(test_tcp_new_max_num),
    TESTFUNC(test_tcp_new_max_num_remove_TIME_WAIT),
    TESTFUNC(test_tcp_connect_active_open),
    TESTFUNC(test_tcp_active_close),
    TESTFUNC(test_tcp_imultaneous_close),
    TESTFUNC(test_tcp_gen_rst_in_CLOSED),
    TESTFUNC(test_tcp_gen_rst_in_LISTEN),
    TESTFUNC(test_tcp_gen_rst_in_TIME_WAIT),
    TESTFUNC(test_tcp_process_rst_seqno),
    TESTFUNC(test_tcp_gen_rst_in_SYN_SENT_ackseq),
    TESTFUNC(test_tcp_gen_rst_in_SYN_SENT_non_syn_ack),
    TESTFUNC(test_tcp_gen_rst_in_SYN_RCVD),
    TESTFUNC(test_tcp_receive_rst_SYN_RCVD_to_LISTEN),
  };
  return create_suite("TCP_STATE", tests, sizeof(tests) / sizeof(testfunc), tcp_state_setup, tcp_state_teardown);
}

Referenced by main().

tcp_state_teardown()

static void tcp_state_teardown ( void  )

static

Definition at line 98 of file test_tcp_state.c.

{
  netif_list = NULL;
  netif_default = NULL;
  tcp_remove_all();
  /* restore netif_list for next tests (e.g. loopif) */
  netif_list = old_netif_list;
  netif_default = old_netif_default;
  lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
}

Referenced by tcp_state_suite().

test_rst_generation_with_incoming_packet()

static void test_rst_generation_with_incoming_packet ( struct pbuf *  p, struct netif *  netif, struct test_tcp_txcounters *  tx_counters  )

static

Definition at line 112 of file test_tcp_state.c.

{
  u16_t tcp_flags;
  EXPECT_RET(p != NULL);
  memset(tx_counters, 0, sizeof(struct test_tcp_txcounters));
  /* pass the segment to tcp_input */
  tx_counters->copy_tx_packets = 1;
  test_tcp_input(p, netif);
  tx_counters->copy_tx_packets = 0;
  /* check if packets are as expected */
  EXPECT(tx_counters->tx_packets != NULL);
  if (tx_counters->tx_packets) {
    tcp_flags = get_tcp_flags_from_packet(tx_counters->tx_packets, 20);
    EXPECT(tcp_flags & TCP_RST);
    pbuf_free(tx_counters->tx_packets);
    tx_counters->tx_packets = NULL;
  }
}

Referenced by START_TEST().

test_tcp_tmr()

static void test_tcp_tmr ( void  )

static

Definition at line 25 of file test_tcp_state.c.

{
  tcp_fasttmr();
  if (++test_tcp_timer & 1) {
    tcp_slowtmr();
  }
}

Referenced by START_TEST().

Variable Documentation

old_netif_default

struct netif* old_netif_default

static

Definition at line 73 of file test_tcp_state.c.

Referenced by tcp_state_setup(), and tcp_state_teardown().

old_netif_list

struct netif* old_netif_list

static

Definition at line 72 of file test_tcp_state.c.

Referenced by tcp_state_setup(), and tcp_state_teardown().

test_netif

struct netif test_netif = {0}

static

Definition at line 16 of file test_tcp_state.c.

Referenced by create_listening_pcb(), START_TEST(), and tcp_state_setup().

test_tcp_timer

u8_t test_tcp_timer

static

Definition at line 21 of file test_tcp_state.c.

Referenced by tcp_state_setup(), and test_tcp_tmr().

test_txcounters

struct test_tcp_txcounters test_txcounters = {0}

static

Definition at line 17 of file test_tcp_state.c.

Referenced by START_TEST(), and tcp_state_setup().