summaryrefslogtreecommitdiffstats
path: root/recipes-extended/xen/files/lwip.patch-cvs
diff options
context:
space:
mode:
authorChristopher Clark <christopher.w.clark@gmail.com>2019-04-16 13:35:36 -0700
committerBruce Ashfield <bruce.ashfield@gmail.com>2019-04-18 09:32:40 -0400
commit15caed2f436afd6ab07a0865b161c54f51bab6a4 (patch)
tree130ef8d75252d6e4aba6ef9ad50e4298eabcad62 /recipes-extended/xen/files/lwip.patch-cvs
parentabcdb5841dfffc1ff4410f6c149dc304d4ac5e42 (diff)
downloadmeta-virtualization-15caed2f436afd6ab07a0865b161c54f51bab6a4.tar.gz
xen: remove recipes for stubdoms and dependent components
Retiring these as the components are not in use and work on updating the recipes to build with the OE native tools rather than host tools has been discontinued. Signed-off-by: Christopher Clark <christopher.clark6@baesystems.com> Signed-off-by: Bruce Ashfield <bruce.ashfield@gmail.com>
Diffstat (limited to 'recipes-extended/xen/files/lwip.patch-cvs')
-rw-r--r--recipes-extended/xen/files/lwip.patch-cvs2398
1 files changed, 0 insertions, 2398 deletions
diff --git a/recipes-extended/xen/files/lwip.patch-cvs b/recipes-extended/xen/files/lwip.patch-cvs
deleted file mode 100644
index b2718778..00000000
--- a/recipes-extended/xen/files/lwip.patch-cvs
+++ /dev/null
@@ -1,2398 +0,0 @@
1? .ChangeLog.swp
2? ChangeLog
3Index: CHANGELOG
4===================================================================
5RCS file: /sources/lwip/lwip/CHANGELOG,v
6retrieving revision 1.300
7retrieving revision 1.318
8diff -u -p -r1.300 -r1.318
9--- a/CHANGELOG 23 Mar 2008 13:49:39 -0000 1.300
10+++ b/CHANGELOG 14 Jul 2008 20:12:36 -0000 1.318
11@@ -19,9 +19,77 @@ HISTORY
12
13 ++ New features:
14
15+ 2008-06-30 Simon Goldschmidt
16+ * mem.c, opt.h, stats.h: fixed bug #21433: Calling mem_free/pbuf_free from
17+ interrupt context isn't safe: LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT allows
18+ mem_free to run between mem_malloc iterations. Added illegal counter for
19+ mem stats.
20+
21+ 2008-06-27 Simon Goldschmidt
22+ * stats.h/.c, some other files: patch #6483: stats module improvement:
23+ Added defines to display each module's statistic individually, added stats
24+ defines for MEM, MEMP and SYS modules, removed (unused) rexmit counter.
25+
26+ 2008-06-17 Simon Goldschmidt
27+ * err.h: patch #6459: Made err_t overridable to use a more efficient type
28+ (define LWIP_ERR_T in cc.h)
29+
30+ 2008-06-17 Simon Goldschmidt
31+ * slipif.c: patch #6480: Added a configuration option for slipif for symmetry
32+ to loopif
33+
34+ 2008-06-17 Simon Goldschmidt (patch by Luca Ceresoli)
35+ * netif.c, loopif.c, ip.c, netif.h, loopif.h, opt.h: Checked in slightly
36+ modified version of patch # 6370: Moved loopif code to netif.c so that
37+ loopback traffic is supported on all netifs (all local IPs).
38+ Added option to limit loopback packets for each netifs.
39+
40
41 ++ Bugfixes:
42
43+ 2008-08-14 Simon Goldschmidt
44+ * api_msg.c: fixed bug #23847: do_close_internal references freed memory (when
45+ tcp_close returns != ERR_OK)
46+
47+ 2008-07-08 Frédéric Bernon
48+ * stats.h: Fix some build bugs introduced with patch #6483 (missing some parameters
49+ in macros, mainly if MEM_STATS=0 and MEMP_STATS=0).
50+
51+ 2008-06-24 Jonathan Larmour
52+ * tcp_in.c: Fix for bug #23693 as suggested by Art R. Ensure cseg is unused
53+ if tcp_seg_copy fails.
54+
55+ 2008-06-17 Simon Goldschmidt
56+ * inet_chksum.c: Checked in some ideas of patch #6460 (loop optimizations)
57+ and created defines for swapping bytes and folding u32 to u16.
58+
59+ 2008-05-30 Kieran Mansley
60+ * tcp_in.c Remove redundant "if" statement, and use real rcv_wnd
61+ rather than rcv_ann_wnd when deciding if packets are in-window.
62+ Contributed by <arasmussen@consultant.datasys.swri.edu>
63+
64+ 2008-05-30 Kieran Mansley
65+ * mem.h: Fix BUG#23254. Change macro definition of mem_* to allow
66+ passing as function pointers when MEM_LIBC_MALLOC is defined.
67+
68+ 2008-05-09 Jonathan Larmour
69+ * err.h, err.c, sockets.c: Fix bug #23119: Reorder timeout error code to
70+ stop it being treated as a fatal error.
71+
72+ 2008-04-15 Simon Goldschmidt
73+ * dhcp.c: fixed bug #22804: dhcp_stop doesn't clear NETIF_FLAG_DHCP
74+ (flag now cleared)
75+
76+ 2008-03-27 Simon Goldschmidt
77+ * mem.c, tcpip.c, tcpip.h, opt.h: fixed bug #21433 (Calling mem_free/pbuf_free
78+ from interrupt context isn't safe): set LWIP_USE_HEAP_FROM_INTERRUPT to 1
79+ in lwipopts.h or use pbuf_free_callback(p)/mem_free_callback(m) to free pbufs
80+ or heap memory from interrupt context
81+
82+ 2008-03-26 Simon Goldschmidt
83+ * tcp_in.c, tcp.c: fixed bug #22249: division by zero could occur if a remote
84+ host sent a zero mss as TCP option.
85+
86
87 (STABLE-1.3.0)
88
89Index: src/api/api_msg.c
90===================================================================
91RCS file: /sources/lwip/lwip/src/api/api_msg.c,v
92retrieving revision 1.102
93retrieving revision 1.104
94diff -u -p -r1.102 -r1.104
95--- a/src/api/api_msg.c 21 Mar 2008 16:23:14 -0000 1.102
96+++ b/src/api/api_msg.c 15 Jul 2008 11:18:58 -0000 1.104
97@@ -598,11 +598,16 @@ do_close_internal(struct netconn *conn)
98 LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL));
99
100 /* Set back some callback pointers */
101+ tcp_arg(conn->pcb.tcp, NULL);
102 if (conn->pcb.tcp->state == LISTEN) {
103- tcp_arg(conn->pcb.tcp, NULL);
104 tcp_accept(conn->pcb.tcp, NULL);
105 } else {
106 tcp_recv(conn->pcb.tcp, NULL);
107+ tcp_accept(conn->pcb.tcp, NULL);
108+ /* some callbacks have to be reset if tcp_close is not successful */
109+ tcp_sent(conn->pcb.tcp, NULL);
110+ tcp_poll(conn->pcb.tcp, NULL, 4);
111+ tcp_err(conn->pcb.tcp, NULL);
112 }
113 /* Try to close the connection */
114 err = tcp_close(conn->pcb.tcp);
115@@ -610,11 +615,6 @@ do_close_internal(struct netconn *conn)
116 /* Closing succeeded */
117 conn->state = NETCONN_NONE;
118 /* Set back some callback pointers as conn is going away */
119- tcp_err(conn->pcb.tcp, NULL);
120- tcp_poll(conn->pcb.tcp, NULL, 4);
121- tcp_sent(conn->pcb.tcp, NULL);
122- tcp_recv(conn->pcb.tcp, NULL);
123- tcp_arg(conn->pcb.tcp, NULL);
124 conn->pcb.tcp = NULL;
125 conn->err = ERR_OK;
126 /* Trigger select() in socket layer. This send should something else so the
127@@ -623,6 +623,14 @@ do_close_internal(struct netconn *conn)
128 API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0);
129 /* wake up the application task */
130 sys_sem_signal(conn->op_completed);
131+ } else {
132+ /* Closing failed, restore some of the callbacks */
133+ /* Closing of listen pcb will never fail! */
134+ LWIP_ASSERT("Closing a listen pcb may not fail!", (conn->pcb.tcp->state != LISTEN));
135+ tcp_sent(conn->pcb.tcp, sent_tcp);
136+ tcp_poll(conn->pcb.tcp, poll_tcp, 4);
137+ tcp_err(conn->pcb.tcp, err_tcp);
138+ tcp_arg(conn->pcb.tcp, conn);
139 }
140 /* If closing didn't succeed, we get called again either
141 from poll_tcp or from sent_tcp */
142Index: src/api/err.c
143===================================================================
144RCS file: /sources/lwip/lwip/src/api/err.c,v
145retrieving revision 1.11
146retrieving revision 1.12
147diff -u -p -r1.11 -r1.12
148--- a/src/api/err.c 13 Dec 2007 23:06:50 -0000 1.11
149+++ b/src/api/err.c 9 May 2008 12:14:23 -0000 1.12
150@@ -44,17 +44,17 @@ static const char *err_strerr[] = {
151 "Ok.", /* ERR_OK 0 */
152 "Out of memory error.", /* ERR_MEM -1 */
153 "Buffer error.", /* ERR_BUF -2 */
154- "Routing problem.", /* ERR_RTE -3 */
155- "Connection aborted.", /* ERR_ABRT -4 */
156- "Connection reset.", /* ERR_RST -5 */
157- "Connection closed.", /* ERR_CLSD -6 */
158- "Not connected.", /* ERR_CONN -7 */
159- "Illegal value.", /* ERR_VAL -8 */
160- "Illegal argument.", /* ERR_ARG -9 */
161- "Address in use.", /* ERR_USE -10 */
162- "Low-level netif error.", /* ERR_IF -11 */
163- "Already connected.", /* ERR_ISCONN -12 */
164- "Timeout.", /* ERR_TIMEOUT -13 */
165+ "Timeout.", /* ERR_TIMEOUT -3 */
166+ "Routing problem.", /* ERR_RTE -4 */
167+ "Connection aborted.", /* ERR_ABRT -5 */
168+ "Connection reset.", /* ERR_RST -6 */
169+ "Connection closed.", /* ERR_CLSD -7 */
170+ "Not connected.", /* ERR_CONN -8 */
171+ "Illegal value.", /* ERR_VAL -9 */
172+ "Illegal argument.", /* ERR_ARG -10 */
173+ "Address in use.", /* ERR_USE -11 */
174+ "Low-level netif error.", /* ERR_IF -12 */
175+ "Already connected.", /* ERR_ISCONN -13 */
176 "Operation in progress." /* ERR_INPROGRESS -14 */
177 };
178
179Index: src/api/netdb.c
180===================================================================
181RCS file: /sources/lwip/lwip/src/api/netdb.c,v
182retrieving revision 1.4
183retrieving revision 1.5
184diff -u -p -r1.4 -r1.5
185--- a/src/api/netdb.c 26 Jan 2008 16:11:39 -0000 1.4
186+++ b/src/api/netdb.c 16 Jul 2008 20:36:12 -0000 1.5
187@@ -326,7 +326,8 @@ lwip_getaddrinfo(const char *nodename, c
188 if (nodename != NULL) {
189 /* copy nodename to canonname if specified */
190 size_t namelen = strlen(nodename);
191- ai->ai_canonname = mem_malloc(namelen + 1);
192+ LWIP_ASSERT("namelen is too long", (namelen + 1) <= (mem_size_t)-1);
193+ ai->ai_canonname = mem_malloc((mem_size_t)(namelen + 1));
194 if (ai->ai_canonname == NULL) {
195 goto memerr;
196 }
197Index: src/api/sockets.c
198===================================================================
199RCS file: /sources/lwip/lwip/src/api/sockets.c,v
200retrieving revision 1.116
201retrieving revision 1.117
202diff -u -p -r1.116 -r1.117
203--- a/src/api/sockets.c 13 Mar 2008 20:03:57 -0000 1.116
204+++ b/src/api/sockets.c 9 May 2008 12:14:24 -0000 1.117
205@@ -128,17 +128,17 @@ static const int err_to_errno_table[] =
206 0, /* ERR_OK 0 No error, everything OK. */
207 ENOMEM, /* ERR_MEM -1 Out of memory error. */
208 ENOBUFS, /* ERR_BUF -2 Buffer error. */
209- EHOSTUNREACH, /* ERR_RTE -3 Routing problem. */
210- ECONNABORTED, /* ERR_ABRT -4 Connection aborted. */
211- ECONNRESET, /* ERR_RST -5 Connection reset. */
212- ESHUTDOWN, /* ERR_CLSD -6 Connection closed. */
213- ENOTCONN, /* ERR_CONN -7 Not connected. */
214- EINVAL, /* ERR_VAL -8 Illegal value. */
215- EIO, /* ERR_ARG -9 Illegal argument. */
216- EADDRINUSE, /* ERR_USE -10 Address in use. */
217- -1, /* ERR_IF -11 Low-level netif error */
218- -1, /* ERR_ISCONN -12 Already connected. */
219- ETIMEDOUT, /* ERR_TIMEOUT -13 Timeout */
220+ ETIMEDOUT, /* ERR_TIMEOUT -3 Timeout */
221+ EHOSTUNREACH, /* ERR_RTE -4 Routing problem. */
222+ ECONNABORTED, /* ERR_ABRT -5 Connection aborted. */
223+ ECONNRESET, /* ERR_RST -6 Connection reset. */
224+ ESHUTDOWN, /* ERR_CLSD -7 Connection closed. */
225+ ENOTCONN, /* ERR_CONN -8 Not connected. */
226+ EINVAL, /* ERR_VAL -9 Illegal value. */
227+ EIO, /* ERR_ARG -10 Illegal argument. */
228+ EADDRINUSE, /* ERR_USE -11 Address in use. */
229+ -1, /* ERR_IF -12 Low-level netif error */
230+ -1, /* ERR_ISCONN -13 Already connected. */
231 EINPROGRESS /* ERR_INPROGRESS -14 Operation in progress */
232 };
233
234Index: src/api/tcpip.c
235===================================================================
236RCS file: /sources/lwip/lwip/src/api/tcpip.c,v
237retrieving revision 1.70
238retrieving revision 1.73
239diff -u -p -r1.70 -r1.73
240--- a/src/api/tcpip.c 12 Jan 2008 11:52:22 -0000 1.70
241+++ b/src/api/tcpip.c 27 Jun 2008 20:34:51 -0000 1.73
242@@ -518,4 +518,42 @@ tcpip_init(void (* initfunc)(void *), vo
243 sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);
244 }
245
246+/**
247+ * Simple callback function used with tcpip_callback to free a pbuf
248+ * (pbuf_free has a wrong signature for tcpip_callback)
249+ *
250+ * @param p The pbuf (chain) to be dereferenced.
251+ */
252+static void
253+pbuf_free_int(void *p)
254+{
255+ struct pbuf *q = p;
256+ pbuf_free(q);
257+}
258+
259+/**
260+ * A simple wrapper function that allows you to free a pbuf from interrupt context.
261+ *
262+ * @param p The pbuf (chain) to be dereferenced.
263+ * @return ERR_OK if callback could be enqueued, an err_t if not
264+ */
265+err_t
266+pbuf_free_callback(struct pbuf *p)
267+{
268+ return tcpip_callback_with_block(pbuf_free_int, p, 0);
269+}
270+
271+/**
272+ * A simple wrapper function that allows you to free heap memory from
273+ * interrupt context.
274+ *
275+ * @param m the heap memory to free
276+ * @return ERR_OK if callback could be enqueued, an err_t if not
277+ */
278+err_t
279+mem_free_callback(void *m)
280+{
281+ return tcpip_callback_with_block(mem_free, m, 0);
282+}
283+
284 #endif /* !NO_SYS */
285Index: src/core/dhcp.c
286===================================================================
287RCS file: /sources/lwip/lwip/src/core/dhcp.c,v
288retrieving revision 1.86
289retrieving revision 1.87
290diff -u -p -r1.86 -r1.87
291--- a/src/core/dhcp.c 4 Mar 2008 14:25:58 -0000 1.86
292+++ b/src/core/dhcp.c 15 Apr 2008 17:24:55 -0000 1.87
293@@ -568,6 +568,8 @@ dhcp_start(struct netif *netif)
294 LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;);
295 dhcp = netif->dhcp;
296 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
297+ /* Remove the flag that says this netif is handled by DHCP,
298+ it is set when we succeeded starting. */
299 netif->flags &= ~NETIF_FLAG_DHCP;
300
301 /* no DHCP client attached yet? */
302@@ -609,6 +611,7 @@ dhcp_start(struct netif *netif)
303 dhcp_stop(netif);
304 return ERR_MEM;
305 }
306+ /* Set the flag that says this netif is handled by DHCP. */
307 netif->flags |= NETIF_FLAG_DHCP;
308 return result;
309 }
310@@ -1063,6 +1066,8 @@ dhcp_stop(struct netif *netif)
311 {
312 struct dhcp *dhcp = netif->dhcp;
313 LWIP_ERROR("dhcp_stop: netif != NULL", (netif != NULL), return;);
314+ /* Remove the flag that says this netif is handled by DHCP. */
315+ netif->flags &= ~NETIF_FLAG_DHCP;
316
317 LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_stop()\n"));
318 /* netif is DHCP configured? */
319Index: src/core/mem.c
320===================================================================
321RCS file: /sources/lwip/lwip/src/core/mem.c,v
322retrieving revision 1.59
323retrieving revision 1.62
324diff -u -p -r1.59 -r1.62
325--- a/src/core/mem.c 4 Mar 2008 16:31:32 -0000 1.59
326+++ b/src/core/mem.c 30 Jun 2008 18:16:51 -0000 1.62
327@@ -177,9 +177,36 @@ static u8_t *ram;
328 static struct mem *ram_end;
329 /** pointer to the lowest free block, this is used for faster search */
330 static struct mem *lfree;
331+
332 /** concurrent access protection */
333 static sys_sem_t mem_sem;
334
335+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
336+
337+static volatile u8_t mem_free_count;
338+
339+/* Allow mem_free from other (e.g. interrupt) context */
340+#define LWIP_MEM_FREE_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_free)
341+#define LWIP_MEM_FREE_PROTECT() SYS_ARCH_PROTECT(lev_free)
342+#define LWIP_MEM_FREE_UNPROTECT() SYS_ARCH_UNPROTECT(lev_free)
343+#define LWIP_MEM_ALLOC_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_alloc)
344+#define LWIP_MEM_ALLOC_PROTECT() SYS_ARCH_PROTECT(lev_alloc)
345+#define LWIP_MEM_ALLOC_UNPROTECT() SYS_ARCH_UNPROTECT(lev_alloc)
346+
347+#else /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
348+
349+/* Protect the heap only by using a semaphore */
350+#define LWIP_MEM_FREE_DECL_PROTECT()
351+#define LWIP_MEM_FREE_PROTECT() sys_arch_sem_wait(mem_sem, 0)
352+#define LWIP_MEM_FREE_UNPROTECT() sys_sem_signal(mem_sem)
353+/* mem_malloc is protected using semaphore AND LWIP_MEM_ALLOC_PROTECT */
354+#define LWIP_MEM_ALLOC_DECL_PROTECT()
355+#define LWIP_MEM_ALLOC_PROTECT()
356+#define LWIP_MEM_ALLOC_UNPROTECT()
357+
358+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
359+
360+
361 /**
362 * "Plug holes" by combining adjacent empty struct mems.
363 * After this function is through, there should not exist
364@@ -255,9 +282,7 @@ mem_init(void)
365 /* initialize the lowest-free pointer to the start of the heap */
366 lfree = (struct mem *)ram;
367
368-#if MEM_STATS
369- lwip_stats.mem.avail = MEM_SIZE_ALIGNED;
370-#endif /* MEM_STATS */
371+ MEM_STATS_AVAIL(avail, MEM_SIZE_ALIGNED);
372 }
373
374 /**
375@@ -270,6 +295,7 @@ void
376 mem_free(void *rmem)
377 {
378 struct mem *mem;
379+ LWIP_MEM_FREE_DECL_PROTECT();
380
381 if (rmem == NULL) {
382 LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_TRACE | 2, ("mem_free(p == NULL) was called.\n"));
383@@ -277,20 +303,20 @@ mem_free(void *rmem)
384 }
385 LWIP_ASSERT("mem_free: sanity check alignment", (((mem_ptr_t)rmem) & (MEM_ALIGNMENT-1)) == 0);
386
387- /* protect the heap from concurrent access */
388- sys_arch_sem_wait(mem_sem, 0);
389-
390 LWIP_ASSERT("mem_free: legal memory", (u8_t *)rmem >= (u8_t *)ram &&
391 (u8_t *)rmem < (u8_t *)ram_end);
392
393 if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) {
394+ SYS_ARCH_DECL_PROTECT(lev);
395 LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_free: illegal memory\n"));
396-#if MEM_STATS
397- ++lwip_stats.mem.err;
398-#endif /* MEM_STATS */
399- sys_sem_signal(mem_sem);
400+ /* protect mem stats from concurrent access */
401+ SYS_ARCH_PROTECT(lev);
402+ MEM_STATS_INC(illegal);
403+ SYS_ARCH_UNPROTECT(lev);
404 return;
405 }
406+ /* protect the heap from concurrent access */
407+ LWIP_MEM_FREE_PROTECT();
408 /* Get the corresponding struct mem ... */
409 mem = (struct mem *)((u8_t *)rmem - SIZEOF_STRUCT_MEM);
410 /* ... which has to be in a used state ... */
411@@ -303,13 +329,14 @@ mem_free(void *rmem)
412 lfree = mem;
413 }
414
415-#if MEM_STATS
416- lwip_stats.mem.used -= mem->next - ((u8_t *)mem - ram);
417-#endif /* MEM_STATS */
418+ MEM_STATS_DEC_USED(used, mem->next - ((u8_t *)mem - ram));
419
420 /* finally, see if prev or next are free also */
421 plug_holes(mem);
422- sys_sem_signal(mem_sem);
423+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
424+ mem_free_count = 1;
425+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
426+ LWIP_MEM_FREE_UNPROTECT();
427 }
428
429 /**
430@@ -321,6 +348,8 @@ mem_free(void *rmem)
431 * @param newsize required size after shrinking (needs to be smaller than or
432 * equal to the previous size)
433 * @return for compatibility reasons: is always == rmem, at the moment
434+ * or NULL if newsize is > old size, in which case rmem is NOT touched
435+ * or freed!
436 */
437 void *
438 mem_realloc(void *rmem, mem_size_t newsize)
439@@ -328,6 +357,8 @@ mem_realloc(void *rmem, mem_size_t newsi
440 mem_size_t size;
441 mem_size_t ptr, ptr2;
442 struct mem *mem, *mem2;
443+ /* use the FREE_PROTECT here: it protects with sem OR SYS_ARCH_PROTECT */
444+ LWIP_MEM_FREE_DECL_PROTECT();
445
446 /* Expand the size of the allocated memory region so that we can
447 adjust for alignment. */
448@@ -346,7 +377,12 @@ mem_realloc(void *rmem, mem_size_t newsi
449 (u8_t *)rmem < (u8_t *)ram_end);
450
451 if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) {
452+ SYS_ARCH_DECL_PROTECT(lev);
453 LWIP_DEBUGF(MEM_DEBUG | 3, ("mem_realloc: illegal memory\n"));
454+ /* protect mem stats from concurrent access */
455+ SYS_ARCH_PROTECT(lev);
456+ MEM_STATS_INC(illegal);
457+ SYS_ARCH_UNPROTECT(lev);
458 return rmem;
459 }
460 /* Get the corresponding struct mem ... */
461@@ -366,11 +402,9 @@ mem_realloc(void *rmem, mem_size_t newsi
462 }
463
464 /* protect the heap from concurrent access */
465- sys_arch_sem_wait(mem_sem, 0);
466+ LWIP_MEM_FREE_PROTECT();
467
468-#if MEM_STATS
469- lwip_stats.mem.used -= (size - newsize);
470-#endif /* MEM_STATS */
471+ MEM_STATS_DEC_USED(used, (size - newsize));
472
473 mem2 = (struct mem *)&ram[mem->next];
474 if(mem2->used == 0) {
475@@ -426,7 +460,10 @@ mem_realloc(void *rmem, mem_size_t newsi
476 -> don't do anyhting.
477 -> the remaining space stays unused since it is too small
478 } */
479- sys_sem_signal(mem_sem);
480+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
481+ mem_free_count = 1;
482+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
483+ LWIP_MEM_FREE_UNPROTECT();
484 return rmem;
485 }
486
487@@ -444,6 +481,10 @@ mem_malloc(mem_size_t size)
488 {
489 mem_size_t ptr, ptr2;
490 struct mem *mem, *mem2;
491+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
492+ u8_t local_mem_free_count = 0;
493+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
494+ LWIP_MEM_ALLOC_DECL_PROTECT();
495
496 if (size == 0) {
497 return NULL;
498@@ -464,88 +505,101 @@ mem_malloc(mem_size_t size)
499
500 /* protect the heap from concurrent access */
501 sys_arch_sem_wait(mem_sem, 0);
502+ LWIP_MEM_ALLOC_PROTECT();
503+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
504+ /* run as long as a mem_free disturbed mem_malloc */
505+ do {
506+ local_mem_free_count = 0;
507+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
508+
509+ /* Scan through the heap searching for a free block that is big enough,
510+ * beginning with the lowest free block.
511+ */
512+ for (ptr = (u8_t *)lfree - ram; ptr < MEM_SIZE_ALIGNED - size;
513+ ptr = ((struct mem *)&ram[ptr])->next) {
514+ mem = (struct mem *)&ram[ptr];
515+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
516+ mem_free_count = 0;
517+ LWIP_MEM_ALLOC_UNPROTECT();
518+ /* allow mem_free to run */
519+ LWIP_MEM_ALLOC_PROTECT();
520+ if (mem_free_count != 0) {
521+ local_mem_free_count = mem_free_count;
522+ }
523+ mem_free_count = 0;
524+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
525
526- /* Scan through the heap searching for a free block that is big enough,
527- * beginning with the lowest free block.
528- */
529- for (ptr = (u8_t *)lfree - ram; ptr < MEM_SIZE_ALIGNED - size;
530- ptr = ((struct mem *)&ram[ptr])->next) {
531- mem = (struct mem *)&ram[ptr];
532-
533- if ((!mem->used) &&
534- (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) {
535- /* mem is not used and at least perfect fit is possible:
536- * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */
537-
538- if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) {
539- /* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing
540- * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
541- * -> split large block, create empty remainder,
542- * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
543- * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
544- * struct mem would fit in but no data between mem2 and mem2->next
545- * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
546- * region that couldn't hold data, but when mem->next gets freed,
547- * the 2 regions would be combined, resulting in more free memory
548- */
549- ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
550- /* create mem2 struct */
551- mem2 = (struct mem *)&ram[ptr2];
552- mem2->used = 0;
553- mem2->next = mem->next;
554- mem2->prev = ptr;
555- /* and insert it between mem and mem->next */
556- mem->next = ptr2;
557- mem->used = 1;
558-
559- if (mem2->next != MEM_SIZE_ALIGNED) {
560- ((struct mem *)&ram[mem2->next])->prev = ptr2;
561- }
562-#if MEM_STATS
563- lwip_stats.mem.used += (size + SIZEOF_STRUCT_MEM);
564- if (lwip_stats.mem.max < lwip_stats.mem.used) {
565- lwip_stats.mem.max = lwip_stats.mem.used;
566+ if ((!mem->used) &&
567+ (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) {
568+ /* mem is not used and at least perfect fit is possible:
569+ * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */
570+
571+ if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) {
572+ /* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing
573+ * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
574+ * -> split large block, create empty remainder,
575+ * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
576+ * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
577+ * struct mem would fit in but no data between mem2 and mem2->next
578+ * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
579+ * region that couldn't hold data, but when mem->next gets freed,
580+ * the 2 regions would be combined, resulting in more free memory
581+ */
582+ ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
583+ /* create mem2 struct */
584+ mem2 = (struct mem *)&ram[ptr2];
585+ mem2->used = 0;
586+ mem2->next = mem->next;
587+ mem2->prev = ptr;
588+ /* and insert it between mem and mem->next */
589+ mem->next = ptr2;
590+ mem->used = 1;
591+
592+ if (mem2->next != MEM_SIZE_ALIGNED) {
593+ ((struct mem *)&ram[mem2->next])->prev = ptr2;
594+ }
595+ MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM));
596+ } else {
597+ /* (a mem2 struct does no fit into the user data space of mem and mem->next will always
598+ * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
599+ * take care of this).
600+ * -> near fit or excact fit: do not split, no mem2 creation
601+ * also can't move mem->next directly behind mem, since mem->next
602+ * will always be used at this point!
603+ */
604+ mem->used = 1;
605+ MEM_STATS_INC_USED(used, mem->next - ((u8_t *)mem - ram));
606 }
607-#endif /* MEM_STATS */
608- } else {
609- /* (a mem2 struct does no fit into the user data space of mem and mem->next will always
610- * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
611- * take care of this).
612- * -> near fit or excact fit: do not split, no mem2 creation
613- * also can't move mem->next directly behind mem, since mem->next
614- * will always be used at this point!
615- */
616- mem->used = 1;
617-#if MEM_STATS
618- lwip_stats.mem.used += mem->next - ((u8_t *)mem - ram);
619- if (lwip_stats.mem.max < lwip_stats.mem.used) {
620- lwip_stats.mem.max = lwip_stats.mem.used;
621- }
622-#endif /* MEM_STATS */
623- }
624
625- if (mem == lfree) {
626- /* Find next free block after mem and update lowest free pointer */
627- while (lfree->used && lfree != ram_end) {
628- lfree = (struct mem *)&ram[lfree->next];
629+ if (mem == lfree) {
630+ /* Find next free block after mem and update lowest free pointer */
631+ while (lfree->used && lfree != ram_end) {
632+ LWIP_MEM_ALLOC_UNPROTECT();
633+ /* prevent high interrupt latency... */
634+ LWIP_MEM_ALLOC_PROTECT();
635+ lfree = (struct mem *)&ram[lfree->next];
636+ }
637+ LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used)));
638 }
639- LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used)));
640- }
641- sys_sem_signal(mem_sem);
642- LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.",
643- (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end);
644- LWIP_ASSERT("mem_malloc: allocated memory properly aligned.",
645- (unsigned long)((u8_t *)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0);
646- LWIP_ASSERT("mem_malloc: sanity check alignment",
647- (((mem_ptr_t)mem) & (MEM_ALIGNMENT-1)) == 0);
648+ LWIP_MEM_ALLOC_UNPROTECT();
649+ sys_sem_signal(mem_sem);
650+ LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.",
651+ (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end);
652+ LWIP_ASSERT("mem_malloc: allocated memory properly aligned.",
653+ (unsigned long)((u8_t *)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0);
654+ LWIP_ASSERT("mem_malloc: sanity check alignment",
655+ (((mem_ptr_t)mem) & (MEM_ALIGNMENT-1)) == 0);
656
657- return (u8_t *)mem + SIZEOF_STRUCT_MEM;
658+ return (u8_t *)mem + SIZEOF_STRUCT_MEM;
659+ }
660 }
661- }
662+#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
663+ /* if we got interrupted by a mem_free, try again */
664+ } while(local_mem_free_count != 0);
665+#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */
666 LWIP_DEBUGF(MEM_DEBUG | 2, ("mem_malloc: could not allocate %"S16_F" bytes\n", (s16_t)size));
667-#if MEM_STATS
668- ++lwip_stats.mem.err;
669-#endif /* MEM_STATS */
670+ MEM_STATS_INC(err);
671+ LWIP_MEM_ALLOC_UNPROTECT();
672 sys_sem_signal(mem_sem);
673 return NULL;
674 }
675Index: src/core/memp.c
676===================================================================
677RCS file: /sources/lwip/lwip/src/core/memp.c,v
678retrieving revision 1.55
679retrieving revision 1.56
680diff -u -p -r1.55 -r1.56
681--- a/src/core/memp.c 25 Nov 2007 10:43:28 -0000 1.55
682+++ b/src/core/memp.c 27 Jun 2008 18:37:54 -0000 1.56
683@@ -252,13 +252,12 @@ memp_init(void)
684 struct memp *memp;
685 u16_t i, j;
686
687-#if MEMP_STATS
688 for (i = 0; i < MEMP_MAX; ++i) {
689- lwip_stats.memp[i].used = lwip_stats.memp[i].max =
690- lwip_stats.memp[i].err = 0;
691- lwip_stats.memp[i].avail = memp_num[i];
692+ MEMP_STATS_AVAIL(used, i, 0);
693+ MEMP_STATS_AVAIL(max, i, 0);
694+ MEMP_STATS_AVAIL(err, i, 0);
695+ MEMP_STATS_AVAIL(avail, i, memp_num[i]);
696 }
697-#endif /* MEMP_STATS */
698
699 memp = LWIP_MEM_ALIGN(memp_memory);
700 /* for every pool: */
701@@ -315,20 +314,13 @@ memp_malloc_fn(memp_t type, const char*
702 memp->file = file;
703 memp->line = line;
704 #endif /* MEMP_OVERFLOW_CHECK */
705-#if MEMP_STATS
706- ++lwip_stats.memp[type].used;
707- if (lwip_stats.memp[type].used > lwip_stats.memp[type].max) {
708- lwip_stats.memp[type].max = lwip_stats.memp[type].used;
709- }
710-#endif /* MEMP_STATS */
711+ MEMP_STATS_INC_USED(used, type);
712 LWIP_ASSERT("memp_malloc: memp properly aligned",
713 ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
714 memp = (struct memp*)((u8_t*)memp + MEMP_SIZE);
715 } else {
716 LWIP_DEBUGF(MEMP_DEBUG | 2, ("memp_malloc: out of memory in pool %s\n", memp_desc[type]));
717-#if MEMP_STATS
718- ++lwip_stats.memp[type].err;
719-#endif /* MEMP_STATS */
720+ MEMP_STATS_INC(err, type);
721 }
722
723 SYS_ARCH_UNPROTECT(old_level);
724@@ -365,9 +357,7 @@ memp_free(memp_t type, void *mem)
725 #endif /* MEMP_OVERFLOW_CHECK >= 2 */
726 #endif /* MEMP_OVERFLOW_CHECK */
727
728-#if MEMP_STATS
729- lwip_stats.memp[type].used--;
730-#endif /* MEMP_STATS */
731+ MEMP_STATS_DEC(used, type);
732
733 memp->next = memp_tab[type];
734 memp_tab[type] = memp;
735Index: src/core/netif.c
736===================================================================
737RCS file: /sources/lwip/lwip/src/core/netif.c,v
738retrieving revision 1.65
739retrieving revision 1.68
740diff -u -p -r1.65 -r1.68
741--- a/src/core/netif.c 9 Oct 2007 20:00:55 -0000 1.65
742+++ b/src/core/netif.c 19 Jun 2008 16:27:18 -0000 1.68
743@@ -45,6 +45,12 @@
744 #include "lwip/snmp.h"
745 #include "lwip/igmp.h"
746 #include "netif/etharp.h"
747+#if ENABLE_LOOPBACK
748+#include "lwip/sys.h"
749+#if LWIP_NETIF_LOOPBACK_MULTITHREADING
750+#include "lwip/tcpip.h"
751+#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
752+#endif /* ENABLE_LOOPBACK */
753
754 #if LWIP_NETIF_STATUS_CALLBACK
755 #define NETIF_STATUS_CALLBACK(n) { if (n->status_callback) (n->status_callback)(n); }
756@@ -106,6 +112,10 @@ netif_add(struct netif *netif, struct ip
757 #if LWIP_IGMP
758 netif->igmp_mac_filter = NULL;
759 #endif /* LWIP_IGMP */
760+#if ENABLE_LOOPBACK
761+ netif->loop_first = NULL;
762+ netif->loop_last = NULL;
763+#endif /* ENABLE_LOOPBACK */
764
765 /* remember netif specific state information data */
766 netif->state = state;
767@@ -114,6 +124,9 @@ netif_add(struct netif *netif, struct ip
768 #if LWIP_NETIF_HWADDRHINT
769 netif->addr_hint = NULL;
770 #endif /* LWIP_NETIF_HWADDRHINT*/
771+#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS
772+ netif->loop_cnt_current = 0;
773+#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */
774
775 netif_set_addr(netif, ipaddr, netmask, gw);
776
777@@ -493,7 +506,158 @@ u8_t netif_is_link_up(struct netif *neti
778 */
779 void netif_set_link_callback(struct netif *netif, void (* link_callback)(struct netif *netif ))
780 {
781- if ( netif )
782- netif->link_callback = link_callback;
783+ if (netif) {
784+ netif->link_callback = link_callback;
785+ }
786 }
787 #endif /* LWIP_NETIF_LINK_CALLBACK */
788+
789+#if ENABLE_LOOPBACK
790+/**
791+ * Send an IP packet to be received on the same netif (loopif-like).
792+ * The pbuf is simply copied and handed back to netif->input.
793+ * In multithreaded mode, this is done directly since netif->input must put
794+ * the packet on a queue.
795+ * In callback mode, the packet is put on an internal queue and is fed to
796+ * netif->input by netif_poll().
797+ *
798+ * @param netif the lwip network interface structure
799+ * @param p the (IP) packet to 'send'
800+ * @param ipaddr the ip address to send the packet to (not used)
801+ * @return ERR_OK if the packet has been sent
802+ * ERR_MEM if the pbuf used to copy the packet couldn't be allocated
803+ */
804+err_t
805+netif_loop_output(struct netif *netif, struct pbuf *p,
806+ struct ip_addr *ipaddr)
807+{
808+ struct pbuf *r;
809+ err_t err;
810+ struct pbuf *last;
811+#if LWIP_LOOPBACK_MAX_PBUFS
812+ u8_t clen = 0;
813+#endif /* LWIP_LOOPBACK_MAX_PBUFS */
814+ SYS_ARCH_DECL_PROTECT(lev);
815+ LWIP_UNUSED_ARG(ipaddr);
816+
817+ /* Allocate a new pbuf */
818+ r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM);
819+ if (r == NULL) {
820+ return ERR_MEM;
821+ }
822+#if LWIP_LOOPBACK_MAX_PBUFS
823+ clen = pbuf_clen(r);
824+ /* check for overflow or too many pbuf on queue */
825+ if(((netif->loop_cnt_current + clen) < netif->loop_cnt_current) ||
826+ ((netif->loop_cnt_current + clen) > LWIP_LOOPBACK_MAX_PBUFS)) {
827+ pbuf_free(r);
828+ r = NULL;
829+ return ERR_MEM;
830+ }
831+ netif->loop_cnt_current += clen;
832+#endif /* LWIP_LOOPBACK_MAX_PBUFS */
833+
834+ /* Copy the whole pbuf queue p into the single pbuf r */
835+ if ((err = pbuf_copy(r, p)) != ERR_OK) {
836+ pbuf_free(r);
837+ r = NULL;
838+ return err;
839+ }
840+
841+ /* Put the packet on a linked list which gets emptied through calling
842+ netif_poll(). */
843+
844+ /* let last point to the last pbuf in chain r */
845+ for (last = r; last->next != NULL; last = last->next);
846+
847+ SYS_ARCH_PROTECT(lev);
848+ if(netif->loop_first != NULL) {
849+ LWIP_ASSERT("if first != NULL, last must also be != NULL", netif->loop_last != NULL);
850+ netif->loop_last->next = r;
851+ netif->loop_last = last;
852+ } else {
853+ netif->loop_first = r;
854+ netif->loop_last = last;
855+ }
856+ SYS_ARCH_UNPROTECT(lev);
857+
858+#if LWIP_NETIF_LOOPBACK_MULTITHREADING
859+ /* For multithreading environment, schedule a call to netif_poll */
860+ tcpip_callback(netif_poll, netif);
861+#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
862+
863+ return ERR_OK;
864+}
865+
866+/**
867+ * Call netif_poll() in the main loop of your application. This is to prevent
868+ * reentering non-reentrant functions like tcp_input(). Packets passed to
869+ * netif_loop_output() are put on a list that is passed to netif->input() by
870+ * netif_poll().
871+ */
872+void
873+netif_poll(struct netif *netif)
874+{
875+ struct pbuf *in;
876+ SYS_ARCH_DECL_PROTECT(lev);
877+
878+ do {
879+ /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */
880+ SYS_ARCH_PROTECT(lev);
881+ in = netif->loop_first;
882+ if(in != NULL) {
883+ struct pbuf *in_end = in;
884+#if LWIP_LOOPBACK_MAX_PBUFS
885+ u8_t clen = pbuf_clen(in);
886+ /* adjust the number of pbufs on queue */
887+ LWIP_ASSERT("netif->loop_cnt_current underflow",
888+ ((netif->loop_cnt_current - clen) < netif->loop_cnt_current));
889+ netif->loop_cnt_current -= clen;
890+#endif /* LWIP_LOOPBACK_MAX_PBUFS */
891+ while(in_end->len != in_end->tot_len) {
892+ LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL);
893+ in_end = in_end->next;
894+ }
895+ /* 'in_end' now points to the last pbuf from 'in' */
896+ if(in_end == netif->loop_last) {
897+ /* this was the last pbuf in the list */
898+ netif->loop_first = netif->loop_last = NULL;
899+ } else {
900+ /* pop the pbuf off the list */
901+ netif->loop_first = in_end->next;
902+ LWIP_ASSERT("should not be null since first != last!", netif->loop_first != NULL);
903+ }
904+ /* De-queue the pbuf from its successors on the 'loop_' list. */
905+ in_end->next = NULL;
906+ }
907+ SYS_ARCH_UNPROTECT(lev);
908+
909+ if(in != NULL) {
910+ /* loopback packets are always IP packets! */
911+ if(ip_input(in, netif) != ERR_OK) {
912+ pbuf_free(in);
913+ }
914+ /* Don't reference the packet any more! */
915+ in = NULL;
916+ }
917+ /* go on while there is a packet on the list */
918+ } while(netif->loop_first != NULL);
919+}
920+
921+#if !LWIP_NETIF_LOOPBACK_MULTITHREADING
922+/**
923+ * Calls netif_poll() for every netif on the netif_list.
924+ */
925+void
926+netif_poll_all(void)
927+{
928+ struct netif *netif = netif_list;
929+ /* loop through netifs */
930+ while (netif != NULL) {
931+ netif_poll(netif);
932+ /* proceed to next network interface */
933+ netif = netif->next;
934+ }
935+}
936+#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
937+#endif /* ENABLE_LOOPBACK */
938Index: src/core/pbuf.c
939===================================================================
940RCS file: /sources/lwip/lwip/src/core/pbuf.c,v
941retrieving revision 1.127
942retrieving revision 1.128
943diff -u -p -r1.127 -r1.128
944--- a/src/core/pbuf.c 4 Mar 2008 16:37:46 -0000 1.127
945+++ b/src/core/pbuf.c 1 Apr 2008 19:05:40 -0000 1.128
946@@ -667,8 +667,8 @@ pbuf_dechain(struct pbuf *p)
947 *
948 * @note Only one packet is copied, no packet queue!
949 *
950- * @param p_to pbuf source of the copy
951- * @param p_from pbuf destination of the copy
952+ * @param p_to pbuf destination of the copy
953+ * @param p_from pbuf source of the copy
954 *
955 * @return ERR_OK if pbuf was copied
956 * ERR_ARG if one of the pbufs is NULL or p_to is not big
957Index: src/core/stats.c
958===================================================================
959RCS file: /sources/lwip/lwip/src/core/stats.c,v
960retrieving revision 1.27
961retrieving revision 1.28
962diff -u -p -r1.27 -r1.28
963--- a/src/core/stats.c 4 Mar 2008 16:31:32 -0000 1.27
964+++ b/src/core/stats.c 27 Jun 2008 18:37:54 -0000 1.28
965@@ -54,7 +54,6 @@ stats_display_proto(struct stats_proto *
966 {
967 LWIP_PLATFORM_DIAG(("\n%s\n\t", name));
968 LWIP_PLATFORM_DIAG(("xmit: %"STAT_COUNTER_F"\n\t", proto->xmit));
969- LWIP_PLATFORM_DIAG(("rexmit: %"STAT_COUNTER_F"\n\t", proto->rexmit));
970 LWIP_PLATFORM_DIAG(("recv: %"STAT_COUNTER_F"\n\t", proto->recv));
971 LWIP_PLATFORM_DIAG(("fw: %"STAT_COUNTER_F"\n\t", proto->fw));
972 LWIP_PLATFORM_DIAG(("drop: %"STAT_COUNTER_F"\n\t", proto->drop));
973@@ -68,6 +67,7 @@ stats_display_proto(struct stats_proto *
974 LWIP_PLATFORM_DIAG(("cachehit: %"STAT_COUNTER_F"\n", proto->cachehit));
975 }
976
977+#if IGMP_STATS
978 void
979 stats_display_igmp(struct stats_igmp *igmp)
980 {
981@@ -82,7 +82,9 @@ stats_display_igmp(struct stats_igmp *ig
982 LWIP_PLATFORM_DIAG(("report_rxed: %"STAT_COUNTER_F"\n\t", igmp->report_rxed));
983 LWIP_PLATFORM_DIAG(("group_query_rxed: %"STAT_COUNTER_F"\n", igmp->group_query_rxed));
984 }
985+#endif /* IGMP_STATS */
986
987+#if MEM_STATS || MEMP_STATS
988 void
989 stats_display_mem(struct stats_mem *mem, char *name)
990 {
991@@ -93,48 +95,53 @@ stats_display_mem(struct stats_mem *mem,
992 LWIP_PLATFORM_DIAG(("err: %"U32_F"\n", (u32_t)mem->err));
993 }
994
995+#if MEMP_STATS
996 void
997-stats_display(void)
998+stats_display_memp(struct stats_mem *mem, int index)
999 {
1000-#if MEMP_STATS
1001- s16_t i;
1002 char * memp_names[] = {
1003 #define LWIP_MEMPOOL(name,num,size,desc) desc,
1004 #include "lwip/memp_std.h"
1005 };
1006-#endif
1007-#if LINK_STATS
1008- stats_display_proto(&lwip_stats.link, "LINK");
1009-#endif
1010-#if ETHARP_STATS
1011- stats_display_proto(&lwip_stats.etharp, "ETHARP");
1012-#endif
1013-#if IPFRAG_STATS
1014- stats_display_proto(&lwip_stats.ip_frag, "IP_FRAG");
1015-#endif
1016-#if IP_STATS
1017- stats_display_proto(&lwip_stats.ip, "IP");
1018-#endif
1019-#if ICMP_STATS
1020- stats_display_proto(&lwip_stats.icmp, "ICMP");
1021-#endif
1022-#if IGMP_STATS
1023- stats_display_igmp(&lwip_stats.igmp);
1024-#endif
1025-#if UDP_STATS
1026- stats_display_proto(&lwip_stats.udp, "UDP");
1027-#endif
1028-#if TCP_STATS
1029- stats_display_proto(&lwip_stats.tcp, "TCP");
1030-#endif
1031-#if MEM_STATS
1032- stats_display_mem(&lwip_stats.mem, "HEAP");
1033-#endif
1034-#if MEMP_STATS
1035+ if(index < MEMP_MAX) {
1036+ stats_display_mem(mem, memp_names[index]);
1037+ }
1038+}
1039+#endif /* MEMP_STATS */
1040+#endif /* MEM_STATS || MEMP_STATS */
1041+
1042+#if SYS_STATS
1043+void
1044+stats_display_sys(struct stats_sys *sys)
1045+{
1046+ LWIP_PLATFORM_DIAG(("\nSYS\n\t"));
1047+ LWIP_PLATFORM_DIAG(("sem.used: %"U32_F"\n\t", (u32_t)sys->sem.used));
1048+ LWIP_PLATFORM_DIAG(("sem.max: %"U32_F"\n\t", (u32_t)sys->sem.max));
1049+ LWIP_PLATFORM_DIAG(("sem.err: %"U32_F"\n\t", (u32_t)sys->sem.err));
1050+ LWIP_PLATFORM_DIAG(("mbox.used: %"U32_F"\n\t", (u32_t)sys->mbox.used));
1051+ LWIP_PLATFORM_DIAG(("mbox.max: %"U32_F"\n\t", (u32_t)sys->mbox.max));
1052+ LWIP_PLATFORM_DIAG(("mbox.err: %"U32_F"\n\t", (u32_t)sys->mbox.err));
1053+}
1054+#endif /* SYS_STATS */
1055+
1056+void
1057+stats_display(void)
1058+{
1059+ s16_t i;
1060+
1061+ LINK_STATS_DISPLAY();
1062+ ETHARP_STATS_DISPLAY();
1063+ IPFRAG_STATS_DISPLAY();
1064+ IP_STATS_DISPLAY();
1065+ IGMP_STATS_DISPLAY();
1066+ ICMP_STATS_DISPLAY();
1067+ UDP_STATS_DISPLAY();
1068+ TCP_STATS_DISPLAY();
1069+ MEM_STATS_DISPLAY();
1070 for (i = 0; i < MEMP_MAX; i++) {
1071- stats_display_mem(&lwip_stats.memp[i], memp_names[i]);
1072+ MEMP_STATS_DISPLAY(i);
1073 }
1074-#endif
1075+ SYS_STATS_DISPLAY();
1076 }
1077 #endif /* LWIP_STATS_DISPLAY */
1078
1079Index: src/core/sys.c
1080===================================================================
1081RCS file: /sources/lwip/lwip/src/core/sys.c,v
1082retrieving revision 1.32
1083retrieving revision 1.33
1084diff -u -p -r1.32 -r1.33
1085--- a/src/core/sys.c 25 Nov 2007 13:57:05 -0000 1.32
1086+++ b/src/core/sys.c 16 Jul 2008 20:36:12 -0000 1.33
1087@@ -65,7 +65,7 @@ struct sswt_cb
1088 void
1089 sys_mbox_fetch(sys_mbox_t mbox, void **msg)
1090 {
1091- u32_t time;
1092+ u32_t time_needed;
1093 struct sys_timeouts *timeouts;
1094 struct sys_timeo *tmptimeout;
1095 sys_timeout_handler h;
1096@@ -76,18 +76,18 @@ sys_mbox_fetch(sys_mbox_t mbox, void **m
1097
1098 if (!timeouts || !timeouts->next) {
1099 UNLOCK_TCPIP_CORE();
1100- time = sys_arch_mbox_fetch(mbox, msg, 0);
1101+ time_needed = sys_arch_mbox_fetch(mbox, msg, 0);
1102 LOCK_TCPIP_CORE();
1103 } else {
1104 if (timeouts->next->time > 0) {
1105 UNLOCK_TCPIP_CORE();
1106- time = sys_arch_mbox_fetch(mbox, msg, timeouts->next->time);
1107+ time_needed = sys_arch_mbox_fetch(mbox, msg, timeouts->next->time);
1108 LOCK_TCPIP_CORE();
1109 } else {
1110- time = SYS_ARCH_TIMEOUT;
1111+ time_needed = SYS_ARCH_TIMEOUT;
1112 }
1113
1114- if (time == SYS_ARCH_TIMEOUT) {
1115+ if (time_needed == SYS_ARCH_TIMEOUT) {
1116 /* If time == SYS_ARCH_TIMEOUT, a timeout occured before a message
1117 could be fetched. We should now call the timeout handler and
1118 deallocate the memory allocated for the timeout. */
1119@@ -107,8 +107,8 @@ sys_mbox_fetch(sys_mbox_t mbox, void **m
1120 /* If time != SYS_ARCH_TIMEOUT, a message was received before the timeout
1121 occured. The time variable is set to the number of
1122 milliseconds we waited for the message. */
1123- if (time < timeouts->next->time) {
1124- timeouts->next->time -= time;
1125+ if (time_needed < timeouts->next->time) {
1126+ timeouts->next->time -= time_needed;
1127 } else {
1128 timeouts->next->time = 0;
1129 }
1130@@ -125,7 +125,7 @@ sys_mbox_fetch(sys_mbox_t mbox, void **m
1131 void
1132 sys_sem_wait(sys_sem_t sem)
1133 {
1134- u32_t time;
1135+ u32_t time_needed;
1136 struct sys_timeouts *timeouts;
1137 struct sys_timeo *tmptimeout;
1138 sys_timeout_handler h;
1139@@ -139,12 +139,12 @@ sys_sem_wait(sys_sem_t sem)
1140 sys_arch_sem_wait(sem, 0);
1141 } else {
1142 if (timeouts->next->time > 0) {
1143- time = sys_arch_sem_wait(sem, timeouts->next->time);
1144+ time_needed = sys_arch_sem_wait(sem, timeouts->next->time);
1145 } else {
1146- time = SYS_ARCH_TIMEOUT;
1147+ time_needed = SYS_ARCH_TIMEOUT;
1148 }
1149
1150- if (time == SYS_ARCH_TIMEOUT) {
1151+ if (time_needed == SYS_ARCH_TIMEOUT) {
1152 /* If time == SYS_ARCH_TIMEOUT, a timeout occured before a message
1153 could be fetched. We should now call the timeout handler and
1154 deallocate the memory allocated for the timeout. */
1155@@ -164,8 +164,8 @@ sys_sem_wait(sys_sem_t sem)
1156 /* If time != SYS_ARCH_TIMEOUT, a message was received before the timeout
1157 occured. The time variable is set to the number of
1158 milliseconds we waited for the message. */
1159- if (time < timeouts->next->time) {
1160- timeouts->next->time -= time;
1161+ if (time_needed < timeouts->next->time) {
1162+ timeouts->next->time -= time_needed;
1163 } else {
1164 timeouts->next->time = 0;
1165 }
1166Index: src/core/tcp.c
1167===================================================================
1168RCS file: /sources/lwip/lwip/src/core/tcp.c,v
1169retrieving revision 1.85
1170retrieving revision 1.86
1171diff -u -p -r1.85 -r1.86
1172--- a/src/core/tcp.c 22 Jan 2008 21:15:15 -0000 1.85
1173+++ b/src/core/tcp.c 26 Mar 2008 11:57:13 -0000 1.86
1174@@ -509,7 +509,8 @@ tcp_connect(struct tcp_pcb *pcb, struct
1175 pcb->rcv_wnd = TCP_WND;
1176 pcb->rcv_ann_wnd = TCP_WND;
1177 pcb->snd_wnd = TCP_WND;
1178- /* The send MSS is updated when an MSS option is received. */
1179+ /* As initial send MSS, we use TCP_MSS but limit it to 536.
1180+ The send MSS is updated when an MSS option is received. */
1181 pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
1182 #if TCP_CALCULATE_EFF_SEND_MSS
1183 pcb->mss = tcp_eff_send_mss(pcb->mss, ipaddr);
1184@@ -991,7 +992,8 @@ tcp_alloc(u8_t prio)
1185 pcb->rcv_ann_wnd = TCP_WND;
1186 pcb->tos = 0;
1187 pcb->ttl = TCP_TTL;
1188- /* The send MSS is updated when an MSS option is received. */
1189+ /* As initial send MSS, we use TCP_MSS but limit it to 536.
1190+ The send MSS is updated when an MSS option is received. */
1191 pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
1192 pcb->rto = 3000 / TCP_SLOW_INTERVAL;
1193 pcb->sa = 0;
1194Index: src/core/tcp_in.c
1195===================================================================
1196RCS file: /sources/lwip/lwip/src/core/tcp_in.c,v
1197retrieving revision 1.97
1198retrieving revision 1.100
1199diff -u -p -r1.97 -r1.100
1200--- a/src/core/tcp_in.c 22 Jan 2008 21:15:15 -0000 1.97
1201+++ b/src/core/tcp_in.c 24 Jun 2008 15:46:39 -0000 1.100
1202@@ -511,7 +511,7 @@ tcp_process(struct tcp_pcb *pcb)
1203 }
1204 } else {
1205 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
1206- pcb->rcv_nxt+pcb->rcv_ann_wnd)) {
1207+ pcb->rcv_nxt+pcb->rcv_wnd)) {
1208 acceptable = 1;
1209 }
1210 }
1211@@ -1038,7 +1038,7 @@ tcp_receive(struct tcp_pcb *pcb)
1212 and below rcv_nxt + rcv_wnd) in order to be further
1213 processed. */
1214 if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
1215- pcb->rcv_nxt + pcb->rcv_ann_wnd - 1)){
1216+ pcb->rcv_nxt + pcb->rcv_wnd - 1)){
1217 if (pcb->rcv_nxt == seqno) {
1218 accepted_inseq = 1;
1219 /* The incoming segment is the next in sequence. We check if
1220@@ -1195,14 +1195,14 @@ tcp_receive(struct tcp_pcb *pcb)
1221 } else {
1222 pcb->ooseq = cseg;
1223 }
1224- }
1225- tcp_seg_free(next);
1226- if (cseg->next != NULL) {
1227- next = cseg->next;
1228- if (TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) {
1229- /* We need to trim the incoming segment. */
1230- cseg->len = (u16_t)(next->tcphdr->seqno - seqno);
1231- pbuf_realloc(cseg->p, cseg->len);
1232+ tcp_seg_free(next);
1233+ if (cseg->next != NULL) {
1234+ next = cseg->next;
1235+ if (TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) {
1236+ /* We need to trim the incoming segment. */
1237+ cseg->len = (u16_t)(next->tcphdr->seqno - seqno);
1238+ pbuf_realloc(cseg->p, cseg->len);
1239+ }
1240 }
1241 }
1242 break;
1243@@ -1282,10 +1282,7 @@ tcp_receive(struct tcp_pcb *pcb)
1244
1245 }
1246 } else {
1247- if(!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
1248- pcb->rcv_nxt + pcb->rcv_ann_wnd-1)){
1249- tcp_ack_now(pcb);
1250- }
1251+ tcp_ack_now(pcb);
1252 }
1253 } else {
1254 /* Segments with length 0 is taken care of here. Segments that
1255@@ -1331,7 +1328,8 @@ tcp_parseopt(struct tcp_pcb *pcb)
1256 opts[c + 1] == 0x04) {
1257 /* An MSS option with the right option length. */
1258 mss = (opts[c + 2] << 8) | opts[c + 3];
1259- pcb->mss = mss > TCP_MSS? TCP_MSS: mss;
1260+ /* Limit the mss to the configured TCP_MSS and prevent division by zero */
1261+ pcb->mss = ((mss > TCP_MSS) || (mss == 0)) ? TCP_MSS : mss;
1262
1263 /* And we are done processing options. */
1264 break;
1265Index: src/core/ipv4/autoip.c
1266===================================================================
1267RCS file: /sources/lwip/lwip/src/core/ipv4/autoip.c,v
1268retrieving revision 1.16
1269retrieving revision 1.17
1270diff -u -p -r1.16 -r1.17
1271--- a/src/core/ipv4/autoip.c 26 Jan 2008 16:11:40 -0000 1.16
1272+++ b/src/core/ipv4/autoip.c 17 Jun 2008 20:16:23 -0000 1.17
1273@@ -395,8 +395,8 @@ autoip_arp_reply(struct netif *netif, st
1274 /* Copy struct ip_addr2 to aligned ip_addr, to support compilers without
1275 * structure packing (not using structure copy which breaks strict-aliasing rules).
1276 */
1277- MEMCPY(&sipaddr, &hdr->sipaddr, sizeof(sipaddr));
1278- MEMCPY(&dipaddr, &hdr->dipaddr, sizeof(dipaddr));
1279+ SMEMCPY(&sipaddr, &hdr->sipaddr, sizeof(sipaddr));
1280+ SMEMCPY(&dipaddr, &hdr->dipaddr, sizeof(dipaddr));
1281
1282 if ((netif->autoip->state == AUTOIP_STATE_PROBING) ||
1283 ((netif->autoip->state == AUTOIP_STATE_ANNOUNCING) &&
1284Index: src/core/ipv4/inet_chksum.c
1285===================================================================
1286RCS file: /sources/lwip/lwip/src/core/ipv4/inet_chksum.c,v
1287retrieving revision 1.4
1288retrieving revision 1.5
1289diff -u -p -r1.4 -r1.5
1290--- a/src/core/ipv4/inet_chksum.c 10 Mar 2008 16:12:31 -0000 1.4
1291+++ b/src/core/ipv4/inet_chksum.c 17 Jun 2008 20:06:25 -0000 1.5
1292@@ -41,8 +41,6 @@
1293 #include "lwip/inet_chksum.h"
1294 #include "lwip/inet.h"
1295
1296-#include <string.h>
1297-
1298 /* These are some reference implementations of the checksum algorithm, with the
1299 * aim of being simple, correct and fully portable. Checksumming is the
1300 * first thing you would want to optimize for your platform. If you create
1301@@ -65,6 +63,11 @@
1302 # define LWIP_CHKSUM_ALGORITHM 0
1303 #endif
1304
1305+/** Like the name says... */
1306+#define SWAP_BYTES_IN_WORD(w) ((w & 0xff) << 8) | ((w & 0xff00) >> 8)
1307+/** Split an u32_t in two u16_ts and add them up */
1308+#define FOLD_U32T(u) ((u >> 16) + (u & 0x0000ffffUL))
1309+
1310 #if (LWIP_CHKSUM_ALGORITHM == 1) /* Version #1 */
1311 /**
1312 * lwip checksum
1313@@ -86,8 +89,7 @@ lwip_standard_chksum(void *dataptr, u16_
1314 acc = 0;
1315 /* dataptr may be at odd or even addresses */
1316 octetptr = (u8_t*)dataptr;
1317- while (len > 1)
1318- {
1319+ while (len > 1) {
1320 /* declare first octet as most significant
1321 thus assume network order, ignoring host order */
1322 src = (*octetptr) << 8;
1323@@ -98,8 +100,7 @@ lwip_standard_chksum(void *dataptr, u16_
1324 acc += src;
1325 len -= 2;
1326 }
1327- if (len > 0)
1328- {
1329+ if (len > 0) {
1330 /* accumulate remaining octet */
1331 src = (*octetptr) << 8;
1332 acc += src;
1333@@ -154,19 +155,22 @@ lwip_standard_chksum(void *dataptr, int
1334 }
1335
1336 /* Consume left-over byte, if any */
1337- if (len > 0)
1338+ if (len > 0) {
1339 ((u8_t *)&t)[0] = *(u8_t *)ps;;
1340+ }
1341
1342 /* Add end bytes */
1343 sum += t;
1344
1345- /* Fold 32-bit sum to 16 bits */
1346- while ((sum >> 16) != 0)
1347- sum = (sum & 0xffff) + (sum >> 16);
1348+ /* Fold 32-bit sum to 16 bits
1349+ calling this twice is propably faster than if statements... */
1350+ sum = FOLD_U32T(sum);
1351+ sum = FOLD_U32T(sum);
1352
1353 /* Swap if alignment was odd */
1354- if (odd)
1355- sum = ((sum & 0xff) << 8) | ((sum & 0xff00) >> 8);
1356+ if (odd) {
1357+ sum = SWAP_BYTES_IN_WORD(sum);
1358+ }
1359
1360 return sum;
1361 }
1362@@ -211,18 +215,20 @@ lwip_standard_chksum(void *dataptr, int
1363
1364 while (len > 7) {
1365 tmp = sum + *pl++; /* ping */
1366- if (tmp < sum)
1367+ if (tmp < sum) {
1368 tmp++; /* add back carry */
1369+ }
1370
1371 sum = tmp + *pl++; /* pong */
1372- if (sum < tmp)
1373+ if (sum < tmp) {
1374 sum++; /* add back carry */
1375+ }
1376
1377 len -= 8;
1378 }
1379
1380 /* make room in upper bits */
1381- sum = (sum >> 16) + (sum & 0xffff);
1382+ sum = FOLD_U32T(sum);
1383
1384 ps = (u16_t *)pl;
1385
1386@@ -233,16 +239,20 @@ lwip_standard_chksum(void *dataptr, int
1387 }
1388
1389 /* dangling tail byte remaining? */
1390- if (len > 0) /* include odd byte */
1391+ if (len > 0) { /* include odd byte */
1392 ((u8_t *)&t)[0] = *(u8_t *)ps;
1393+ }
1394
1395 sum += t; /* add end bytes */
1396
1397- while ((sum >> 16) != 0) /* combine halves */
1398- sum = (sum >> 16) + (sum & 0xffff);
1399+ /* Fold 32-bit sum to 16 bits
1400+ calling this twice is propably faster than if statements... */
1401+ sum = FOLD_U32T(sum);
1402+ sum = FOLD_U32T(sum);
1403
1404- if (odd)
1405- sum = ((sum & 0xff) << 8) | ((sum & 0xff00) >> 8);
1406+ if (odd) {
1407+ sum = SWAP_BYTES_IN_WORD(sum);
1408+ }
1409
1410 return sum;
1411 }
1412@@ -277,18 +287,18 @@ inet_chksum_pseudo(struct pbuf *p,
1413 (void *)q, (void *)q->next));
1414 acc += LWIP_CHKSUM(q->payload, q->len);
1415 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/
1416- while ((acc >> 16) != 0) {
1417- acc = (acc & 0xffffUL) + (acc >> 16);
1418- }
1419+ /* just executing this next line is probably faster that the if statement needed
1420+ to check whether we really need to execute it, and does no harm */
1421+ acc = FOLD_U32T(acc);
1422 if (q->len % 2 != 0) {
1423 swapped = 1 - swapped;
1424- acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
1425+ acc = SWAP_BYTES_IN_WORD(acc);
1426 }
1427 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/
1428 }
1429
1430 if (swapped) {
1431- acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
1432+ acc = SWAP_BYTES_IN_WORD(acc);
1433 }
1434 acc += (src->addr & 0xffffUL);
1435 acc += ((src->addr >> 16) & 0xffffUL);
1436@@ -297,9 +307,10 @@ inet_chksum_pseudo(struct pbuf *p,
1437 acc += (u32_t)htons((u16_t)proto);
1438 acc += (u32_t)htons(proto_len);
1439
1440- while ((acc >> 16) != 0) {
1441- acc = (acc & 0xffffUL) + (acc >> 16);
1442- }
1443+ /* Fold 32-bit sum to 16 bits
1444+ calling this twice is propably faster than if statements... */
1445+ acc = FOLD_U32T(acc);
1446+ acc = FOLD_U32T(acc);
1447 LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc));
1448 return (u16_t)~(acc & 0xffffUL);
1449 }
1450@@ -340,18 +351,17 @@ inet_chksum_pseudo_partial(struct pbuf *
1451 chksum_len -= chklen;
1452 LWIP_ASSERT("delete me", chksum_len < 0x7fff);
1453 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/
1454- while ((acc >> 16) != 0) {
1455- acc = (acc & 0xffffUL) + (acc >> 16);
1456- }
1457+ /* fold the upper bit down */
1458+ acc = FOLD_U32T(acc);
1459 if (q->len % 2 != 0) {
1460 swapped = 1 - swapped;
1461- acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
1462+ acc = SWAP_BYTES_IN_WORD(acc);
1463 }
1464 /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/
1465 }
1466
1467 if (swapped) {
1468- acc = ((acc & 0xff) << 8) | ((acc & 0xff00UL) >> 8);
1469+ acc = SWAP_BYTES_IN_WORD(acc);
1470 }
1471 acc += (src->addr & 0xffffUL);
1472 acc += ((src->addr >> 16) & 0xffffUL);
1473@@ -360,9 +370,10 @@ inet_chksum_pseudo_partial(struct pbuf *
1474 acc += (u32_t)htons((u16_t)proto);
1475 acc += (u32_t)htons(proto_len);
1476
1477- while ((acc >> 16) != 0) {
1478- acc = (acc & 0xffffUL) + (acc >> 16);
1479- }
1480+ /* Fold 32-bit sum to 16 bits
1481+ calling this twice is propably faster than if statements... */
1482+ acc = FOLD_U32T(acc);
1483+ acc = FOLD_U32T(acc);
1484 LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc));
1485 return (u16_t)~(acc & 0xffffUL);
1486 }
1487@@ -380,13 +391,7 @@ inet_chksum_pseudo_partial(struct pbuf *
1488 u16_t
1489 inet_chksum(void *dataptr, u16_t len)
1490 {
1491- u32_t acc;
1492-
1493- acc = LWIP_CHKSUM(dataptr, len);
1494- while ((acc >> 16) != 0) {
1495- acc = (acc & 0xffff) + (acc >> 16);
1496- }
1497- return (u16_t)~(acc & 0xffff);
1498+ return ~LWIP_CHKSUM(dataptr, len);
1499 }
1500
1501 /**
1502@@ -407,17 +412,15 @@ inet_chksum_pbuf(struct pbuf *p)
1503 swapped = 0;
1504 for(q = p; q != NULL; q = q->next) {
1505 acc += LWIP_CHKSUM(q->payload, q->len);
1506- while ((acc >> 16) != 0) {
1507- acc = (acc & 0xffffUL) + (acc >> 16);
1508- }
1509+ acc = FOLD_U32T(acc);
1510 if (q->len % 2 != 0) {
1511 swapped = 1 - swapped;
1512- acc = (acc & 0x00ffUL << 8) | (acc & 0xff00UL >> 8);
1513+ acc = SWAP_BYTES_IN_WORD(acc);
1514 }
1515 }
1516
1517 if (swapped) {
1518- acc = ((acc & 0x00ffUL) << 8) | ((acc & 0xff00UL) >> 8);
1519+ acc = SWAP_BYTES_IN_WORD(acc);
1520 }
1521 return (u16_t)~(acc & 0xffffUL);
1522 }
1523Index: src/core/ipv4/ip.c
1524===================================================================
1525RCS file: /sources/lwip/lwip/src/core/ipv4/ip.c,v
1526retrieving revision 1.66
1527retrieving revision 1.68
1528diff -u -p -r1.66 -r1.68
1529--- a/src/core/ipv4/ip.c 14 Jan 2008 20:53:23 -0000 1.66
1530+++ b/src/core/ipv4/ip.c 17 Jun 2008 19:39:22 -0000 1.68
1531@@ -531,9 +531,19 @@ ip_output_if(struct pbuf *p, struct ip_a
1532 LWIP_DEBUGF(IP_DEBUG, ("ip_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], netif->num));
1533 ip_debug_print(p);
1534
1535- LWIP_DEBUGF(IP_DEBUG, ("netif->output()"));
1536+#if (LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF)
1537+ if (ip_addr_cmp(dest, &netif->ip_addr)) {
1538+ /* Packet to self, enqueue it for loopback */
1539+ LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()"));
1540+
1541+ return netif_loop_output(netif, p, dest);
1542+ } else
1543+#endif /* (LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF) */
1544+ {
1545+ LWIP_DEBUGF(IP_DEBUG, ("netif->output()"));
1546
1547- return netif->output(netif, p, dest);
1548+ return netif->output(netif, p, dest);
1549+ }
1550 }
1551
1552 /**
1553Index: src/include/lwip/debug.h
1554===================================================================
1555RCS file: /sources/lwip/lwip/src/include/lwip/debug.h,v
1556retrieving revision 1.37
1557retrieving revision 1.39
1558diff -u -p -r1.37 -r1.39
1559--- a/src/include/lwip/debug.h 22 Sep 2007 11:16:07 -0000 1.37
1560+++ b/src/include/lwip/debug.h 16 Jul 2008 20:36:22 -0000 1.39
1561@@ -61,26 +61,28 @@
1562 #define LWIP_DBG_HALT 0x08U
1563
1564 #ifndef LWIP_NOASSERT
1565-#define LWIP_ASSERT(x,y) do { if(!(y)) LWIP_PLATFORM_ASSERT(x); } while(0)
1566+#define LWIP_ASSERT(message, assertion) do { if(!(assertion)) \
1567+ LWIP_PLATFORM_ASSERT(message); } while(0)
1568 #else /* LWIP_NOASSERT */
1569-#define LWIP_ASSERT(x,y)
1570+#define LWIP_ASSERT(message, assertion)
1571 #endif /* LWIP_NOASSERT */
1572
1573-/** print "m" message only if "e" is true, and execute "h" expression */
1574+/** if "expression" isn't true, then print "message" and execute "handler" expression */
1575 #ifndef LWIP_ERROR
1576-#define LWIP_ERROR(m,e,h) do { if (!(e)) { LWIP_PLATFORM_ASSERT(m); h;}} while(0)
1577+#define LWIP_ERROR(message, expression, handler) do { if (!(expression)) { \
1578+ LWIP_PLATFORM_ASSERT(message); handler;}} while(0)
1579 #endif /* LWIP_ERROR */
1580
1581 #ifdef LWIP_DEBUG
1582 /** print debug message only if debug message type is enabled...
1583 * AND is of correct type AND is at least LWIP_DBG_LEVEL
1584 */
1585-#define LWIP_DEBUGF(debug,x) do { \
1586+#define LWIP_DEBUGF(debug, message) do { \
1587 if ( \
1588 ((debug) & LWIP_DBG_ON) && \
1589 ((debug) & LWIP_DBG_TYPES_ON) && \
1590 ((s16_t)((debug) & LWIP_DBG_MASK_LEVEL) >= LWIP_DBG_MIN_LEVEL)) { \
1591- LWIP_PLATFORM_DIAG(x); \
1592+ LWIP_PLATFORM_DIAG(message); \
1593 if ((debug) & LWIP_DBG_HALT) { \
1594 while(1); \
1595 } \
1596@@ -88,7 +90,7 @@
1597 } while(0)
1598
1599 #else /* LWIP_DEBUG */
1600-#define LWIP_DEBUGF(debug,x)
1601+#define LWIP_DEBUGF(debug, message)
1602 #endif /* LWIP_DEBUG */
1603
1604 #endif /* __LWIP_DEBUG_H__ */
1605Index: src/include/lwip/err.h
1606===================================================================
1607RCS file: /sources/lwip/lwip/src/include/lwip/err.h,v
1608retrieving revision 1.13
1609retrieving revision 1.15
1610diff -u -p -r1.13 -r1.15
1611--- a/src/include/lwip/err.h 13 Dec 2007 23:06:50 -0000 1.13
1612+++ b/src/include/lwip/err.h 17 Jun 2008 20:27:32 -0000 1.15
1613@@ -33,37 +33,43 @@
1614 #define __LWIP_ERR_H__
1615
1616 #include "lwip/opt.h"
1617+#include "lwip/arch.h"
1618
1619 #ifdef __cplusplus
1620 extern "C" {
1621 #endif
1622
1623-typedef s8_t err_t;
1624+/** Define LWIP_ERR_T in cc.h if you want to use
1625+ * a different type for your platform (must be signed). */
1626+#ifdef LWIP_ERR_T
1627+typedef LWIP_ERR_T err_t;
1628+#else /* LWIP_ERR_T */
1629+ typedef s8_t err_t;
1630+#endif /* LWIP_ERR_T*/
1631
1632 /* Definitions for error constants. */
1633
1634 #define ERR_OK 0 /* No error, everything OK. */
1635 #define ERR_MEM -1 /* Out of memory error. */
1636 #define ERR_BUF -2 /* Buffer error. */
1637-#define ERR_RTE -3 /* Routing problem. */
1638+#define ERR_TIMEOUT -3 /* Timeout. */
1639+#define ERR_RTE -4 /* Routing problem. */
1640
1641 #define ERR_IS_FATAL(e) ((e) < ERR_RTE)
1642
1643-#define ERR_ABRT -4 /* Connection aborted. */
1644-#define ERR_RST -5 /* Connection reset. */
1645-#define ERR_CLSD -6 /* Connection closed. */
1646-#define ERR_CONN -7 /* Not connected. */
1647+#define ERR_ABRT -5 /* Connection aborted. */
1648+#define ERR_RST -6 /* Connection reset. */
1649+#define ERR_CLSD -7 /* Connection closed. */
1650+#define ERR_CONN -8 /* Not connected. */
1651
1652-#define ERR_VAL -8 /* Illegal value. */
1653+#define ERR_VAL -9 /* Illegal value. */
1654
1655-#define ERR_ARG -9 /* Illegal argument. */
1656+#define ERR_ARG -10 /* Illegal argument. */
1657
1658-#define ERR_USE -10 /* Address in use. */
1659+#define ERR_USE -11 /* Address in use. */
1660
1661-#define ERR_IF -11 /* Low-level netif error */
1662-#define ERR_ISCONN -12 /* Already connected. */
1663-
1664-#define ERR_TIMEOUT -13 /* Timeout. */
1665+#define ERR_IF -12 /* Low-level netif error */
1666+#define ERR_ISCONN -13 /* Already connected. */
1667
1668 #define ERR_INPROGRESS -14 /* Operation in progress */
1669
1670Index: src/include/lwip/mem.h
1671===================================================================
1672RCS file: /sources/lwip/lwip/src/include/lwip/mem.h,v
1673retrieving revision 1.21
1674retrieving revision 1.22
1675diff -u -p -r1.21 -r1.22
1676--- a/src/include/lwip/mem.h 4 Mar 2008 16:31:32 -0000 1.21
1677+++ b/src/include/lwip/mem.h 30 May 2008 11:37:15 -0000 1.22
1678@@ -50,16 +50,16 @@ typedef size_t mem_size_t;
1679 * allow these defines to be overridden.
1680 */
1681 #ifndef mem_free
1682-#define mem_free(x) free(x)
1683+#define mem_free free
1684 #endif
1685 #ifndef mem_malloc
1686-#define mem_malloc(x) malloc(x)
1687+#define mem_malloc malloc
1688 #endif
1689 #ifndef mem_calloc
1690-#define mem_calloc(x, y) calloc(x, y)
1691+#define mem_calloc calloc
1692 #endif
1693 #ifndef mem_realloc
1694-#define mem_realloc(x, size) (x)
1695+#define mem_realloc realloc
1696 #endif
1697 #else /* MEM_LIBC_MALLOC */
1698
1699Index: src/include/lwip/netif.h
1700===================================================================
1701RCS file: /sources/lwip/lwip/src/include/lwip/netif.h,v
1702retrieving revision 1.43
1703retrieving revision 1.46
1704diff -u -p -r1.43 -r1.46
1705--- a/src/include/lwip/netif.h 9 Oct 2007 19:59:59 -0000 1.43
1706+++ b/src/include/lwip/netif.h 19 Jun 2008 16:27:23 -0000 1.46
1707@@ -34,6 +34,8 @@
1708
1709 #include "lwip/opt.h"
1710
1711+#define ENABLE_LOOPBACK (LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF)
1712+
1713 #include "lwip/err.h"
1714
1715 #include "lwip/ip_addr.h"
1716@@ -165,6 +167,14 @@ struct netif {
1717 #if LWIP_NETIF_HWADDRHINT
1718 u8_t *addr_hint;
1719 #endif /* LWIP_NETIF_HWADDRHINT */
1720+#if ENABLE_LOOPBACK
1721+ /* List of packets to be queued for ourselves. */
1722+ struct pbuf *loop_first;
1723+ struct pbuf *loop_last;
1724+#if LWIP_LOOPBACK_MAX_PBUFS
1725+ u16_t loop_cnt_current;
1726+#endif /* LWIP_LOOPBACK_MAX_PBUFS */
1727+#endif /* ENABLE_LOOPBACK */
1728 };
1729
1730 #if LWIP_SNMP
1731@@ -242,4 +252,12 @@ void netif_set_link_callback(struct neti
1732 }
1733 #endif
1734
1735+#if ENABLE_LOOPBACK
1736+err_t netif_loop_output(struct netif *netif, struct pbuf *p, struct ip_addr *dest_ip);
1737+void netif_poll(struct netif *netif);
1738+#if !LWIP_NETIF_LOOPBACK_MULTITHREADING
1739+void netif_poll_all(void);
1740+#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
1741+#endif /* ENABLE_LOOPBACK */
1742+
1743 #endif /* __LWIP_NETIF_H__ */
1744Index: src/include/lwip/opt.h
1745===================================================================
1746RCS file: /sources/lwip/lwip/src/include/lwip/opt.h,v
1747retrieving revision 1.116
1748retrieving revision 1.122
1749diff -u -p -r1.116 -r1.122
1750--- a/src/include/lwip/opt.h 31 Jan 2008 18:19:29 -0000 1.116
1751+++ b/src/include/lwip/opt.h 30 Jun 2008 18:16:52 -0000 1.122
1752@@ -155,6 +155,27 @@
1753 #define MEMP_USE_CUSTOM_POOLS 0
1754 #endif
1755
1756+/**
1757+ * Set this to 1 if you want to free PBUF_RAM pbufs (or call mem_free()) from
1758+ * interrupt context (or another context that doesn't allow waiting for a
1759+ * semaphore).
1760+ * If set to 1, mem_malloc will be protected by a semaphore and SYS_ARCH_PROTECT,
1761+ * while mem_free will only use SYS_ARCH_PROTECT. mem_malloc SYS_ARCH_UNPROTECTs
1762+ * with each loop so that mem_free can run.
1763+ *
1764+ * ATTENTION: As you can see from the above description, this leads to dis-/
1765+ * enabling interrupts often, which can be slow! Also, on low memory, mem_malloc
1766+ * can need longer.
1767+ *
1768+ * If you don't want that, at least for NO_SYS=0, you can still use the following
1769+ * functions to enqueue a deallocation call which then runs in the tcpip_thread
1770+ * context:
1771+ * - pbuf_free_callback(p);
1772+ * - mem_free_callback(m);
1773+ */
1774+#ifndef LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT
1775+#define LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT 0
1776+#endif
1777
1778 /*
1779 ------------------------------------------------
1780@@ -815,6 +836,39 @@
1781 #define LWIP_NETIF_HWADDRHINT 0
1782 #endif
1783
1784+/**
1785+ * LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP
1786+ * address equal to the netif IP address, looping them back up the stack.
1787+ */
1788+#ifndef LWIP_NETIF_LOOPBACK
1789+#define LWIP_NETIF_LOOPBACK 0
1790+#endif
1791+
1792+/**
1793+ * LWIP_LOOPBACK_MAX_PBUFS: Maximum number of pbufs on queue for loopback
1794+ * sending for each netif (0 = disabled)
1795+ */
1796+#ifndef LWIP_LOOPBACK_MAX_PBUFS
1797+#define LWIP_LOOPBACK_MAX_PBUFS 0
1798+#endif
1799+
1800+/**
1801+ * LWIP_NETIF_LOOPBACK_MULTITHREADING: Indicates whether threading is enabled in
1802+ * the system, as netifs must change how they behave depending on this setting
1803+ * for the LWIP_NETIF_LOOPBACK option to work.
1804+ * Setting this is needed to avoid reentering non-reentrant functions like
1805+ * tcp_input().
1806+ * LWIP_NETIF_LOOPBACK_MULTITHREADING==1: Indicates that the user is using a
1807+ * multithreaded environment like tcpip.c. In this case, netif->input()
1808+ * is called directly.
1809+ * LWIP_NETIF_LOOPBACK_MULTITHREADING==0: Indicates a polling (or NO_SYS) setup.
1810+ * The packets are put on a list and netif_poll() must be called in
1811+ * the main application loop.
1812+ */
1813+#ifndef LWIP_NETIF_LOOPBACK_MULTITHREADING
1814+#define LWIP_NETIF_LOOPBACK_MULTITHREADING (!NO_SYS)
1815+#endif
1816+
1817 /*
1818 ------------------------------------
1819 ---------- LOOPIF options ----------
1820@@ -827,20 +881,16 @@
1821 #define LWIP_HAVE_LOOPIF 0
1822 #endif
1823
1824+/*
1825+ ------------------------------------
1826+ ---------- SLIPIF options ----------
1827+ ------------------------------------
1828+*/
1829 /**
1830- * LWIP_LOOPIF_MULTITHREADING: Indicates whether threading is enabled in
1831- * the system, as LOOPIF must change how it behaves depending on this setting.
1832- * Setting this is needed to avoid reentering non-reentrant functions like
1833- * tcp_input().
1834- * LWIP_LOOPIF_MULTITHREADING==1: Indicates that the user is using a
1835- * multithreaded environment like tcpip.c. In this case, netif->input()
1836- * is called directly.
1837- * LWIP_LOOPIF_MULTITHREADING==0: Indicates a polling (or NO_SYS) setup.
1838- * The packets are put on a list and loopif_poll() must be called in
1839- * the main application loop.
1840+ * LWIP_HAVE_SLIPIF==1: Support slip interface and slipif.c
1841 */
1842-#ifndef LWIP_LOOPIF_MULTITHREADING
1843-#define LWIP_LOOPIF_MULTITHREADING 1
1844+#ifndef LWIP_HAVE_SLIPIF
1845+#define LWIP_HAVE_SLIPIF 0
1846 #endif
1847
1848 /*
1849Index: src/include/lwip/sio.h
1850===================================================================
1851RCS file: /sources/lwip/lwip/src/include/lwip/sio.h,v
1852retrieving revision 1.7
1853retrieving revision 1.8
1854diff -u -p -r1.7 -r1.8
1855--- a/src/include/lwip/sio.h 6 Sep 2007 16:43:44 -0000 1.7
1856+++ b/src/include/lwip/sio.h 27 Mar 2008 18:06:02 -0000 1.8
1857@@ -32,16 +32,24 @@
1858 * It needs to be implemented by those platforms which need SLIP or PPP
1859 */
1860
1861+#ifndef __SIO_H__
1862+#define __SIO_H__
1863+
1864 #include "lwip/arch.h"
1865
1866 #ifdef __cplusplus
1867 extern "C" {
1868 #endif
1869
1870+/* If you want to define sio_fd_t elsewhere or differently,
1871+ define this in your cc.h file. */
1872 #ifndef __sio_fd_t_defined
1873 typedef void * sio_fd_t;
1874 #endif
1875
1876+/* The following functions can be defined to something else in your cc.h file
1877+ or be implemented in your custom sio.c file. */
1878+
1879 #ifndef sio_open
1880 sio_fd_t sio_open(u8_t);
1881 #endif
1882@@ -69,3 +77,5 @@ void sio_read_abort(sio_fd_t);
1883 #ifdef __cplusplus
1884 }
1885 #endif
1886+
1887+#endif /* __SIO_H__ */
1888Index: src/include/lwip/sockets.h
1889===================================================================
1890RCS file: /sources/lwip/lwip/src/include/lwip/sockets.h,v
1891retrieving revision 1.38
1892retrieving revision 1.39
1893diff -u -p -r1.38 -r1.39
1894--- a/src/include/lwip/sockets.h 2 Dec 2007 15:24:02 -0000 1.38
1895+++ b/src/include/lwip/sockets.h 26 Apr 2008 10:46:23 -0000 1.39
1896@@ -177,7 +177,22 @@ typedef struct ip_mreq {
1897 } ip_mreq;
1898 #endif /* LWIP_IGMP */
1899
1900-/* Unimplemented for now... */
1901+/*
1902+ * The Type of Service provides an indication of the abstract
1903+ * parameters of the quality of service desired. These parameters are
1904+ * to be used to guide the selection of the actual service parameters
1905+ * when transmitting a datagram through a particular network. Several
1906+ * networks offer service precedence, which somehow treats high
1907+ * precedence traffic as more important than other traffic (generally
1908+ * by accepting only traffic above a certain precedence at time of high
1909+ * load). The major choice is a three way tradeoff between low-delay,
1910+ * high-reliability, and high-throughput.
1911+ * The use of the Delay, Throughput, and Reliability indications may
1912+ * increase the cost (in some sense) of the service. In many networks
1913+ * better performance for one of these parameters is coupled with worse
1914+ * performance on another. Except for very unusual cases at most two
1915+ * of these three indications should be set.
1916+ */
1917 #define IPTOS_TOS_MASK 0x1E
1918 #define IPTOS_TOS(tos) ((tos) & IPTOS_TOS_MASK)
1919 #define IPTOS_LOWDELAY 0x10
1920@@ -187,7 +202,13 @@ typedef struct ip_mreq {
1921 #define IPTOS_MINCOST IPTOS_LOWCOST
1922
1923 /*
1924- * Definitions for IP precedence (also in ip_tos) (Unimplemented)
1925+ * The Network Control precedence designation is intended to be used
1926+ * within a network only. The actual use and control of that
1927+ * designation is up to each network. The Internetwork Control
1928+ * designation is intended for use by gateway control originators only.
1929+ * If the actual use of these precedence designations is of concern to
1930+ * a particular network, it is the responsibility of that network to
1931+ * control the access to, and use of, those precedence designations.
1932 */
1933 #define IPTOS_PREC_MASK 0xe0
1934 #define IPTOS_PREC(tos) ((tos) & IPTOS_PREC_MASK)
1935Index: src/include/lwip/stats.h
1936===================================================================
1937RCS file: /sources/lwip/lwip/src/include/lwip/stats.h,v
1938retrieving revision 1.19
1939retrieving revision 1.23
1940diff -u -p -r1.19 -r1.23
1941--- a/src/include/lwip/stats.h 28 Nov 2007 21:25:07 -0000 1.19
1942+++ b/src/include/lwip/stats.h 8 Jul 2008 09:15:57 -0000 1.23
1943@@ -57,7 +57,6 @@ extern "C" {
1944
1945 struct stats_proto {
1946 STAT_COUNTER xmit; /* Transmitted packets. */
1947- STAT_COUNTER rexmit; /* Retransmitted packets. */
1948 STAT_COUNTER recv; /* Received packets. */
1949 STAT_COUNTER fw; /* Forwarded packets. */
1950 STAT_COUNTER drop; /* Dropped packets. */
1951@@ -87,7 +86,8 @@ struct stats_mem {
1952 mem_size_t avail;
1953 mem_size_t used;
1954 mem_size_t max;
1955- mem_size_t err;
1956+ STAT_COUNTER err;
1957+ STAT_COUNTER illegal;
1958 };
1959
1960 struct stats_syselem {
1961@@ -142,64 +142,138 @@ extern struct stats_ lwip_stats;
1962 #define stats_init() /* Compatibility define, not init needed. */
1963
1964 #define STATS_INC(x) ++lwip_stats.x
1965+#define STATS_DEC(x) --lwip_stats.x
1966 #else
1967 #define stats_init()
1968 #define STATS_INC(x)
1969+#define STATS_DEC(x)
1970 #endif /* LWIP_STATS */
1971
1972 #if TCP_STATS
1973 #define TCP_STATS_INC(x) STATS_INC(x)
1974+#define TCP_STATS_DISPLAY() stats_display_proto(&lwip_stats.tcp, "TCP")
1975 #else
1976 #define TCP_STATS_INC(x)
1977+#define TCP_STATS_DISPLAY()
1978 #endif
1979
1980 #if UDP_STATS
1981 #define UDP_STATS_INC(x) STATS_INC(x)
1982+#define UDP_STATS_DISPLAY() stats_display_proto(&lwip_stats.udp, "UDP")
1983 #else
1984 #define UDP_STATS_INC(x)
1985+#define UDP_STATS_DISPLAY()
1986 #endif
1987
1988 #if ICMP_STATS
1989 #define ICMP_STATS_INC(x) STATS_INC(x)
1990+#define ICMP_STATS_DISPLAY() stats_display_proto(&lwip_stats.icmp, "ICMP")
1991 #else
1992 #define ICMP_STATS_INC(x)
1993+#define ICMP_STATS_DISPLAY()
1994 #endif
1995
1996 #if IGMP_STATS
1997 #define IGMP_STATS_INC(x) STATS_INC(x)
1998+#define IGMP_STATS_DISPLAY() stats_display_igmp(&lwip_stats.igmp)
1999 #else
2000 #define IGMP_STATS_INC(x)
2001+#define IGMP_STATS_DISPLAY()
2002 #endif
2003
2004 #if IP_STATS
2005 #define IP_STATS_INC(x) STATS_INC(x)
2006+#define IP_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip, "IP")
2007 #else
2008 #define IP_STATS_INC(x)
2009+#define IP_STATS_DISPLAY()
2010 #endif
2011
2012 #if IPFRAG_STATS
2013 #define IPFRAG_STATS_INC(x) STATS_INC(x)
2014+#define IPFRAG_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip_frag, "IP_FRAG")
2015 #else
2016 #define IPFRAG_STATS_INC(x)
2017+#define IPFRAG_STATS_DISPLAY()
2018 #endif
2019
2020 #if ETHARP_STATS
2021 #define ETHARP_STATS_INC(x) STATS_INC(x)
2022+#define ETHARP_STATS_DISPLAY() stats_display_proto(&lwip_stats.etharp, "ETHARP")
2023 #else
2024 #define ETHARP_STATS_INC(x)
2025+#define ETHARP_STATS_DISPLAY()
2026 #endif
2027
2028 #if LINK_STATS
2029 #define LINK_STATS_INC(x) STATS_INC(x)
2030+#define LINK_STATS_DISPLAY() stats_display_proto(&lwip_stats.link, "LINK")
2031 #else
2032 #define LINK_STATS_INC(x)
2033+#define LINK_STATS_DISPLAY()
2034+#endif
2035+
2036+#if MEM_STATS
2037+#define MEM_STATS_AVAIL(x, y) lwip_stats.mem.x = y
2038+#define MEM_STATS_INC(x) STATS_INC(mem.x)
2039+#define MEM_STATS_INC_USED(x, y) do { lwip_stats.mem.used += y; \
2040+ if (lwip_stats.mem.max < lwip_stats.mem.used) { \
2041+ lwip_stats.mem.max = lwip_stats.mem.used; \
2042+ } \
2043+ } while(0)
2044+#define MEM_STATS_DEC_USED(x, y) lwip_stats.mem.x -= y
2045+#define MEM_STATS_DISPLAY() stats_display_mem(&lwip_stats.mem, "HEAP")
2046+#else
2047+#define MEM_STATS_AVAIL(x, y)
2048+#define MEM_STATS_INC(x)
2049+#define MEM_STATS_INC_USED(x, y)
2050+#define MEM_STATS_DEC_USED(x, y)
2051+#define MEM_STATS_DISPLAY()
2052+#endif
2053+
2054+#if MEMP_STATS
2055+#define MEMP_STATS_AVAIL(x, i, y) lwip_stats.memp[i].x = y
2056+#define MEMP_STATS_INC(x, i) STATS_INC(memp[i].x)
2057+#define MEMP_STATS_DEC(x, i) STATS_DEC(memp[i].x)
2058+#define MEMP_STATS_INC_USED(x, i) do { ++lwip_stats.memp[i].used; \
2059+ if (lwip_stats.memp[i].max < lwip_stats.memp[i].used) { \
2060+ lwip_stats.memp[i].max = lwip_stats.memp[i].used; \
2061+ } \
2062+ } while(0)
2063+#define MEMP_STATS_DISPLAY(i) stats_display_memp(&lwip_stats.memp[i], i)
2064+#else
2065+#define MEMP_STATS_AVAIL(x, i, y)
2066+#define MEMP_STATS_INC(x, i)
2067+#define MEMP_STATS_DEC(x, i)
2068+#define MEMP_STATS_INC_USED(x, i)
2069+#define MEMP_STATS_DISPLAY(i)
2070+#endif
2071+
2072+#if SYS_STATS
2073+#define SYS_STATS_INC(x) STATS_INC(sys.x)
2074+#define SYS_STATS_DEC(x) STATS_DEC(sys.x)
2075+#define SYS_STATS_DISPLAY() stats_display_sys(&lwip_stats.sys)
2076+#else
2077+#define SYS_STATS_INC(x)
2078+#define SYS_STATS_DEC(x)
2079+#define SYS_STATS_DISPLAY()
2080 #endif
2081
2082 /* Display of statistics */
2083 #if LWIP_STATS_DISPLAY
2084 void stats_display(void);
2085+void stats_display_proto(struct stats_proto *proto, char *name);
2086+void stats_display_igmp(struct stats_igmp *igmp);
2087+void stats_display_mem(struct stats_mem *mem, char *name);
2088+void stats_display_memp(struct stats_mem *mem, int index);
2089+void stats_display_sys(struct stats_sys *sys);
2090 #else
2091 #define stats_display()
2092+#define stats_display_proto(proto, name)
2093+#define stats_display_igmp(igmp)
2094+#define stats_display_mem(mem, name)
2095+#define stats_display_memp(mem, index)
2096+#define stats_display_sys(sys)
2097 #endif /* LWIP_STATS_DISPLAY */
2098
2099 #ifdef __cplusplus
2100Index: src/include/lwip/tcpip.h
2101===================================================================
2102RCS file: /sources/lwip/lwip/src/include/lwip/tcpip.h,v
2103retrieving revision 1.24
2104retrieving revision 1.27
2105diff -u -p -r1.24 -r1.27
2106--- a/src/include/lwip/tcpip.h 12 Jan 2008 11:52:22 -0000 1.24
2107+++ b/src/include/lwip/tcpip.h 27 Jun 2008 20:34:55 -0000 1.27
2108@@ -83,7 +83,11 @@ err_t tcpip_netifapi_lock(struct netifap
2109 #endif /* LWIP_NETIF_API */
2110
2111 err_t tcpip_callback_with_block(void (*f)(void *ctx), void *ctx, u8_t block);
2112-#define tcpip_callback(f,ctx) tcpip_callback_with_block(f,ctx,1)
2113+#define tcpip_callback(f, ctx) tcpip_callback_with_block(f, ctx, 1)
2114+
2115+/* free pbufs or heap memory from another context without blocking */
2116+err_t pbuf_free_callback(struct pbuf *p);
2117+err_t mem_free_callback(void *m);
2118
2119 err_t tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg);
2120 #define tcpip_untimeout(h, arg) tcpip_timeout(0xffffffff, h, arg)
2121Index: src/include/netif/loopif.h
2122===================================================================
2123RCS file: /sources/lwip/lwip/src/include/netif/loopif.h,v
2124retrieving revision 1.7
2125retrieving revision 1.9
2126diff -u -p -r1.7 -r1.9
2127--- a/src/include/netif/loopif.h 10 May 2007 10:59:20 -0000 1.7
2128+++ b/src/include/netif/loopif.h 17 Jun 2008 20:12:22 -0000 1.9
2129@@ -32,6 +32,7 @@
2130 #ifndef __NETIF_LOOPIF_H__
2131 #define __NETIF_LOOPIF_H__
2132
2133+#include "lwip/opt.h"
2134 #include "lwip/netif.h"
2135 #include "lwip/err.h"
2136
2137@@ -39,9 +40,9 @@
2138 extern "C" {
2139 #endif
2140
2141-#if !LWIP_LOOPIF_MULTITHREADING
2142-void loopif_poll(struct netif *netif);
2143-#endif
2144+#if !LWIP_NETIF_LOOPBACK_MULTITHREADING
2145+#define loopif_poll netif_poll
2146+#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
2147
2148 err_t loopif_init(struct netif *netif);
2149
2150Index: src/netif/etharp.c
2151===================================================================
2152RCS file: /sources/lwip/lwip/src/netif/etharp.c,v
2153retrieving revision 1.145
2154retrieving revision 1.148
2155diff -u -p -r1.145 -r1.148
2156--- a/src/netif/etharp.c 4 Mar 2008 13:41:24 -0000 1.145
2157+++ b/src/netif/etharp.c 19 Jun 2008 16:40:59 -0000 1.148
2158@@ -353,7 +353,7 @@ find_entry(struct ip_addr *ipaddr, u8_t
2159 * 1) empty entry
2160 * 2) oldest stable entry
2161 * 3) oldest pending entry without queued packets
2162- * 4) oldest pending entry without queued packets
2163+ * 4) oldest pending entry with queued packets
2164 *
2165 * { ETHARP_TRY_HARD is set at this point }
2166 */
2167@@ -1130,7 +1130,14 @@ ethernet_input(struct pbuf *p, struct ne
2168
2169 /* points to packet payload, which starts with an Ethernet header */
2170 ethhdr = p->payload;
2171-
2172+ LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE,
2173+ ("ethernet_input: dest:%02x:%02x:%02x:%02x:%02x:%02x, src:%02x:%02x:%02x:%02x:%02x:%02x, type:%2hx\n",
2174+ (unsigned)ethhdr->dest.addr[0], (unsigned)ethhdr->dest.addr[1], (unsigned)ethhdr->dest.addr[2],
2175+ (unsigned)ethhdr->dest.addr[3], (unsigned)ethhdr->dest.addr[4], (unsigned)ethhdr->dest.addr[5],
2176+ (unsigned)ethhdr->src.addr[0], (unsigned)ethhdr->src.addr[1], (unsigned)ethhdr->src.addr[2],
2177+ (unsigned)ethhdr->src.addr[3], (unsigned)ethhdr->src.addr[4], (unsigned)ethhdr->src.addr[5],
2178+ (unsigned)htons(ethhdr->type)));
2179+
2180 switch (htons(ethhdr->type)) {
2181 /* IP packet? */
2182 case ETHTYPE_IP:
2183@@ -1165,6 +1172,8 @@ ethernet_input(struct pbuf *p, struct ne
2184 #endif /* PPPOE_SUPPORT */
2185
2186 default:
2187+ ETHARP_STATS_INC(etharp.proterr);
2188+ ETHARP_STATS_INC(etharp.drop);
2189 pbuf_free(p);
2190 p = NULL;
2191 break;
2192Index: src/netif/loopif.c
2193===================================================================
2194RCS file: /sources/lwip/lwip/src/netif/loopif.c,v
2195retrieving revision 1.26
2196retrieving revision 1.27
2197diff -u -p -r1.26 -r1.27
2198--- a/src/netif/loopif.c 31 Aug 2007 10:14:09 -0000 1.26
2199+++ b/src/netif/loopif.c 12 Jun 2008 20:10:10 -0000 1.27
2200@@ -40,149 +40,8 @@
2201 #if LWIP_HAVE_LOOPIF
2202
2203 #include "netif/loopif.h"
2204-#include "lwip/pbuf.h"
2205 #include "lwip/snmp.h"
2206
2207-#include <string.h>
2208-
2209-#if !LWIP_LOOPIF_MULTITHREADING
2210-
2211-#include "lwip/sys.h"
2212-#include "lwip/mem.h"
2213-
2214-/* helper struct for the linked list of pbufs */
2215-struct loopif_private {
2216- struct pbuf *first;
2217- struct pbuf *last;
2218-};
2219-
2220-/**
2221- * Call loopif_poll() in the main loop of your application. This is to prevent
2222- * reentering non-reentrant functions like tcp_input(). Packets passed to
2223- * loopif_output() are put on a list that is passed to netif->input() by
2224- * loopif_poll().
2225- *
2226- * @param netif the lwip network interface structure for this loopif
2227- */
2228-void
2229-loopif_poll(struct netif *netif)
2230-{
2231- SYS_ARCH_DECL_PROTECT(lev);
2232- struct pbuf *in, *in_end;
2233- struct loopif_private *priv = (struct loopif_private*)netif->state;
2234-
2235- LWIP_ERROR("priv != NULL", (priv != NULL), return;);
2236-
2237- do {
2238- /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */
2239- SYS_ARCH_PROTECT(lev);
2240- in = priv->first;
2241- if(in) {
2242- in_end = in;
2243- while(in_end->len != in_end->tot_len) {
2244- LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL);
2245- in_end = in_end->next;
2246- }
2247- /* 'in_end' now points to the last pbuf from 'in' */
2248- if(in_end == priv->last) {
2249- /* this was the last pbuf in the list */
2250- priv->first = priv->last = NULL;
2251- } else {
2252- /* pop the pbuf off the list */
2253- priv->first = in_end->next;
2254- LWIP_ASSERT("should not be null since first != last!", priv->first != NULL);
2255- }
2256- }
2257- SYS_ARCH_UNPROTECT(lev);
2258-
2259- if(in != NULL) {
2260- if(in_end->next != NULL) {
2261- /* De-queue the pbuf from its successors on the 'priv' list. */
2262- in_end->next = NULL;
2263- }
2264- if(netif->input(in, netif) != ERR_OK) {
2265- pbuf_free(in);
2266- }
2267- /* Don't reference the packet any more! */
2268- in = NULL;
2269- in_end = NULL;
2270- }
2271- /* go on while there is a packet on the list */
2272- } while(priv->first != NULL);
2273-}
2274-#endif /* LWIP_LOOPIF_MULTITHREADING */
2275-
2276-/**
2277- * Send an IP packet over the loopback interface.
2278- * The pbuf is simply copied and handed back to netif->input.
2279- * In multithreaded mode, this is done directly since netif->input must put
2280- * the packet on a queue.
2281- * In callback mode, the packet is put on an internal queue and is fed to
2282- * netif->input by loopif_poll().
2283- *
2284- * @param netif the lwip network interface structure for this loopif
2285- * @param p the (IP) packet to 'send'
2286- * @param ipaddr the ip address to send the packet to (not used for loopif)
2287- * @return ERR_OK if the packet has been sent
2288- * ERR_MEM if the pbuf used to copy the packet couldn't be allocated
2289- */
2290-static err_t
2291-loopif_output(struct netif *netif, struct pbuf *p,
2292- struct ip_addr *ipaddr)
2293-{
2294-#if !LWIP_LOOPIF_MULTITHREADING
2295- SYS_ARCH_DECL_PROTECT(lev);
2296- struct loopif_private *priv;
2297- struct pbuf *last;
2298-#endif /* LWIP_LOOPIF_MULTITHREADING */
2299- struct pbuf *r;
2300- err_t err;
2301-
2302- LWIP_UNUSED_ARG(ipaddr);
2303-
2304- /* Allocate a new pbuf */
2305- r = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
2306- if (r == NULL) {
2307- return ERR_MEM;
2308- }
2309-
2310- /* Copy the whole pbuf queue p into the single pbuf r */
2311- if ((err = pbuf_copy(r, p)) != ERR_OK) {
2312- pbuf_free(r);
2313- r = NULL;
2314- return err;
2315- }
2316-
2317-#if LWIP_LOOPIF_MULTITHREADING
2318- /* Multithreading environment, netif->input() is supposed to put the packet
2319- into a mailbox, so we can safely call it here without risking to re-enter
2320- functions that are not reentrant (TCP!!!) */
2321- if(netif->input(r, netif) != ERR_OK) {
2322- pbuf_free(r);
2323- r = NULL;
2324- }
2325-#else /* LWIP_LOOPIF_MULTITHREADING */
2326- /* Raw API without threads: put the packet on a linked list which gets emptied
2327- through calling loopif_poll(). */
2328- priv = (struct loopif_private*)netif->state;
2329-
2330- /* let last point to the last pbuf in chain r */
2331- for (last = r; last->next != NULL; last = last->next);
2332- SYS_ARCH_PROTECT(lev);
2333- if(priv->first != NULL) {
2334- LWIP_ASSERT("if first != NULL, last must also be != NULL", priv->last != NULL);
2335- priv->last->next = r;
2336- priv->last = last;
2337- } else {
2338- priv->first = r;
2339- priv->last = last;
2340- }
2341- SYS_ARCH_UNPROTECT(lev);
2342-#endif /* LWIP_LOOPIF_MULTITHREADING */
2343-
2344- return ERR_OK;
2345-}
2346-
2347 /**
2348 * Initialize a lwip network interface structure for a loopback interface
2349 *
2350@@ -193,16 +52,6 @@ loopif_output(struct netif *netif, struc
2351 err_t
2352 loopif_init(struct netif *netif)
2353 {
2354-#if !LWIP_LOOPIF_MULTITHREADING
2355- struct loopif_private *priv;
2356-
2357- priv = (struct loopif_private*)mem_malloc(sizeof(struct loopif_private));
2358- if(priv == NULL)
2359- return ERR_MEM;
2360- priv->first = priv->last = NULL;
2361- netif->state = priv;
2362-#endif /* LWIP_LOOPIF_MULTITHREADING */
2363-
2364 /* initialize the snmp variables and counters inside the struct netif
2365 * ifSpeed: no assumption can be made!
2366 */
2367@@ -210,7 +59,7 @@ loopif_init(struct netif *netif)
2368
2369 netif->name[0] = 'l';
2370 netif->name[1] = 'o';
2371- netif->output = loopif_output;
2372+ netif->output = netif_loop_output;
2373 return ERR_OK;
2374 }
2375
2376Index: src/netif/slipif.c
2377===================================================================
2378RCS file: /sources/lwip/lwip/src/netif/slipif.c,v
2379retrieving revision 1.29
2380retrieving revision 1.30
2381diff -u -p -r1.29 -r1.30
2382--- a/src/netif/slipif.c 30 Nov 2007 17:22:21 -0000 1.29
2383+++ b/src/netif/slipif.c 17 Jun 2008 20:14:05 -0000 1.30
2384@@ -44,6 +44,9 @@
2385
2386 #include "netif/slipif.h"
2387 #include "lwip/opt.h"
2388+
2389+#if LWIP_HAVE_SLIPIF
2390+
2391 #include "lwip/def.h"
2392 #include "lwip/pbuf.h"
2393 #include "lwip/sys.h"
2394@@ -273,3 +276,4 @@ slipif_init(struct netif *netif)
2395 sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop, netif, SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);
2396 return ERR_OK;
2397 }
2398+#endif /* LWIP_HAVE_SLIPIF */
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2025-05-31 05:09:34 +0000