1 #include "tcp_helper.h"
2
3 #include "lwip/priv/tcp_priv.h"
4 #include "lwip/stats.h"
5 #include "lwip/pbuf.h"
6 #include "lwip/inet.h"
7 #include "lwip/inet_chksum.h"
8 #include "lwip/ip_addr.h"
9
10 #if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
11 #error "This tests needs TCP- and MEMP-statistics enabled"
12 #endif
13
14 const ip_addr_t test_local_ip = IPADDR4_INIT_BYTES(192, 168, 1, 1);
15 const ip_addr_t test_remote_ip = IPADDR4_INIT_BYTES(192, 168, 1, 2);
16 const ip_addr_t test_netmask = IPADDR4_INIT_BYTES(255, 255, 255, 0);
17
18 /** Remove all pcbs on the given list. */
19 static void
tcp_remove(struct tcp_pcb * pcb_list)20 tcp_remove(struct tcp_pcb* pcb_list)
21 {
22 struct tcp_pcb *pcb = pcb_list;
23 struct tcp_pcb *pcb2;
24
25 while(pcb != NULL) {
26 pcb2 = pcb;
27 pcb = pcb->next;
28 if (pcb2->state == LISTEN) {
29 tcp_close(pcb2);
30 } else {
31 tcp_abort(pcb2);
32 }
33 }
34 }
35
36 /** Remove all pcbs on listen-, active- and time-wait-list (bound- isn't exported). */
37 void
tcp_remove_all(void)38 tcp_remove_all(void)
39 {
40 tcp_remove(tcp_listen_pcbs.pcbs);
41 tcp_remove(tcp_bound_pcbs);
42 tcp_remove(tcp_active_pcbs);
43 tcp_remove(tcp_tw_pcbs);
44 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB) == 0);
45 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_PCB_LISTEN) == 0);
46 fail_unless(MEMP_STATS_GET(used, MEMP_TCP_SEG) == 0);
47 fail_unless(MEMP_STATS_GET(used, MEMP_PBUF_POOL) == 0);
48 }
49
50 /** Create a TCP segment usable for passing to tcp_input */
51 static struct pbuf*
tcp_create_segment_wnd(ip_addr_t * src_ip,ip_addr_t * dst_ip,u16_t src_port,u16_t dst_port,void * data,size_t data_len,u32_t seqno,u32_t ackno,u8_t headerflags,u16_t wnd)52 tcp_create_segment_wnd(ip_addr_t* src_ip, ip_addr_t* dst_ip,
53 u16_t src_port, u16_t dst_port, void* data, size_t data_len,
54 u32_t seqno, u32_t ackno, u8_t headerflags, u16_t wnd)
55 {
56 struct pbuf *p, *q;
57 struct ip_hdr* iphdr;
58 struct tcp_hdr* tcphdr;
59 u16_t pbuf_len = (u16_t)(sizeof(struct ip_hdr) + sizeof(struct tcp_hdr) + data_len);
60 LWIP_ASSERT("data_len too big", data_len <= 0xFFFF);
61
62 p = pbuf_alloc(PBUF_RAW, pbuf_len, PBUF_POOL);
63 EXPECT_RETNULL(p != NULL);
64 /* first pbuf must be big enough to hold the headers */
65 EXPECT_RETNULL(p->len >= (sizeof(struct ip_hdr) + sizeof(struct tcp_hdr)));
66 if (data_len > 0) {
67 /* first pbuf must be big enough to hold at least 1 data byte, too */
68 EXPECT_RETNULL(p->len > (sizeof(struct ip_hdr) + sizeof(struct tcp_hdr)));
69 }
70
71 for(q = p; q != NULL; q = q->next) {
72 memset(q->payload, 0, q->len);
73 }
74
75 iphdr = (struct ip_hdr*)p->payload;
76 /* fill IP header */
77 iphdr->dest.addr = ip_2_ip4(dst_ip)->addr;
78 iphdr->src.addr = ip_2_ip4(src_ip)->addr;
79 IPH_VHL_SET(iphdr, 4, IP_HLEN / 4);
80 IPH_TOS_SET(iphdr, 0);
81 IPH_LEN_SET(iphdr, htons(p->tot_len));
82 IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
83
84 /* let p point to TCP header */
85 pbuf_header(p, -(s16_t)sizeof(struct ip_hdr));
86
87 tcphdr = (struct tcp_hdr*)p->payload;
88 tcphdr->src = htons(src_port);
89 tcphdr->dest = htons(dst_port);
90 tcphdr->seqno = htonl(seqno);
91 tcphdr->ackno = htonl(ackno);
92 TCPH_HDRLEN_SET(tcphdr, sizeof(struct tcp_hdr)/4);
93 TCPH_FLAGS_SET(tcphdr, headerflags);
94 tcphdr->wnd = htons(wnd);
95
96 if (data_len > 0) {
97 /* let p point to TCP data */
98 pbuf_header(p, -(s16_t)sizeof(struct tcp_hdr));
99 /* copy data */
100 pbuf_take(p, data, (u16_t)data_len);
101 /* let p point to TCP header again */
102 pbuf_header(p, sizeof(struct tcp_hdr));
103 }
104
105 /* calculate checksum */
106
107 tcphdr->chksum = ip_chksum_pseudo(p,
108 IP_PROTO_TCP, p->tot_len, src_ip, dst_ip);
109
110 pbuf_header(p, sizeof(struct ip_hdr));
111
112 return p;
113 }
114
115 /** Create a TCP segment usable for passing to tcp_input */
116 struct pbuf*
tcp_create_segment(ip_addr_t * src_ip,ip_addr_t * dst_ip,u16_t src_port,u16_t dst_port,void * data,size_t data_len,u32_t seqno,u32_t ackno,u8_t headerflags)117 tcp_create_segment(ip_addr_t* src_ip, ip_addr_t* dst_ip,
118 u16_t src_port, u16_t dst_port, void* data, size_t data_len,
119 u32_t seqno, u32_t ackno, u8_t headerflags)
120 {
121 return tcp_create_segment_wnd(src_ip, dst_ip, src_port, dst_port, data,
122 data_len, seqno, ackno, headerflags, TCP_WND);
123 }
124
125 /** Create a TCP segment usable for passing to tcp_input
126 * - IP-addresses, ports, seqno and ackno are taken from pcb
127 * - seqno and ackno can be altered with an offset
128 */
129 struct pbuf*
tcp_create_rx_segment(struct tcp_pcb * pcb,void * data,size_t data_len,u32_t seqno_offset,u32_t ackno_offset,u8_t headerflags)130 tcp_create_rx_segment(struct tcp_pcb* pcb, void* data, size_t data_len, u32_t seqno_offset,
131 u32_t ackno_offset, u8_t headerflags)
132 {
133 return tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port, pcb->local_port,
134 data, data_len, pcb->rcv_nxt + seqno_offset, pcb->lastack + ackno_offset, headerflags);
135 }
136
137 /** Create a TCP segment usable for passing to tcp_input
138 * - IP-addresses, ports, seqno and ackno are taken from pcb
139 * - seqno and ackno can be altered with an offset
140 * - TCP window can be adjusted
141 */
tcp_create_rx_segment_wnd(struct tcp_pcb * pcb,void * data,size_t data_len,u32_t seqno_offset,u32_t ackno_offset,u8_t headerflags,u16_t wnd)142 struct pbuf* tcp_create_rx_segment_wnd(struct tcp_pcb* pcb, void* data, size_t data_len,
143 u32_t seqno_offset, u32_t ackno_offset, u8_t headerflags, u16_t wnd)
144 {
145 return tcp_create_segment_wnd(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port, pcb->local_port,
146 data, data_len, pcb->rcv_nxt + seqno_offset, pcb->lastack + ackno_offset, headerflags, wnd);
147 }
148
149 /** Safely bring a tcp_pcb into the requested state */
150 void
tcp_set_state(struct tcp_pcb * pcb,enum tcp_state state,const ip_addr_t * local_ip,const ip_addr_t * remote_ip,u16_t local_port,u16_t remote_port)151 tcp_set_state(struct tcp_pcb* pcb, enum tcp_state state, const ip_addr_t* local_ip,
152 const ip_addr_t* remote_ip, u16_t local_port, u16_t remote_port)
153 {
154 u32_t iss;
155
156 /* @todo: are these all states? */
157 /* @todo: remove from previous list */
158 pcb->state = state;
159
160 iss = tcp_next_iss(pcb);
161 pcb->snd_wl2 = iss;
162 pcb->snd_nxt = iss;
163 pcb->lastack = iss;
164 pcb->snd_lbb = iss;
165
166 if (state == ESTABLISHED) {
167 TCP_REG(&tcp_active_pcbs, pcb);
168 ip_addr_copy(pcb->local_ip, *local_ip);
169 pcb->local_port = local_port;
170 ip_addr_copy(pcb->remote_ip, *remote_ip);
171 pcb->remote_port = remote_port;
172 } else if(state == LISTEN) {
173 TCP_REG(&tcp_listen_pcbs.pcbs, pcb);
174 ip_addr_copy(pcb->local_ip, *local_ip);
175 pcb->local_port = local_port;
176 } else if(state == TIME_WAIT) {
177 TCP_REG(&tcp_tw_pcbs, pcb);
178 ip_addr_copy(pcb->local_ip, *local_ip);
179 pcb->local_port = local_port;
180 ip_addr_copy(pcb->remote_ip, *remote_ip);
181 pcb->remote_port = remote_port;
182 } else {
183 fail();
184 }
185 }
186
187 void
test_tcp_counters_err(void * arg,err_t err)188 test_tcp_counters_err(void* arg, err_t err)
189 {
190 struct test_tcp_counters* counters = (struct test_tcp_counters*)arg;
191 EXPECT_RET(arg != NULL);
192 counters->err_calls++;
193 counters->last_err = err;
194 }
195
196 static void
test_tcp_counters_check_rxdata(struct test_tcp_counters * counters,struct pbuf * p)197 test_tcp_counters_check_rxdata(struct test_tcp_counters* counters, struct pbuf* p)
198 {
199 struct pbuf* q;
200 u32_t i, received;
201 if(counters->expected_data == NULL) {
202 /* no data to compare */
203 return;
204 }
205 EXPECT_RET(counters->recved_bytes + p->tot_len <= counters->expected_data_len);
206 received = counters->recved_bytes;
207 for(q = p; q != NULL; q = q->next) {
208 char *data = (char*)q->payload;
209 for(i = 0; i < q->len; i++) {
210 EXPECT_RET(data[i] == counters->expected_data[received]);
211 received++;
212 }
213 }
214 EXPECT(received == counters->recved_bytes + p->tot_len);
215 }
216
217 err_t
test_tcp_counters_recv(void * arg,struct tcp_pcb * pcb,struct pbuf * p,err_t err)218 test_tcp_counters_recv(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
219 {
220 struct test_tcp_counters* counters = (struct test_tcp_counters*)arg;
221 EXPECT_RETX(arg != NULL, ERR_OK);
222 EXPECT_RETX(pcb != NULL, ERR_OK);
223 EXPECT_RETX(err == ERR_OK, ERR_OK);
224
225 if (p != NULL) {
226 if (counters->close_calls == 0) {
227 counters->recv_calls++;
228 test_tcp_counters_check_rxdata(counters, p);
229 counters->recved_bytes += p->tot_len;
230 } else {
231 counters->recv_calls_after_close++;
232 counters->recved_bytes_after_close += p->tot_len;
233 }
234 pbuf_free(p);
235 } else {
236 counters->close_calls++;
237 }
238 EXPECT(counters->recv_calls_after_close == 0 && counters->recved_bytes_after_close == 0);
239 return ERR_OK;
240 }
241
242 /** Allocate a pcb and set up the test_tcp_counters_* callbacks */
243 struct tcp_pcb*
test_tcp_new_counters_pcb(struct test_tcp_counters * counters)244 test_tcp_new_counters_pcb(struct test_tcp_counters* counters)
245 {
246 struct tcp_pcb* pcb = tcp_new();
247 if (pcb != NULL) {
248 /* set up args and callbacks */
249 tcp_arg(pcb, counters);
250 tcp_recv(pcb, test_tcp_counters_recv);
251 tcp_err(pcb, test_tcp_counters_err);
252 pcb->snd_wnd = TCP_WND;
253 pcb->snd_wnd_max = TCP_WND;
254 }
255 return pcb;
256 }
257
258 /** Calls tcp_input() after adjusting current_iphdr_dest */
test_tcp_input(struct pbuf * p,struct netif * inp)259 void test_tcp_input(struct pbuf *p, struct netif *inp)
260 {
261 struct ip_hdr *iphdr = (struct ip_hdr*)p->payload;
262 /* these lines are a hack, don't use them as an example :-) */
263 ip_addr_copy_from_ip4(*ip_current_dest_addr(), iphdr->dest);
264 ip_addr_copy_from_ip4(*ip_current_src_addr(), iphdr->src);
265 ip_current_netif() = inp;
266 ip_data.current_ip4_header = iphdr;
267 ip_data.current_input_netif = inp;
268
269 /* since adding IPv6, p->payload must point to tcp header, not ip header */
270 pbuf_header(p, -(s16_t)sizeof(struct ip_hdr));
271
272 tcp_input(p, inp);
273
274 ip_addr_set_zero(ip_current_dest_addr());
275 ip_addr_set_zero(ip_current_src_addr());
276 ip_current_netif() = NULL;
277 ip_data.current_ip4_header = NULL;
278 }
279
test_tcp_netif_output(struct netif * netif,struct pbuf * p,const ip4_addr_t * ipaddr)280 static err_t test_tcp_netif_output(struct netif *netif, struct pbuf *p,
281 const ip4_addr_t *ipaddr)
282 {
283 struct test_tcp_txcounters *txcounters = (struct test_tcp_txcounters*)netif->state;
284 LWIP_UNUSED_ARG(ipaddr);
285 if (txcounters != NULL)
286 {
287 txcounters->num_tx_calls++;
288 txcounters->num_tx_bytes += p->tot_len;
289 if (txcounters->copy_tx_packets) {
290 struct pbuf *p_copy = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM);
291 err_t err;
292 EXPECT(p_copy != NULL);
293 err = pbuf_copy(p_copy, p);
294 EXPECT(err == ERR_OK);
295 if (txcounters->tx_packets == NULL) {
296 txcounters->tx_packets = p_copy;
297 } else {
298 pbuf_cat(txcounters->tx_packets, p_copy);
299 }
300 }
301 }
302 return ERR_OK;
303 }
304
test_tcp_init_netif(struct netif * netif,struct test_tcp_txcounters * txcounters,const ip_addr_t * ip_addr,const ip_addr_t * netmask)305 void test_tcp_init_netif(struct netif *netif, struct test_tcp_txcounters *txcounters,
306 const ip_addr_t *ip_addr, const ip_addr_t *netmask)
307 {
308 struct netif *n;
309 memset(netif, 0, sizeof(struct netif));
310 if (txcounters != NULL) {
311 memset(txcounters, 0, sizeof(struct test_tcp_txcounters));
312 netif->state = txcounters;
313 }
314 netif->output = test_tcp_netif_output;
315 netif->flags |= NETIF_FLAG_UP | NETIF_FLAG_LINK_UP;
316 ip_addr_copy_from_ip4(netif->netmask, *ip_2_ip4(netmask));
317 ip_addr_copy_from_ip4(netif->ip_addr, *ip_2_ip4(ip_addr));
318 for (n = netif_list; n != NULL; n = n->next) {
319 if (n == netif) {
320 return;
321 }
322 }
323 netif->next = NULL;
324 netif_list = netif;
325 }
326