1*10465441SEvalZero /**
2*10465441SEvalZero * @file
3*10465441SEvalZero * lwIP iPerf server implementation
4*10465441SEvalZero */
5*10465441SEvalZero
6*10465441SEvalZero /**
7*10465441SEvalZero * @defgroup iperf Iperf server
8*10465441SEvalZero * @ingroup apps
9*10465441SEvalZero *
10*10465441SEvalZero * This is a simple performance measuring server to check your bandwith using
11*10465441SEvalZero * iPerf2 on a PC as client.
12*10465441SEvalZero * It is currently a minimal implementation providing an IPv4 TCP server only.
13*10465441SEvalZero *
14*10465441SEvalZero * @todo: implement UDP mode and IPv6
15*10465441SEvalZero */
16*10465441SEvalZero
17*10465441SEvalZero /*
18*10465441SEvalZero * Copyright (c) 2014 Simon Goldschmidt
19*10465441SEvalZero * All rights reserved.
20*10465441SEvalZero *
21*10465441SEvalZero * Redistribution and use in source and binary forms, with or without modification,
22*10465441SEvalZero * are permitted provided that the following conditions are met:
23*10465441SEvalZero *
24*10465441SEvalZero * 1. Redistributions of source code must retain the above copyright notice,
25*10465441SEvalZero * this list of conditions and the following disclaimer.
26*10465441SEvalZero * 2. Redistributions in binary form must reproduce the above copyright notice,
27*10465441SEvalZero * this list of conditions and the following disclaimer in the documentation
28*10465441SEvalZero * and/or other materials provided with the distribution.
29*10465441SEvalZero * 3. The name of the author may not be used to endorse or promote products
30*10465441SEvalZero * derived from this software without specific prior written permission.
31*10465441SEvalZero *
32*10465441SEvalZero * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
33*10465441SEvalZero * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
34*10465441SEvalZero * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
35*10465441SEvalZero * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
36*10465441SEvalZero * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
37*10465441SEvalZero * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
38*10465441SEvalZero * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
39*10465441SEvalZero * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40*10465441SEvalZero * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
41*10465441SEvalZero * OF SUCH DAMAGE.
42*10465441SEvalZero *
43*10465441SEvalZero * This file is part of the lwIP TCP/IP stack.
44*10465441SEvalZero *
45*10465441SEvalZero * Author: Simon Goldschmidt
46*10465441SEvalZero */
47*10465441SEvalZero
48*10465441SEvalZero #include "lwip/apps/lwiperf.h"
49*10465441SEvalZero
50*10465441SEvalZero #include "lwip/tcp.h"
51*10465441SEvalZero #include "lwip/sys.h"
52*10465441SEvalZero
53*10465441SEvalZero #include <string.h>
54*10465441SEvalZero
55*10465441SEvalZero /* Currently, only TCP-over-IPv4 is implemented (does iperf support IPv6 anyway?) */
56*10465441SEvalZero #if LWIP_IPV4 && LWIP_TCP && LWIP_CALLBACK_API
57*10465441SEvalZero
58*10465441SEvalZero /** Specify the idle timeout (in seconds) after that the test fails */
59*10465441SEvalZero #ifndef LWIPERF_TCP_MAX_IDLE_SEC
60*10465441SEvalZero #define LWIPERF_TCP_MAX_IDLE_SEC 10U
61*10465441SEvalZero #endif
62*10465441SEvalZero #if LWIPERF_TCP_MAX_IDLE_SEC > 255
63*10465441SEvalZero #error LWIPERF_TCP_MAX_IDLE_SEC must fit into an u8_t
64*10465441SEvalZero #endif
65*10465441SEvalZero
66*10465441SEvalZero /* File internal memory allocation (struct lwiperf_*): this defaults to
67*10465441SEvalZero the heap */
68*10465441SEvalZero #ifndef LWIPERF_ALLOC
69*10465441SEvalZero #define LWIPERF_ALLOC(type) mem_malloc(sizeof(type))
70*10465441SEvalZero #define LWIPERF_FREE(type, item) mem_free(item)
71*10465441SEvalZero #endif
72*10465441SEvalZero
73*10465441SEvalZero /** If this is 1, check that received data has the correct format */
74*10465441SEvalZero #ifndef LWIPERF_CHECK_RX_DATA
75*10465441SEvalZero #define LWIPERF_CHECK_RX_DATA 0
76*10465441SEvalZero #endif
77*10465441SEvalZero
78*10465441SEvalZero /** This is the Iperf settings struct sent from the client */
79*10465441SEvalZero typedef struct _lwiperf_settings {
80*10465441SEvalZero #define LWIPERF_FLAGS_ANSWER_TEST 0x80000000
81*10465441SEvalZero #define LWIPERF_FLAGS_ANSWER_NOW 0x00000001
82*10465441SEvalZero u32_t flags;
83*10465441SEvalZero u32_t num_threads; /* unused for now */
84*10465441SEvalZero u32_t remote_port;
85*10465441SEvalZero u32_t buffer_len; /* unused for now */
86*10465441SEvalZero u32_t win_band; /* TCP window / UDP rate: unused for now */
87*10465441SEvalZero u32_t amount; /* pos. value: bytes?; neg. values: time (unit is 10ms: 1/100 second) */
88*10465441SEvalZero } lwiperf_settings_t;
89*10465441SEvalZero
90*10465441SEvalZero /** Basic connection handle */
91*10465441SEvalZero struct _lwiperf_state_base;
92*10465441SEvalZero typedef struct _lwiperf_state_base lwiperf_state_base_t;
93*10465441SEvalZero struct _lwiperf_state_base {
94*10465441SEvalZero /* 1=tcp, 0=udp */
95*10465441SEvalZero u8_t tcp;
96*10465441SEvalZero /* 1=server, 0=client */
97*10465441SEvalZero u8_t server;
98*10465441SEvalZero lwiperf_state_base_t* next;
99*10465441SEvalZero lwiperf_state_base_t* related_server_state;
100*10465441SEvalZero };
101*10465441SEvalZero
102*10465441SEvalZero /** Connection handle for a TCP iperf session */
103*10465441SEvalZero typedef struct _lwiperf_state_tcp {
104*10465441SEvalZero lwiperf_state_base_t base;
105*10465441SEvalZero struct tcp_pcb* server_pcb;
106*10465441SEvalZero struct tcp_pcb* conn_pcb;
107*10465441SEvalZero u32_t time_started;
108*10465441SEvalZero lwiperf_report_fn report_fn;
109*10465441SEvalZero void* report_arg;
110*10465441SEvalZero u8_t poll_count;
111*10465441SEvalZero u8_t next_num;
112*10465441SEvalZero u32_t bytes_transferred;
113*10465441SEvalZero lwiperf_settings_t settings;
114*10465441SEvalZero u8_t have_settings_buf;
115*10465441SEvalZero } lwiperf_state_tcp_t;
116*10465441SEvalZero
117*10465441SEvalZero /** List of active iperf sessions */
118*10465441SEvalZero static lwiperf_state_base_t* lwiperf_all_connections;
119*10465441SEvalZero /** A const buffer to send from: we want to measure sending, not copying! */
120*10465441SEvalZero static const u8_t lwiperf_txbuf_const[1600] = {
121*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
122*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
123*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
124*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
125*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
126*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
127*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
128*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
129*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
130*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
131*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
132*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
133*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
134*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
135*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
136*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
137*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
138*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
139*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
140*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
141*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
142*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
143*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
144*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
145*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
146*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
147*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
148*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
149*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
150*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
151*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
152*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
153*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
154*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
155*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
156*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
157*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
158*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
159*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
160*10465441SEvalZero '0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9',
161*10465441SEvalZero };
162*10465441SEvalZero
163*10465441SEvalZero static err_t lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb);
164*10465441SEvalZero static void lwiperf_tcp_err(void *arg, err_t err);
165*10465441SEvalZero
166*10465441SEvalZero /** Add an iperf session to the 'active' list */
167*10465441SEvalZero static void
lwiperf_list_add(lwiperf_state_base_t * item)168*10465441SEvalZero lwiperf_list_add(lwiperf_state_base_t* item)
169*10465441SEvalZero {
170*10465441SEvalZero if (lwiperf_all_connections == NULL) {
171*10465441SEvalZero lwiperf_all_connections = item;
172*10465441SEvalZero } else {
173*10465441SEvalZero item = lwiperf_all_connections;
174*10465441SEvalZero }
175*10465441SEvalZero }
176*10465441SEvalZero
177*10465441SEvalZero /** Remove an iperf session from the 'active' list */
178*10465441SEvalZero static void
lwiperf_list_remove(lwiperf_state_base_t * item)179*10465441SEvalZero lwiperf_list_remove(lwiperf_state_base_t* item)
180*10465441SEvalZero {
181*10465441SEvalZero lwiperf_state_base_t* prev = NULL;
182*10465441SEvalZero lwiperf_state_base_t* iter;
183*10465441SEvalZero for (iter = lwiperf_all_connections; iter != NULL; prev = iter, iter = iter->next) {
184*10465441SEvalZero if (iter == item) {
185*10465441SEvalZero if (prev == NULL) {
186*10465441SEvalZero lwiperf_all_connections = iter->next;
187*10465441SEvalZero } else {
188*10465441SEvalZero prev->next = item;
189*10465441SEvalZero }
190*10465441SEvalZero /* @debug: ensure this item is listed only once */
191*10465441SEvalZero for (iter = iter->next; iter != NULL; iter = iter->next) {
192*10465441SEvalZero LWIP_ASSERT("duplicate entry", iter != item);
193*10465441SEvalZero }
194*10465441SEvalZero break;
195*10465441SEvalZero }
196*10465441SEvalZero }
197*10465441SEvalZero }
198*10465441SEvalZero
199*10465441SEvalZero /** Call the report function of an iperf tcp session */
200*10465441SEvalZero static void
lwip_tcp_conn_report(lwiperf_state_tcp_t * conn,enum lwiperf_report_type report_type)201*10465441SEvalZero lwip_tcp_conn_report(lwiperf_state_tcp_t* conn, enum lwiperf_report_type report_type)
202*10465441SEvalZero {
203*10465441SEvalZero if ((conn != NULL) && (conn->report_fn != NULL)) {
204*10465441SEvalZero u32_t now, duration_ms, bandwidth_kbitpsec;
205*10465441SEvalZero now = sys_now();
206*10465441SEvalZero duration_ms = now - conn->time_started;
207*10465441SEvalZero if (duration_ms == 0) {
208*10465441SEvalZero bandwidth_kbitpsec = 0;
209*10465441SEvalZero } else {
210*10465441SEvalZero bandwidth_kbitpsec = (conn->bytes_transferred / duration_ms) * 8U;
211*10465441SEvalZero }
212*10465441SEvalZero conn->report_fn(conn->report_arg, report_type,
213*10465441SEvalZero &conn->conn_pcb->local_ip, conn->conn_pcb->local_port,
214*10465441SEvalZero &conn->conn_pcb->remote_ip, conn->conn_pcb->remote_port,
215*10465441SEvalZero conn->bytes_transferred, duration_ms, bandwidth_kbitpsec);
216*10465441SEvalZero }
217*10465441SEvalZero }
218*10465441SEvalZero
219*10465441SEvalZero /** Close an iperf tcp session */
220*10465441SEvalZero static void
lwiperf_tcp_close(lwiperf_state_tcp_t * conn,enum lwiperf_report_type report_type)221*10465441SEvalZero lwiperf_tcp_close(lwiperf_state_tcp_t* conn, enum lwiperf_report_type report_type)
222*10465441SEvalZero {
223*10465441SEvalZero err_t err;
224*10465441SEvalZero
225*10465441SEvalZero lwip_tcp_conn_report(conn, report_type);
226*10465441SEvalZero lwiperf_list_remove(&conn->base);
227*10465441SEvalZero if (conn->conn_pcb != NULL) {
228*10465441SEvalZero tcp_arg(conn->conn_pcb, NULL);
229*10465441SEvalZero tcp_poll(conn->conn_pcb, NULL, 0);
230*10465441SEvalZero tcp_sent(conn->conn_pcb, NULL);
231*10465441SEvalZero tcp_recv(conn->conn_pcb, NULL);
232*10465441SEvalZero tcp_err(conn->conn_pcb, NULL);
233*10465441SEvalZero err = tcp_close(conn->conn_pcb);
234*10465441SEvalZero if (err != ERR_OK) {
235*10465441SEvalZero /* don't want to wait for free memory here... */
236*10465441SEvalZero tcp_abort(conn->conn_pcb);
237*10465441SEvalZero }
238*10465441SEvalZero } else {
239*10465441SEvalZero /* no conn pcb, this is the server pcb */
240*10465441SEvalZero err = tcp_close(conn->server_pcb);
241*10465441SEvalZero LWIP_ASSERT("error", err != ERR_OK);
242*10465441SEvalZero }
243*10465441SEvalZero LWIPERF_FREE(lwiperf_state_tcp_t, conn);
244*10465441SEvalZero }
245*10465441SEvalZero
246*10465441SEvalZero /** Try to send more data on an iperf tcp session */
247*10465441SEvalZero static err_t
lwiperf_tcp_client_send_more(lwiperf_state_tcp_t * conn)248*10465441SEvalZero lwiperf_tcp_client_send_more(lwiperf_state_tcp_t* conn)
249*10465441SEvalZero {
250*10465441SEvalZero int send_more;
251*10465441SEvalZero err_t err;
252*10465441SEvalZero u16_t txlen;
253*10465441SEvalZero u16_t txlen_max;
254*10465441SEvalZero void* txptr;
255*10465441SEvalZero u8_t apiflags;
256*10465441SEvalZero
257*10465441SEvalZero LWIP_ASSERT("conn invalid", (conn != NULL) && conn->base.tcp && (conn->base.server == 0));
258*10465441SEvalZero
259*10465441SEvalZero do {
260*10465441SEvalZero send_more = 0;
261*10465441SEvalZero if (conn->settings.amount & PP_HTONL(0x80000000)) {
262*10465441SEvalZero /* this session is time-limited */
263*10465441SEvalZero u32_t now = sys_now();
264*10465441SEvalZero u32_t diff_ms = now - conn->time_started;
265*10465441SEvalZero u32_t time = (u32_t)-(s32_t)lwip_htonl(conn->settings.amount);
266*10465441SEvalZero u32_t time_ms = time * 10;
267*10465441SEvalZero if (diff_ms >= time_ms) {
268*10465441SEvalZero /* time specified by the client is over -> close the connection */
269*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT);
270*10465441SEvalZero return ERR_OK;
271*10465441SEvalZero }
272*10465441SEvalZero } else {
273*10465441SEvalZero /* this session is byte-limited */
274*10465441SEvalZero u32_t amount_bytes = lwip_htonl(conn->settings.amount);
275*10465441SEvalZero /* @todo: this can send up to 1*MSS more than requested... */
276*10465441SEvalZero if (amount_bytes >= conn->bytes_transferred) {
277*10465441SEvalZero /* all requested bytes transferred -> close the connection */
278*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT);
279*10465441SEvalZero return ERR_OK;
280*10465441SEvalZero }
281*10465441SEvalZero }
282*10465441SEvalZero
283*10465441SEvalZero if (conn->bytes_transferred < 24) {
284*10465441SEvalZero /* transmit the settings a first time */
285*10465441SEvalZero txptr = &((u8_t*)&conn->settings)[conn->bytes_transferred];
286*10465441SEvalZero txlen_max = (u16_t)(24 - conn->bytes_transferred);
287*10465441SEvalZero apiflags = TCP_WRITE_FLAG_COPY;
288*10465441SEvalZero } else if (conn->bytes_transferred < 48) {
289*10465441SEvalZero /* transmit the settings a second time */
290*10465441SEvalZero txptr = &((u8_t*)&conn->settings)[conn->bytes_transferred - 24];
291*10465441SEvalZero txlen_max = (u16_t)(48 - conn->bytes_transferred);
292*10465441SEvalZero apiflags = TCP_WRITE_FLAG_COPY | TCP_WRITE_FLAG_MORE;
293*10465441SEvalZero send_more = 1;
294*10465441SEvalZero } else {
295*10465441SEvalZero /* transmit data */
296*10465441SEvalZero /* @todo: every x bytes, transmit the settings again */
297*10465441SEvalZero txptr = LWIP_CONST_CAST(void*, &lwiperf_txbuf_const[conn->bytes_transferred % 10]);
298*10465441SEvalZero txlen_max = TCP_MSS;
299*10465441SEvalZero if (conn->bytes_transferred == 48) { /* @todo: fix this for intermediate settings, too */
300*10465441SEvalZero txlen_max = TCP_MSS - 24;
301*10465441SEvalZero }
302*10465441SEvalZero apiflags = 0; /* no copying needed */
303*10465441SEvalZero send_more = 1;
304*10465441SEvalZero }
305*10465441SEvalZero txlen = txlen_max;
306*10465441SEvalZero do {
307*10465441SEvalZero err = tcp_write(conn->conn_pcb, txptr, txlen, apiflags);
308*10465441SEvalZero if (err == ERR_MEM) {
309*10465441SEvalZero txlen /= 2;
310*10465441SEvalZero }
311*10465441SEvalZero } while ((err == ERR_MEM) && (txlen >= (TCP_MSS/2)));
312*10465441SEvalZero
313*10465441SEvalZero if (err == ERR_OK) {
314*10465441SEvalZero conn->bytes_transferred += txlen;
315*10465441SEvalZero } else {
316*10465441SEvalZero send_more = 0;
317*10465441SEvalZero }
318*10465441SEvalZero } while(send_more);
319*10465441SEvalZero
320*10465441SEvalZero tcp_output(conn->conn_pcb);
321*10465441SEvalZero return ERR_OK;
322*10465441SEvalZero }
323*10465441SEvalZero
324*10465441SEvalZero /** TCP sent callback, try to send more data */
325*10465441SEvalZero static err_t
lwiperf_tcp_client_sent(void * arg,struct tcp_pcb * tpcb,u16_t len)326*10465441SEvalZero lwiperf_tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
327*10465441SEvalZero {
328*10465441SEvalZero lwiperf_state_tcp_t* conn = (lwiperf_state_tcp_t*)arg;
329*10465441SEvalZero /* @todo: check 'len' (e.g. to time ACK of all data)? for now, we just send more... */
330*10465441SEvalZero LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb);
331*10465441SEvalZero LWIP_UNUSED_ARG(tpcb);
332*10465441SEvalZero LWIP_UNUSED_ARG(len);
333*10465441SEvalZero
334*10465441SEvalZero conn->poll_count = 0;
335*10465441SEvalZero
336*10465441SEvalZero return lwiperf_tcp_client_send_more(conn);
337*10465441SEvalZero }
338*10465441SEvalZero
339*10465441SEvalZero /** TCP connected callback (active connection), send data now */
340*10465441SEvalZero static err_t
lwiperf_tcp_client_connected(void * arg,struct tcp_pcb * tpcb,err_t err)341*10465441SEvalZero lwiperf_tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err)
342*10465441SEvalZero {
343*10465441SEvalZero lwiperf_state_tcp_t* conn = (lwiperf_state_tcp_t*)arg;
344*10465441SEvalZero LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb);
345*10465441SEvalZero LWIP_UNUSED_ARG(tpcb);
346*10465441SEvalZero if (err != ERR_OK) {
347*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE);
348*10465441SEvalZero return ERR_OK;
349*10465441SEvalZero }
350*10465441SEvalZero conn->poll_count = 0;
351*10465441SEvalZero conn->time_started = sys_now();
352*10465441SEvalZero return lwiperf_tcp_client_send_more(conn);
353*10465441SEvalZero }
354*10465441SEvalZero
355*10465441SEvalZero /** Start TCP connection back to the client (either parallel or after the
356*10465441SEvalZero * receive test has finished.
357*10465441SEvalZero */
358*10465441SEvalZero static err_t
lwiperf_tx_start(lwiperf_state_tcp_t * conn)359*10465441SEvalZero lwiperf_tx_start(lwiperf_state_tcp_t* conn)
360*10465441SEvalZero {
361*10465441SEvalZero err_t err;
362*10465441SEvalZero lwiperf_state_tcp_t* client_conn;
363*10465441SEvalZero struct tcp_pcb* newpcb;
364*10465441SEvalZero ip_addr_t remote_addr;
365*10465441SEvalZero u16_t remote_port;
366*10465441SEvalZero
367*10465441SEvalZero client_conn = (lwiperf_state_tcp_t*)LWIPERF_ALLOC(lwiperf_state_tcp_t);
368*10465441SEvalZero if (client_conn == NULL) {
369*10465441SEvalZero return ERR_MEM;
370*10465441SEvalZero }
371*10465441SEvalZero newpcb = tcp_new();
372*10465441SEvalZero if (newpcb == NULL) {
373*10465441SEvalZero LWIPERF_FREE(lwiperf_state_tcp_t, client_conn);
374*10465441SEvalZero return ERR_MEM;
375*10465441SEvalZero }
376*10465441SEvalZero
377*10465441SEvalZero MEMCPY(client_conn, conn, sizeof(lwiperf_state_tcp_t));
378*10465441SEvalZero client_conn->base.server = 0;
379*10465441SEvalZero client_conn->server_pcb = NULL;
380*10465441SEvalZero client_conn->conn_pcb = newpcb;
381*10465441SEvalZero client_conn->time_started = sys_now(); /* @todo: set this again on 'connected' */
382*10465441SEvalZero client_conn->poll_count = 0;
383*10465441SEvalZero client_conn->next_num = 4; /* initial nr is '4' since the header has 24 byte */
384*10465441SEvalZero client_conn->bytes_transferred = 0;
385*10465441SEvalZero client_conn->settings.flags = 0; /* prevent the remote side starting back as client again */
386*10465441SEvalZero
387*10465441SEvalZero tcp_arg(newpcb, client_conn);
388*10465441SEvalZero tcp_sent(newpcb, lwiperf_tcp_client_sent);
389*10465441SEvalZero tcp_poll(newpcb, lwiperf_tcp_poll, 2U);
390*10465441SEvalZero tcp_err(newpcb, lwiperf_tcp_err);
391*10465441SEvalZero
392*10465441SEvalZero ip_addr_copy(remote_addr, conn->conn_pcb->remote_ip);
393*10465441SEvalZero remote_port = (u16_t)lwip_htonl(client_conn->settings.remote_port);
394*10465441SEvalZero
395*10465441SEvalZero err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected);
396*10465441SEvalZero if (err != ERR_OK) {
397*10465441SEvalZero lwiperf_tcp_close(client_conn, LWIPERF_TCP_ABORTED_LOCAL);
398*10465441SEvalZero return err;
399*10465441SEvalZero }
400*10465441SEvalZero lwiperf_list_add(&client_conn->base);
401*10465441SEvalZero return ERR_OK;
402*10465441SEvalZero }
403*10465441SEvalZero
404*10465441SEvalZero /** Receive data on an iperf tcp session */
405*10465441SEvalZero static err_t
lwiperf_tcp_recv(void * arg,struct tcp_pcb * tpcb,struct pbuf * p,err_t err)406*10465441SEvalZero lwiperf_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
407*10465441SEvalZero {
408*10465441SEvalZero u8_t tmp;
409*10465441SEvalZero u16_t tot_len;
410*10465441SEvalZero u32_t packet_idx;
411*10465441SEvalZero struct pbuf* q;
412*10465441SEvalZero lwiperf_state_tcp_t* conn = (lwiperf_state_tcp_t*)arg;
413*10465441SEvalZero
414*10465441SEvalZero LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb);
415*10465441SEvalZero LWIP_UNUSED_ARG(tpcb);
416*10465441SEvalZero
417*10465441SEvalZero if (err != ERR_OK) {
418*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE);
419*10465441SEvalZero return ERR_OK;
420*10465441SEvalZero }
421*10465441SEvalZero if (p == NULL) {
422*10465441SEvalZero /* connection closed -> test done */
423*10465441SEvalZero if ((conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST|LWIPERF_FLAGS_ANSWER_NOW)) ==
424*10465441SEvalZero PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) {
425*10465441SEvalZero /* client requested transmission after end of test */
426*10465441SEvalZero lwiperf_tx_start(conn);
427*10465441SEvalZero }
428*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_SERVER);
429*10465441SEvalZero return ERR_OK;
430*10465441SEvalZero }
431*10465441SEvalZero tot_len = p->tot_len;
432*10465441SEvalZero
433*10465441SEvalZero conn->poll_count = 0;
434*10465441SEvalZero
435*10465441SEvalZero if ((!conn->have_settings_buf) || ((conn->bytes_transferred -24) % (1024*128) == 0)) {
436*10465441SEvalZero /* wait for 24-byte header */
437*10465441SEvalZero if (p->tot_len < sizeof(lwiperf_settings_t)) {
438*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR);
439*10465441SEvalZero pbuf_free(p);
440*10465441SEvalZero return ERR_VAL;
441*10465441SEvalZero }
442*10465441SEvalZero if (!conn->have_settings_buf) {
443*10465441SEvalZero if (pbuf_copy_partial(p, &conn->settings, sizeof(lwiperf_settings_t), 0) != sizeof(lwiperf_settings_t)) {
444*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL);
445*10465441SEvalZero pbuf_free(p);
446*10465441SEvalZero return ERR_VAL;
447*10465441SEvalZero }
448*10465441SEvalZero conn->have_settings_buf = 1;
449*10465441SEvalZero if ((conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST|LWIPERF_FLAGS_ANSWER_NOW)) ==
450*10465441SEvalZero PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST|LWIPERF_FLAGS_ANSWER_NOW)) {
451*10465441SEvalZero /* client requested parallel transmission test */
452*10465441SEvalZero err_t err2 = lwiperf_tx_start(conn);
453*10465441SEvalZero if (err2 != ERR_OK) {
454*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_TXERROR);
455*10465441SEvalZero pbuf_free(p);
456*10465441SEvalZero return err2;
457*10465441SEvalZero }
458*10465441SEvalZero }
459*10465441SEvalZero } else {
460*10465441SEvalZero if (pbuf_memcmp(p, 0, &conn->settings, sizeof(lwiperf_settings_t)) != 0) {
461*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR);
462*10465441SEvalZero pbuf_free(p);
463*10465441SEvalZero return ERR_VAL;
464*10465441SEvalZero }
465*10465441SEvalZero }
466*10465441SEvalZero conn->bytes_transferred += sizeof(lwiperf_settings_t);
467*10465441SEvalZero if (conn->bytes_transferred <= 24) {
468*10465441SEvalZero conn->time_started = sys_now();
469*10465441SEvalZero tcp_recved(tpcb, p->tot_len);
470*10465441SEvalZero pbuf_free(p);
471*10465441SEvalZero return ERR_OK;
472*10465441SEvalZero }
473*10465441SEvalZero conn->next_num = 4; /* 24 bytes received... */
474*10465441SEvalZero tmp = pbuf_header(p, -24);
475*10465441SEvalZero LWIP_ASSERT("pbuf_header failed", tmp == 0);
476*10465441SEvalZero }
477*10465441SEvalZero
478*10465441SEvalZero packet_idx = 0;
479*10465441SEvalZero for (q = p; q != NULL; q = q->next) {
480*10465441SEvalZero #if LWIPERF_CHECK_RX_DATA
481*10465441SEvalZero const u8_t* payload = (const u8_t*)q->payload;
482*10465441SEvalZero u16_t i;
483*10465441SEvalZero for (i = 0; i < q->len; i++) {
484*10465441SEvalZero u8_t val = payload[i];
485*10465441SEvalZero u8_t num = val - '0';
486*10465441SEvalZero if (num == conn->next_num) {
487*10465441SEvalZero conn->next_num++;
488*10465441SEvalZero if (conn->next_num == 10) {
489*10465441SEvalZero conn->next_num = 0;
490*10465441SEvalZero }
491*10465441SEvalZero } else {
492*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR);
493*10465441SEvalZero pbuf_free(p);
494*10465441SEvalZero return ERR_VAL;
495*10465441SEvalZero }
496*10465441SEvalZero }
497*10465441SEvalZero #endif
498*10465441SEvalZero packet_idx += q->len;
499*10465441SEvalZero }
500*10465441SEvalZero LWIP_ASSERT("count mismatch", packet_idx == p->tot_len);
501*10465441SEvalZero conn->bytes_transferred += packet_idx;
502*10465441SEvalZero tcp_recved(tpcb, tot_len);
503*10465441SEvalZero pbuf_free(p);
504*10465441SEvalZero return ERR_OK;
505*10465441SEvalZero }
506*10465441SEvalZero
507*10465441SEvalZero /** Error callback, iperf tcp session aborted */
508*10465441SEvalZero static void
lwiperf_tcp_err(void * arg,err_t err)509*10465441SEvalZero lwiperf_tcp_err(void *arg, err_t err)
510*10465441SEvalZero {
511*10465441SEvalZero lwiperf_state_tcp_t* conn = (lwiperf_state_tcp_t*)arg;
512*10465441SEvalZero LWIP_UNUSED_ARG(err);
513*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE);
514*10465441SEvalZero }
515*10465441SEvalZero
516*10465441SEvalZero /** TCP poll callback, try to send more data */
517*10465441SEvalZero static err_t
lwiperf_tcp_poll(void * arg,struct tcp_pcb * tpcb)518*10465441SEvalZero lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb)
519*10465441SEvalZero {
520*10465441SEvalZero lwiperf_state_tcp_t* conn = (lwiperf_state_tcp_t*)arg;
521*10465441SEvalZero LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb);
522*10465441SEvalZero LWIP_UNUSED_ARG(tpcb);
523*10465441SEvalZero if (++conn->poll_count >= LWIPERF_TCP_MAX_IDLE_SEC) {
524*10465441SEvalZero lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL);
525*10465441SEvalZero return ERR_OK; /* lwiperf_tcp_close frees conn */
526*10465441SEvalZero }
527*10465441SEvalZero
528*10465441SEvalZero if (!conn->base.server) {
529*10465441SEvalZero lwiperf_tcp_client_send_more(conn);
530*10465441SEvalZero }
531*10465441SEvalZero
532*10465441SEvalZero return ERR_OK;
533*10465441SEvalZero }
534*10465441SEvalZero
535*10465441SEvalZero /** This is called when a new client connects for an iperf tcp session */
536*10465441SEvalZero static err_t
lwiperf_tcp_accept(void * arg,struct tcp_pcb * newpcb,err_t err)537*10465441SEvalZero lwiperf_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
538*10465441SEvalZero {
539*10465441SEvalZero lwiperf_state_tcp_t *s, *conn;
540*10465441SEvalZero if ((err != ERR_OK) || (newpcb == NULL) || (arg == NULL)) {
541*10465441SEvalZero return ERR_VAL;
542*10465441SEvalZero }
543*10465441SEvalZero
544*10465441SEvalZero s = (lwiperf_state_tcp_t*)arg;
545*10465441SEvalZero conn = (lwiperf_state_tcp_t*)LWIPERF_ALLOC(lwiperf_state_tcp_t);
546*10465441SEvalZero if (conn == NULL) {
547*10465441SEvalZero return ERR_MEM;
548*10465441SEvalZero }
549*10465441SEvalZero memset(conn, 0, sizeof(lwiperf_state_tcp_t));
550*10465441SEvalZero conn->base.tcp = 1;
551*10465441SEvalZero conn->base.server = 1;
552*10465441SEvalZero conn->base.related_server_state = &s->base;
553*10465441SEvalZero conn->server_pcb = s->server_pcb;
554*10465441SEvalZero conn->conn_pcb = newpcb;
555*10465441SEvalZero conn->time_started = sys_now();
556*10465441SEvalZero conn->report_fn = s->report_fn;
557*10465441SEvalZero conn->report_arg = s->report_arg;
558*10465441SEvalZero
559*10465441SEvalZero /* setup the tcp rx connection */
560*10465441SEvalZero tcp_arg(newpcb, conn);
561*10465441SEvalZero tcp_recv(newpcb, lwiperf_tcp_recv);
562*10465441SEvalZero tcp_poll(newpcb, lwiperf_tcp_poll, 2U);
563*10465441SEvalZero tcp_err(conn->conn_pcb, lwiperf_tcp_err);
564*10465441SEvalZero
565*10465441SEvalZero lwiperf_list_add(&conn->base);
566*10465441SEvalZero return ERR_OK;
567*10465441SEvalZero }
568*10465441SEvalZero
569*10465441SEvalZero /**
570*10465441SEvalZero * @ingroup iperf
571*10465441SEvalZero * Start a TCP iperf server on the default TCP port (5001) and listen for
572*10465441SEvalZero * incoming connections from iperf clients.
573*10465441SEvalZero *
574*10465441SEvalZero * @returns a connection handle that can be used to abort the server
575*10465441SEvalZero * by calling @ref lwiperf_abort()
576*10465441SEvalZero */
577*10465441SEvalZero void*
lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn,void * report_arg)578*10465441SEvalZero lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn, void* report_arg)
579*10465441SEvalZero {
580*10465441SEvalZero return lwiperf_start_tcp_server(IP_ADDR_ANY, LWIPERF_TCP_PORT_DEFAULT,
581*10465441SEvalZero report_fn, report_arg);
582*10465441SEvalZero }
583*10465441SEvalZero
584*10465441SEvalZero /**
585*10465441SEvalZero * @ingroup iperf
586*10465441SEvalZero * Start a TCP iperf server on a specific IP address and port and listen for
587*10465441SEvalZero * incoming connections from iperf clients.
588*10465441SEvalZero *
589*10465441SEvalZero * @returns a connection handle that can be used to abort the server
590*10465441SEvalZero * by calling @ref lwiperf_abort()
591*10465441SEvalZero */
592*10465441SEvalZero void*
lwiperf_start_tcp_server(const ip_addr_t * local_addr,u16_t local_port,lwiperf_report_fn report_fn,void * report_arg)593*10465441SEvalZero lwiperf_start_tcp_server(const ip_addr_t* local_addr, u16_t local_port,
594*10465441SEvalZero lwiperf_report_fn report_fn, void* report_arg)
595*10465441SEvalZero {
596*10465441SEvalZero err_t err;
597*10465441SEvalZero struct tcp_pcb* pcb;
598*10465441SEvalZero lwiperf_state_tcp_t* s;
599*10465441SEvalZero
600*10465441SEvalZero if (local_addr == NULL) {
601*10465441SEvalZero return NULL;
602*10465441SEvalZero }
603*10465441SEvalZero
604*10465441SEvalZero s = (lwiperf_state_tcp_t*)LWIPERF_ALLOC(lwiperf_state_tcp_t);
605*10465441SEvalZero if (s == NULL) {
606*10465441SEvalZero return NULL;
607*10465441SEvalZero }
608*10465441SEvalZero memset(s, 0, sizeof(lwiperf_state_tcp_t));
609*10465441SEvalZero s->base.tcp = 1;
610*10465441SEvalZero s->base.server = 1;
611*10465441SEvalZero s->report_fn = report_fn;
612*10465441SEvalZero s->report_arg = report_arg;
613*10465441SEvalZero
614*10465441SEvalZero pcb = tcp_new();
615*10465441SEvalZero if (pcb != NULL) {
616*10465441SEvalZero err = tcp_bind(pcb, local_addr, local_port);
617*10465441SEvalZero if (err == ERR_OK) {
618*10465441SEvalZero s->server_pcb = tcp_listen_with_backlog(pcb, 1);
619*10465441SEvalZero }
620*10465441SEvalZero }
621*10465441SEvalZero if (s->server_pcb == NULL) {
622*10465441SEvalZero if (pcb != NULL) {
623*10465441SEvalZero tcp_close(pcb);
624*10465441SEvalZero }
625*10465441SEvalZero LWIPERF_FREE(lwiperf_state_tcp_t, s);
626*10465441SEvalZero return NULL;
627*10465441SEvalZero }
628*10465441SEvalZero pcb = NULL;
629*10465441SEvalZero
630*10465441SEvalZero tcp_arg(s->server_pcb, s);
631*10465441SEvalZero tcp_accept(s->server_pcb, lwiperf_tcp_accept);
632*10465441SEvalZero
633*10465441SEvalZero lwiperf_list_add(&s->base);
634*10465441SEvalZero return s;
635*10465441SEvalZero }
636*10465441SEvalZero
637*10465441SEvalZero /**
638*10465441SEvalZero * @ingroup iperf
639*10465441SEvalZero * Abort an iperf session (handle returned by lwiperf_start_tcp_server*())
640*10465441SEvalZero */
641*10465441SEvalZero void
lwiperf_abort(void * lwiperf_session)642*10465441SEvalZero lwiperf_abort(void* lwiperf_session)
643*10465441SEvalZero {
644*10465441SEvalZero lwiperf_state_base_t* i, *dealloc, *last = NULL;
645*10465441SEvalZero
646*10465441SEvalZero for (i = lwiperf_all_connections; i != NULL; ) {
647*10465441SEvalZero if ((i == lwiperf_session) || (i->related_server_state == lwiperf_session)) {
648*10465441SEvalZero dealloc = i;
649*10465441SEvalZero i = i->next;
650*10465441SEvalZero if (last != NULL) {
651*10465441SEvalZero last->next = i;
652*10465441SEvalZero }
653*10465441SEvalZero LWIPERF_FREE(lwiperf_state_tcp_t, dealloc); /* @todo: type? */
654*10465441SEvalZero } else {
655*10465441SEvalZero last = i;
656*10465441SEvalZero i = i->next;
657*10465441SEvalZero }
658*10465441SEvalZero }
659*10465441SEvalZero }
660*10465441SEvalZero
661*10465441SEvalZero #endif /* LWIP_IPV4 && LWIP_TCP && LWIP_CALLBACK_API */
662