ReactOS  0.4.15-dev-3428-g0609db5
api_lib.c
Go to the documentation of this file.
1 
7 /*
8  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without modification,
12  * are permitted provided that the following conditions are met:
13  *
14  * 1. Redistributions of source code must retain the above copyright notice,
15  * this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright notice,
17  * this list of conditions and the following disclaimer in the documentation
18  * and/or other materials provided with the distribution.
19  * 3. The name of the author may not be used to endorse or promote products
20  * derived from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
27  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
31  * OF SUCH DAMAGE.
32  *
33  * This file is part of the lwIP TCP/IP stack.
34  *
35  * Author: Adam Dunkels <adam@sics.se>
36  *
37  */
38 
39 /* This is the part of the API that is linked with
40  the application */
41 
42 #include "lwip/opt.h"
43 
44 #if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */
45 
46 #include "lwip/api.h"
47 #include "lwip/tcpip.h"
48 #include "lwip/memp.h"
49 
50 #include "lwip/ip.h"
51 #include "lwip/raw.h"
52 #include "lwip/udp.h"
53 #include "lwip/tcp.h"
54 
55 #include <string.h>
56 
67 struct netconn*
68 netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback)
69 {
70  struct netconn *conn;
71  struct api_msg msg;
72 
73  conn = netconn_alloc(t, callback);
74  if (conn != NULL) {
75  msg.function = do_newconn;
76  msg.msg.msg.n.proto = proto;
77  msg.msg.conn = conn;
78  if (TCPIP_APIMSG(&msg) != ERR_OK) {
79  LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);
80  LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));
81  LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));
82 #if LWIP_TCP
83  LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));
84 #endif /* LWIP_TCP */
85  sys_sem_free(&conn->op_completed);
86  sys_mbox_free(&conn->recvmbox);
87  memp_free(MEMP_NETCONN, conn);
88  return NULL;
89  }
90  }
91  return conn;
92 }
93 
102 err_t
103 netconn_delete(struct netconn *conn)
104 {
105  struct api_msg msg;
106 
107  /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */
108  if (conn == NULL) {
109  return ERR_OK;
110  }
111 
112  msg.function = do_delconn;
113  msg.msg.conn = conn;
114  tcpip_apimsg(&msg);
115 
116  netconn_free(conn);
117 
118  /* don't care for return value of do_delconn since it only calls void functions */
119 
120  return ERR_OK;
121 }
122 
134 err_t
135 netconn_getaddr(struct netconn *conn, ip_addr_t *addr, u16_t *port, u8_t local)
136 {
137  struct api_msg msg;
138  err_t err;
139 
140  LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;);
141  LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;);
142  LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;);
143 
144  msg.function = do_getaddr;
145  msg.msg.conn = conn;
146  msg.msg.msg.ad.ipaddr = addr;
147  msg.msg.msg.ad.port = port;
148  msg.msg.msg.ad.local = local;
149  err = TCPIP_APIMSG(&msg);
150 
151  NETCONN_SET_SAFE_ERR(conn, err);
152  return err;
153 }
154 
165 err_t
166 netconn_bind(struct netconn *conn, ip_addr_t *addr, u16_t port)
167 {
168  struct api_msg msg;
169  err_t err;
170 
171  LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;);
172 
173  msg.function = do_bind;
174  msg.msg.conn = conn;
175  msg.msg.msg.bc.ipaddr = addr;
176  msg.msg.msg.bc.port = port;
177  err = TCPIP_APIMSG(&msg);
178 
179  NETCONN_SET_SAFE_ERR(conn, err);
180  return err;
181 }
182 
191 err_t
192 netconn_connect(struct netconn *conn, ip_addr_t *addr, u16_t port)
193 {
194  struct api_msg msg;
195  err_t err;
196 
197  LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;);
198 
199  msg.function = do_connect;
200  msg.msg.conn = conn;
201  msg.msg.msg.bc.ipaddr = addr;
202  msg.msg.msg.bc.port = port;
203  /* This is the only function which need to not block tcpip_thread */
204  err = tcpip_apimsg(&msg);
205 
206  NETCONN_SET_SAFE_ERR(conn, err);
207  return err;
208 }
209 
216 err_t
217 netconn_disconnect(struct netconn *conn)
218 {
219  struct api_msg msg;
220  err_t err;
221 
222  LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;);
223 
224  msg.function = do_disconnect;
225  msg.msg.conn = conn;
226  err = TCPIP_APIMSG(&msg);
227 
228  NETCONN_SET_SAFE_ERR(conn, err);
229  return err;
230 }
231 
240 err_t
241 netconn_listen_with_backlog(struct netconn *conn, u8_t backlog)
242 {
243 #if LWIP_TCP
244  struct api_msg msg;
245  err_t err;
246 
247  /* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */
248  LWIP_UNUSED_ARG(backlog);
249 
250  LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;);
251 
252  msg.function = do_listen;
253  msg.msg.conn = conn;
254 #if TCP_LISTEN_BACKLOG
255  msg.msg.msg.lb.backlog = backlog;
256 #endif /* TCP_LISTEN_BACKLOG */
257  err = TCPIP_APIMSG(&msg);
258 
259  NETCONN_SET_SAFE_ERR(conn, err);
260  return err;
261 #else /* LWIP_TCP */
262  LWIP_UNUSED_ARG(conn);
263  LWIP_UNUSED_ARG(backlog);
264  return ERR_ARG;
265 #endif /* LWIP_TCP */
266 }
267 
276 err_t
277 netconn_accept(struct netconn *conn, struct netconn **new_conn)
278 {
279 #if LWIP_TCP
280  struct netconn *newconn;
281  err_t err;
282 #if TCP_LISTEN_BACKLOG
283  struct api_msg msg;
284 #endif /* TCP_LISTEN_BACKLOG */
285 
286  LWIP_ERROR("netconn_accept: invalid pointer", (new_conn != NULL), return ERR_ARG;);
287  *new_conn = NULL;
288  LWIP_ERROR("netconn_accept: invalid conn", (conn != NULL), return ERR_ARG;);
289  LWIP_ERROR("netconn_accept: invalid acceptmbox", sys_mbox_valid(&conn->acceptmbox), return ERR_ARG;);
290 
291  err = conn->last_err;
292  if (ERR_IS_FATAL(err)) {
293  /* don't recv on fatal errors: this might block the application task
294  waiting on acceptmbox forever! */
295  return err;
296  }
297 
298 #if LWIP_SO_RCVTIMEO
299  if (sys_arch_mbox_fetch(&conn->acceptmbox, (void **)&newconn, conn->recv_timeout) == SYS_ARCH_TIMEOUT) {
300  NETCONN_SET_SAFE_ERR(conn, ERR_TIMEOUT);
301  return ERR_TIMEOUT;
302  }
303 #else
304  sys_arch_mbox_fetch(&conn->acceptmbox, (void **)&newconn, 0);
305 #endif /* LWIP_SO_RCVTIMEO*/
306  /* Register event with callback */
307  API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);
308 
309  if (newconn == NULL) {
310  /* connection has been aborted */
311  NETCONN_SET_SAFE_ERR(conn, ERR_ABRT);
312  return ERR_ABRT;
313  }
314 #if TCP_LISTEN_BACKLOG
315  /* Let the stack know that we have accepted the connection. */
316  msg.function = do_recv;
317  msg.msg.conn = conn;
318  /* don't care for the return value of do_recv */
319  TCPIP_APIMSG(&msg);
320 #endif /* TCP_LISTEN_BACKLOG */
321 
322  *new_conn = newconn;
323  /* don't set conn->last_err: it's only ERR_OK, anyway */
324  return ERR_OK;
325 #else /* LWIP_TCP */
326  LWIP_UNUSED_ARG(conn);
327  LWIP_UNUSED_ARG(new_conn);
328  return ERR_ARG;
329 #endif /* LWIP_TCP */
330 }
331 
341 static err_t
342 netconn_recv_data(struct netconn *conn, void **new_buf)
343 {
344  void *buf = NULL;
345  u16_t len;
346  err_t err;
347 #if LWIP_TCP
348  struct api_msg msg;
349 #endif /* LWIP_TCP */
350 
351  LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;);
352  *new_buf = NULL;
353  LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;);
354  LWIP_ERROR("netconn_accept: invalid recvmbox", sys_mbox_valid(&conn->recvmbox), return ERR_CONN;);
355 
356  err = conn->last_err;
357  if (ERR_IS_FATAL(err)) {
358  /* don't recv on fatal errors: this might block the application task
359  waiting on recvmbox forever! */
360  /* @todo: this does not allow us to fetch data that has been put into recvmbox
361  before the fatal error occurred - is that a problem? */
362  return err;
363  }
364 
365 #if LWIP_SO_RCVTIMEO
366  if (sys_arch_mbox_fetch(&conn->recvmbox, &buf, conn->recv_timeout) == SYS_ARCH_TIMEOUT) {
367  NETCONN_SET_SAFE_ERR(conn, ERR_TIMEOUT);
368  return ERR_TIMEOUT;
369  }
370 #else
371  sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0);
372 #endif /* LWIP_SO_RCVTIMEO*/
373 
374 #if LWIP_TCP
375 #if (LWIP_UDP || LWIP_RAW)
376  if (conn->type == NETCONN_TCP)
377 #endif /* (LWIP_UDP || LWIP_RAW) */
378  {
379  if (!netconn_get_noautorecved(conn) || (buf == NULL)) {
380  /* Let the stack know that we have taken the data. */
381  /* TODO: Speedup: Don't block and wait for the answer here
382  (to prevent multiple thread-switches). */
383  msg.function = do_recv;
384  msg.msg.conn = conn;
385  if (buf != NULL) {
386  msg.msg.msg.r.len = ((struct pbuf *)buf)->tot_len;
387  } else {
388  msg.msg.msg.r.len = 1;
389  }
390  /* don't care for the return value of do_recv */
391  TCPIP_APIMSG(&msg);
392  }
393 
394  /* If we are closed, we indicate that we no longer wish to use the socket */
395  if (buf == NULL) {
396  API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);
397  /* Avoid to lose any previous error code */
398  NETCONN_SET_SAFE_ERR(conn, ERR_CLSD);
399  return ERR_CLSD;
400  }
401  len = ((struct pbuf *)buf)->tot_len;
402  }
403 #endif /* LWIP_TCP */
404 #if LWIP_TCP && (LWIP_UDP || LWIP_RAW)
405  else
406 #endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */
407 #if (LWIP_UDP || LWIP_RAW)
408  {
409  LWIP_ASSERT("buf != NULL", buf != NULL);
410  len = netbuf_len((struct netbuf *)buf);
411  }
412 #endif /* (LWIP_UDP || LWIP_RAW) */
413 
414 #if LWIP_SO_RCVBUF
415  SYS_ARCH_DEC(conn->recv_avail, len);
416 #endif /* LWIP_SO_RCVBUF */
417  /* Register event with callback */
418  API_EVENT(conn, NETCONN_EVT_RCVMINUS, len);
419 
420  LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv_data: received %p, len=%"U16_F"\n", buf, len));
421 
422  *new_buf = buf;
423  /* don't set conn->last_err: it's only ERR_OK, anyway */
424  return ERR_OK;
425 }
426 
436 err_t
437 netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf)
438 {
439  LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL) &&
440  netconn_type(conn) == NETCONN_TCP, return ERR_ARG;);
441 
442  return netconn_recv_data(conn, (void **)new_buf);
443 }
444 
453 err_t
454 netconn_recv(struct netconn *conn, struct netbuf **new_buf)
455 {
456 #if LWIP_TCP
457  struct netbuf *buf = NULL;
458  err_t err;
459 #endif /* LWIP_TCP */
460 
461  LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;);
462  *new_buf = NULL;
463  LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;);
464  LWIP_ERROR("netconn_accept: invalid recvmbox", sys_mbox_valid(&conn->recvmbox), return ERR_CONN;);
465 
466 #if LWIP_TCP
467 #if (LWIP_UDP || LWIP_RAW)
468  if (conn->type == NETCONN_TCP)
469 #endif /* (LWIP_UDP || LWIP_RAW) */
470  {
471  struct pbuf *p = NULL;
472  /* This is not a listening netconn, since recvmbox is set */
473 
474  buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);
475  if (buf == NULL) {
476  NETCONN_SET_SAFE_ERR(conn, ERR_MEM);
477  return ERR_MEM;
478  }
479 
480  err = netconn_recv_data(conn, (void **)&p);
481  if (err != ERR_OK) {
482  memp_free(MEMP_NETBUF, buf);
483  return err;
484  }
485  LWIP_ASSERT("p != NULL", p != NULL);
486 
487  buf->p = p;
488  buf->ptr = p;
489  buf->port = 0;
490  ip_addr_set_any(&buf->addr);
491  *new_buf = buf;
492  /* don't set conn->last_err: it's only ERR_OK, anyway */
493  return ERR_OK;
494  }
495 #endif /* LWIP_TCP */
496 #if LWIP_TCP && (LWIP_UDP || LWIP_RAW)
497  else
498 #endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */
499  {
500 #if (LWIP_UDP || LWIP_RAW)
501  return netconn_recv_data(conn, (void **)new_buf);
502 #endif /* (LWIP_UDP || LWIP_RAW) */
503  }
504 }
505 
516 void
517 netconn_recved(struct netconn *conn, u32_t length)
518 {
519 #if LWIP_TCP
520  if ((conn != NULL) && (conn->type == NETCONN_TCP) &&
521  (netconn_get_noautorecved(conn))) {
522  struct api_msg msg;
523  /* Let the stack know that we have taken the data. */
524  /* TODO: Speedup: Don't block and wait for the answer here
525  (to prevent multiple thread-switches). */
526  msg.function = do_recv;
527  msg.msg.conn = conn;
528  msg.msg.msg.r.len = length;
529  /* don't care for the return value of do_recv */
530  TCPIP_APIMSG(&msg);
531  }
532 #else /* LWIP_TCP */
533  LWIP_UNUSED_ARG(conn);
535 #endif /* LWIP_TCP */
536 }
537 
548 err_t
549 netconn_sendto(struct netconn *conn, struct netbuf *buf, ip_addr_t *addr, u16_t port)
550 {
551  if (buf != NULL) {
552  ip_addr_set(&buf->addr, addr);
553  buf->port = port;
554  return netconn_send(conn, buf);
555  }
556  return ERR_VAL;
557 }
558 
566 err_t
567 netconn_send(struct netconn *conn, struct netbuf *buf)
568 {
569  struct api_msg msg;
570  err_t err;
571 
572  LWIP_ERROR("netconn_send: invalid conn", (conn != NULL), return ERR_ARG;);
573 
574  LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %"U16_F" bytes\n", buf->p->tot_len));
575  msg.function = do_send;
576  msg.msg.conn = conn;
577  msg.msg.msg.b = buf;
578  err = TCPIP_APIMSG(&msg);
579 
580  NETCONN_SET_SAFE_ERR(conn, err);
581  return err;
582 }
583 
597 err_t
598 netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size,
599  u8_t apiflags, size_t *bytes_written)
600 {
601  struct api_msg msg;
602  err_t err;
603  u8_t dontblock;
604 
605  LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;);
606  LWIP_ERROR("netconn_write: invalid conn->type", (conn->type == NETCONN_TCP), return ERR_VAL;);
607  if (size == 0) {
608  return ERR_OK;
609  }
610  dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK);
611  if (dontblock && !bytes_written) {
612  /* This implies netconn_write() cannot be used for non-blocking send, since
613  it has no way to return the number of bytes written. */
614  return ERR_VAL;
615  }
616 
617  /* non-blocking write sends as much */
618  msg.function = do_write;
619  msg.msg.conn = conn;
620  msg.msg.msg.w.dataptr = dataptr;
621  msg.msg.msg.w.apiflags = apiflags;
622  msg.msg.msg.w.len = size;
623 #if LWIP_SO_SNDTIMEO
624  if (conn->send_timeout != 0) {
625  /* get the time we started, which is later compared to
626  sys_now() + conn->send_timeout */
627  msg.msg.msg.w.time_started = sys_now();
628  } else {
629  msg.msg.msg.w.time_started = 0;
630  }
631 #endif /* LWIP_SO_SNDTIMEO */
632 
633  /* For locking the core: this _can_ be delayed on low memory/low send buffer,
634  but if it is, this is done inside api_msg.c:do_write(), so we can use the
635  non-blocking version here. */
636  err = TCPIP_APIMSG(&msg);
637  if ((err == ERR_OK) && (bytes_written != NULL)) {
638  if (dontblock
640  || (conn->send_timeout != 0)
641 #endif /* LWIP_SO_SNDTIMEO */
642  ) {
643  /* nonblocking write: maybe the data has been sent partly */
644  *bytes_written = msg.msg.msg.w.len;
645  } else {
646  /* blocking call succeeded: all data has been sent if it */
647  *bytes_written = size;
648  }
649  }
650 
651  NETCONN_SET_SAFE_ERR(conn, err);
652  return err;
653 }
654 
662 static err_t
663 netconn_close_shutdown(struct netconn *conn, u8_t how)
664 {
665  struct api_msg msg;
666  err_t err;
667 
668  LWIP_ERROR("netconn_close: invalid conn", (conn != NULL), return ERR_ARG;);
669 
670  msg.function = do_close;
671  msg.msg.conn = conn;
672  /* shutting down both ends is the same as closing */
673  msg.msg.msg.sd.shut = how;
674  /* because of the LWIP_TCPIP_CORE_LOCKING implementation of do_close,
675  don't use TCPIP_APIMSG here */
676  err = tcpip_apimsg(&msg);
677 
678  NETCONN_SET_SAFE_ERR(conn, err);
679  return err;
680 }
681 
688 err_t
689 netconn_close(struct netconn *conn)
690 {
691  /* shutting down both ends is the same as closing */
692  return netconn_close_shutdown(conn, NETCONN_SHUT_RDWR);
693 }
694 
701 err_t
702 netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx)
703 {
704  return netconn_close_shutdown(conn, (shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0));
705 }
706 
707 #if LWIP_IGMP
708 
718 err_t
719 netconn_join_leave_group(struct netconn *conn,
720  ip_addr_t *multiaddr,
721  ip_addr_t *netif_addr,
722  enum netconn_igmp join_or_leave)
723 {
724  struct api_msg msg;
725  err_t err;
726 
727  LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;);
728 
729  msg.function = do_join_leave_group;
730  msg.msg.conn = conn;
731  msg.msg.msg.jl.multiaddr = multiaddr;
732  msg.msg.msg.jl.netif_addr = netif_addr;
733  msg.msg.msg.jl.join_or_leave = join_or_leave;
734  err = TCPIP_APIMSG(&msg);
735 
736  NETCONN_SET_SAFE_ERR(conn, err);
737  return err;
738 }
739 #endif /* LWIP_IGMP */
740 
741 #if LWIP_DNS
742 
752 err_t
753 netconn_gethostbyname(const char *name, ip_addr_t *addr)
754 {
755  struct dns_api_msg msg;
756  err_t err;
757  sys_sem_t sem;
758 
759  LWIP_ERROR("netconn_gethostbyname: invalid name", (name != NULL), return ERR_ARG;);
760  LWIP_ERROR("netconn_gethostbyname: invalid addr", (addr != NULL), return ERR_ARG;);
761 
762  err = sys_sem_new(&sem, 0);
763  if (err != ERR_OK) {
764  return err;
765  }
766 
767  msg.name = name;
768  msg.addr = addr;
769  msg.err = &err;
770  msg.sem = &sem;
771 
772  tcpip_callback(do_gethostbyname, &msg);
773  sys_sem_wait(&sem);
774  sys_sem_free(&sem);
775 
776  return err;
777 }
778 #endif /* LWIP_DNS*/
779 
780 #endif /* LWIP_NETCONN */
#define ERR_CONN
Definition: err.h:68
#define ERR_ARG
Definition: err.h:70
#define tcpip_callback(f, ctx)
Definition: tcpip.h:102
u32_t sys_now(void)
Definition: sys_arch.c:28
#define ERR_CLSD
Definition: err.h:67
NTSTATUS do_write(device_extension *Vcb, PIRP Irp)
Definition: flushthread.c:7789
#define SYS_ARCH_DEC(var, val)
Definition: sys.h:306
int sys_mbox_valid(sys_mbox_t *mbox)
Definition: sys_arch.c:146
#define ERR_IS_FATAL(e)
Definition: err.h:63
GLdouble GLdouble t
Definition: gl.h:2047
typedefPACK_STRUCT_END struct ip_addr ip_addr_t
Definition: ip_addr.h:64
#define SYS_ARCH_TIMEOUT
Definition: sys.h:78
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
Definition: sys_arch.c:182
#define LWIP_ASSERT(message, assertion)
Definition: debug.h:66
void memp_free(memp_t type, void *mem)
Definition: memp.c:435
#define ERR_TIMEOUT
Definition: err.h:55
#define sys_sem_wait(sem)
Definition: sys.h:153
void sys_sem_free(sys_sem_t *sem)
Definition: sys_arch.c:77
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define ERR_VAL
Definition: err.h:58
static void do_close(SOCKET)
err_t sys_sem_new(sys_sem_t *sem, u8_t count)
Definition: sys_arch.c:51
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
int sys_sem_valid(sys_sem_t *sem)
Definition: sys_arch.c:66
#define netbuf_len(buf)
Definition: netbuf.h:83
s8_t err_t
Definition: err.h:47
#define LWIP_DEBUGF(debug, message)
Definition: debug.h:95
#define U16_F
Definition: cc.h:36
BOOL netconn_send(struct netconn *conn, const void *msg, size_t len, int *sent)
Definition: net.c:424
#define ERR_OK
Definition: err.h:52
GLsizeiptr size
Definition: glext.h:5919
Definition: pbuf.h:79
unsigned long u32_t
Definition: cc.h:25
char * name
Definition: compiler.c:66
BOOL netconn_recv(struct netconn *conn, void *buf, size_t len, int flags, int *recvd)
Definition: net.c:539
GLenum const GLvoid * addr
Definition: glext.h:9621
GLenum GLsizei len
Definition: glext.h:6722
#define err(...)
void netconn_close(struct netconn *conn)
Definition: net.c:250
#define TCPIP_APIMSG(m)
Definition: tcpip.h:69
#define API_LIB_DEBUG
Definition: opt.h:1919
#define local
Definition: zutil.h:30
#define ip_addr_set(dest, src)
Definition: ip_addr.h:164
static void do_bind(SOCKET s, struct sockaddr *addr, int addrlen)
Definition: sock.c:508
#define LWIP_ERROR(message, expression, handler)
Definition: debug.h:74
static HANDLE sem
Definition: sync.c:674
#define ERR_MEM
Definition: fontsub.h:52
unsigned char u8_t
Definition: cc.h:23
#define NULL
Definition: types.h:112
Definition: types.h:144
#define msg(x)
Definition: auth_time.c:54
Definition: name.c:38
int const JOCTET * dataptr
Definition: jpeglib.h:1030
#define ERR_ABRT
Definition: err.h:65
unsigned short u16_t
Definition: cc.h:24
static IPrintDialogCallback callback
Definition: printdlg.c:326
void * memp_malloc(memp_t type)
Definition: memp.c:390
GLfloat GLfloat p
Definition: glext.h:8902
USHORT port
Definition: uri.c:228
#define LWIP_UNUSED_ARG(x)
Definition: arch.h:73
void sys_mbox_free(sys_mbox_t *mbox)
Definition: sys_arch.c:157
#define LWIP_SO_SNDTIMEO
Definition: opt.h:1460
#define ip_addr_set_any(ipaddr)
Definition: ip_addr.h:170
GLuint const GLchar * name
Definition: glext.h:6031