URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [lwIP_MCF5235_GCC/] [lwip/] [src/] [api/] [api_lib.c] - Blame information for rev 583

Details | Compare with Previous | View Log


/*
 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 *
 * Author: Adam Dunkels <adam@sics.se>
 *
 */
 
/* This is the part of the API that is linked with
   the application */
 
#include "lwip/opt.h"
#include "lwip/api.h"
#include "lwip/api_msg.h"
#include "lwip/memp.h"
 
 
struct
netbuf *netbuf_new(void)
{
  struct netbuf *buf;
 
  buf = memp_malloc(MEMP_NETBUF);
  if (buf != NULL) {
    buf->p = NULL;
    buf->ptr = NULL;
    return buf;
  } else {
    return NULL;
  }
}
 
void
netbuf_delete(struct netbuf *buf)
{
  if (buf != NULL) {
    if (buf->p != NULL) {
      pbuf_free(buf->p);
      buf->p = buf->ptr = NULL;
    }
    memp_free(MEMP_NETBUF, buf);
  }
}
 
void *
netbuf_alloc(struct netbuf *buf, u16_t size)
{
  /* Deallocate any previously allocated memory. */
  if (buf->p != NULL) {
    pbuf_free(buf->p);
  }
  buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM);
  if (buf->p == NULL) {
     return NULL;
  }
  buf->ptr = buf->p;
  return buf->p->payload;
}
 
void
netbuf_free(struct netbuf *buf)
{
  if (buf->p != NULL) {
    pbuf_free(buf->p);
  }
  buf->p = buf->ptr = NULL;
}
 
void
netbuf_ref(struct netbuf *buf, void *dataptr, u16_t size)
{
  if (buf->p != NULL) {
    pbuf_free(buf->p);
  }
  buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF);
  buf->p->payload = dataptr;
  buf->p->len = buf->p->tot_len = size;
  buf->ptr = buf->p;
}
 
void
netbuf_chain(struct netbuf *head, struct netbuf *tail)
{
  pbuf_chain(head->p, tail->p);
  head->ptr = head->p;
  memp_free(MEMP_NETBUF, tail);
}
 
u16_t
netbuf_len(struct netbuf *buf)
{
  return buf->p->tot_len;
}
 
err_t
netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len)
{
  if (buf->ptr == NULL) {
    return ERR_BUF;
  }
  *dataptr = buf->ptr->payload;
  *len = buf->ptr->len;
  return ERR_OK;
}
 
s8_t
netbuf_next(struct netbuf *buf)
{
  if (buf->ptr->next == NULL) {
    return -1;
  }
  buf->ptr = buf->ptr->next;
  if (buf->ptr->next == NULL) {
    return 1;
  }
  return 0;
}
 
void
netbuf_first(struct netbuf *buf)
{
  buf->ptr = buf->p;
}
 
void
netbuf_copy_partial(struct netbuf *buf, void *dataptr, u16_t len, u16_t offset)
{
  struct pbuf *p;
  u16_t i, left;
 
  left = 0;
 
  if(buf == NULL || dataptr == NULL) {
    return;
  }
 
  /* This implementation is bad. It should use bcopy
     instead. */
  for(p = buf->p; left < len && p != NULL; p = p->next) {
    if (offset != 0 && offset >= p->len) {
      offset -= p->len;
    } else {
      for(i = offset; i < p->len; ++i) {
  ((u8_t *)dataptr)[left] = ((u8_t *)p->payload)[i];
  if (++left >= len) {
    return;
  }
      }
      offset = 0;
    }
  }
}
 
void
netbuf_copy(struct netbuf *buf, void *dataptr, u16_t len)
{
  netbuf_copy_partial(buf, dataptr, len, 0);
}
 
struct ip_addr *
netbuf_fromaddr(struct netbuf *buf)
{
  return buf->fromaddr;
}
 
u16_t
netbuf_fromport(struct netbuf *buf)
{
  return buf->fromport;
}
 
struct
netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u16_t proto,
                                   void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
{
  struct netconn *conn;
  struct api_msg *msg;
 
  conn = memp_malloc(MEMP_NETCONN);
  if (conn == NULL) {
    return NULL;
  }
 
  conn->err = ERR_OK;
  conn->type = t;
  conn->pcb.tcp = NULL;
 
  if ((conn->mbox = sys_mbox_new()) == SYS_MBOX_NULL) {
    memp_free(MEMP_NETCONN, conn);
    return NULL;
  }
  conn->recvmbox = SYS_MBOX_NULL;
  conn->acceptmbox = SYS_MBOX_NULL;
  conn->sem = SYS_SEM_NULL;
  conn->state = NETCONN_NONE;
  conn->socket = 0;
  conn->callback = callback;
  conn->recv_avail = 0;
 
  if((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    memp_free(MEMP_NETCONN, conn);
    return NULL;
  }
 
  msg->type = API_MSG_NEWCONN;
  msg->msg.msg.bc.port = proto; /* misusing the port field */
  msg->msg.conn = conn;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
 
  if ( conn->err != ERR_OK ) {
    memp_free(MEMP_NETCONN, conn);
    return NULL;
  }
 
  return conn;
}
 
 
struct
netconn *netconn_new(enum netconn_type t)
{
  return netconn_new_with_proto_and_callback(t,0,NULL);
}
 
struct
netconn *netconn_new_with_callback(enum netconn_type t,
                                   void (*callback)(struct netconn *, enum netconn_evt, u16_t len))
{
  return netconn_new_with_proto_and_callback(t,0,callback);
}
 
 
err_t
netconn_delete(struct netconn *conn)
{
  struct api_msg *msg;
  void *mem;
 
  if (conn == NULL) {
    return ERR_OK;
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return ERR_MEM;
  }
 
  msg->type = API_MSG_DELCONN;
  msg->msg.conn = conn;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
 
  /* Drain the recvmbox. */
  if (conn->recvmbox != SYS_MBOX_NULL) {
    while (sys_arch_mbox_fetch(conn->recvmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {
      if (conn->type == NETCONN_TCP) {
        if(mem != NULL)
          pbuf_free((struct pbuf *)mem);
      } else {
        netbuf_delete((struct netbuf *)mem);
      }
    }
    sys_mbox_free(conn->recvmbox);
    conn->recvmbox = SYS_MBOX_NULL;
  }
 
 
  /* Drain the acceptmbox. */
  if (conn->acceptmbox != SYS_MBOX_NULL) {
    while (sys_arch_mbox_fetch(conn->acceptmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {
      netconn_delete((struct netconn *)mem);
    }
 
    sys_mbox_free(conn->acceptmbox);
    conn->acceptmbox = SYS_MBOX_NULL;
  }
 
  sys_mbox_free(conn->mbox);
  conn->mbox = SYS_MBOX_NULL;
  if (conn->sem != SYS_SEM_NULL) {
    sys_sem_free(conn->sem);
  }
  /*  conn->sem = SYS_SEM_NULL;*/
  memp_free(MEMP_NETCONN, conn);
  return ERR_OK;
}
 
enum netconn_type
netconn_type(struct netconn *conn)
{
  return conn->type;
}
 
err_t
netconn_peer(struct netconn *conn, struct ip_addr *addr,
       u16_t *port)
{
  switch (conn->type) {
  case NETCONN_RAW:
    /* return an error as connecting is only a helper for upper layers */
    return ERR_CONN;
  case NETCONN_UDPLITE:
  case NETCONN_UDPNOCHKSUM:
  case NETCONN_UDP:
    if (conn->pcb.udp == NULL ||
  ((conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0))
     return ERR_CONN;
    *addr = (conn->pcb.udp->remote_ip);
    *port = conn->pcb.udp->remote_port;
    break;
  case NETCONN_TCP:
    if (conn->pcb.tcp == NULL)
      return ERR_CONN;
    *addr = (conn->pcb.tcp->remote_ip);
    *port = conn->pcb.tcp->remote_port;
    break;
  }
  return (conn->err = ERR_OK);
}
 
err_t
netconn_addr(struct netconn *conn, struct ip_addr **addr,
       u16_t *port)
{
  switch (conn->type) {
  case NETCONN_RAW:
    *addr = &(conn->pcb.raw->local_ip);
    *port = conn->pcb.raw->protocol;
    break;
  case NETCONN_UDPLITE:
  case NETCONN_UDPNOCHKSUM:
  case NETCONN_UDP:
    *addr = &(conn->pcb.udp->local_ip);
    *port = conn->pcb.udp->local_port;
    break;
  case NETCONN_TCP:
    *addr = &(conn->pcb.tcp->local_ip);
    *port = conn->pcb.tcp->local_port;
    break;
  }
  return (conn->err = ERR_OK);
}
 
err_t
netconn_bind(struct netconn *conn, struct ip_addr *addr,
      u16_t port)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
  if (conn->type != NETCONN_TCP &&
     conn->recvmbox == SYS_MBOX_NULL) {
    if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {
      return ERR_MEM;
    }
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return (conn->err = ERR_MEM);
  }
  msg->type = API_MSG_BIND;
  msg->msg.conn = conn;
  msg->msg.msg.bc.ipaddr = addr;
  msg->msg.msg.bc.port = port;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
}
 
 
err_t
netconn_connect(struct netconn *conn, struct ip_addr *addr,
       u16_t port)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
 
  if (conn->recvmbox == SYS_MBOX_NULL) {
    if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {
      return ERR_MEM;
    }
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return ERR_MEM;
  }
  msg->type = API_MSG_CONNECT;
  msg->msg.conn = conn;
  msg->msg.msg.bc.ipaddr = addr;
  msg->msg.msg.bc.port = port;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
}
 
err_t
netconn_disconnect(struct netconn *conn)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return ERR_MEM;
  }
  msg->type = API_MSG_DISCONNECT;
  msg->msg.conn = conn;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
 
}
 
err_t
netconn_listen(struct netconn *conn)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
  if (conn->acceptmbox == SYS_MBOX_NULL) {
    conn->acceptmbox = sys_mbox_new();
    if (conn->acceptmbox == SYS_MBOX_NULL) {
      return ERR_MEM;
    }
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return (conn->err = ERR_MEM);
  }
  msg->type = API_MSG_LISTEN;
  msg->msg.conn = conn;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
}
 
struct netconn *
netconn_accept(struct netconn *conn)
{
  struct netconn *newconn;
 
  if (conn == NULL) {
    return NULL;
  }
 
  sys_mbox_fetch(conn->acceptmbox, (void **)&newconn);
  /* Register event with callback */
  if (conn->callback)
      (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, 0);
 
  return newconn;
}
 
struct netbuf *
netconn_recv(struct netconn *conn)
{
  struct api_msg *msg;
  struct netbuf *buf;
  struct pbuf *p;
  u16_t len;
 
  if (conn == NULL) {
    return NULL;
  }
 
  if (conn->recvmbox == SYS_MBOX_NULL) {
    conn->err = ERR_CONN;
    return NULL;
  }
 
  if (conn->err != ERR_OK) {
    return NULL;
  }
 
  if (conn->type == NETCONN_TCP) {
    if (conn->pcb.tcp->state == LISTEN) {
      conn->err = ERR_CONN;
      return NULL;
    }
 
 
    buf = memp_malloc(MEMP_NETBUF);
 
    if (buf == NULL) {
      conn->err = ERR_MEM;
      return NULL;
    }
 
    sys_mbox_fetch(conn->recvmbox, (void **)&p);
 
    if (p != NULL)
    {
        len = p->tot_len;
        conn->recv_avail -= len;
    }
    else
        len = 0;
 
    /* Register event with callback */
      if (conn->callback)
        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, len);
 
    /* If we are closed, we indicate that we no longer wish to receive
       data by setting conn->recvmbox to SYS_MBOX_NULL. */
    if (p == NULL) {
      memp_free(MEMP_NETBUF, buf);
      sys_mbox_free(conn->recvmbox);
      conn->recvmbox = SYS_MBOX_NULL;
      return NULL;
    }
 
    buf->p = p;
    buf->ptr = p;
    buf->fromport = 0;
    buf->fromaddr = NULL;
 
    /* Let the stack know that we have taken the data. */
    if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
      conn->err = ERR_MEM;
      return buf;
    }
    msg->type = API_MSG_RECV;
    msg->msg.conn = conn;
    if (buf != NULL) {
      msg->msg.msg.len = buf->p->tot_len;
    } else {
      msg->msg.msg.len = 1;
    }
    api_msg_post(msg);
 
    sys_mbox_fetch(conn->mbox, NULL);
    memp_free(MEMP_API_MSG, msg);
  } else {
    sys_mbox_fetch(conn->recvmbox, (void **)&buf);
  conn->recv_avail -= buf->p->tot_len;
    /* Register event with callback */
    if (conn->callback)
        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len);
  }
 
 
 
 
  LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)\n", (void *)buf, conn->err));
 
 
  return buf;
}
 
err_t
netconn_send(struct netconn *conn, struct netbuf *buf)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
  if (conn->err != ERR_OK) {
    return conn->err;
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return (conn->err = ERR_MEM);
  }
 
  LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %d bytes\n", buf->p->tot_len));
  msg->type = API_MSG_SEND;
  msg->msg.conn = conn;
  msg->msg.msg.p = buf->p;
  api_msg_post(msg);
 
  sys_mbox_fetch(conn->mbox, NULL);
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
}
 
err_t
netconn_write(struct netconn *conn, void *dataptr, u16_t size, u8_t copy)
{
  struct api_msg *msg;
  u16_t len;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
 
  if (conn->err != ERR_OK) {
    return conn->err;
  }
 
  if (conn->sem == SYS_SEM_NULL) {
    conn->sem = sys_sem_new(0);
    if (conn->sem == SYS_SEM_NULL) {
      return ERR_MEM;
    }
  }
 
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return (conn->err = ERR_MEM);
  }
  msg->type = API_MSG_WRITE;
  msg->msg.conn = conn;
 
 
  conn->state = NETCONN_WRITE;
  while (conn->err == ERR_OK && size > 0) {
    msg->msg.msg.w.dataptr = dataptr;
    msg->msg.msg.w.copy = copy;
 
    if (conn->type == NETCONN_TCP) {
      if (tcp_sndbuf(conn->pcb.tcp) == 0) {
  sys_sem_wait(conn->sem);
  if (conn->err != ERR_OK) {
    goto ret;
  }
      }
      if (size > tcp_sndbuf(conn->pcb.tcp)) {
  /* We cannot send more than one send buffer's worth of data at a
     time. */
  len = tcp_sndbuf(conn->pcb.tcp);
      } else {
  len = size;
      }
    } else {
      len = size;
    }
 
    LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write: writing %d bytes (%d)\n", len, copy));
    msg->msg.msg.w.len = len;
    api_msg_post(msg);
    sys_mbox_fetch(conn->mbox, NULL);
    if (conn->err == ERR_OK) {
      dataptr = (void *)((u8_t *)dataptr + len);
      size -= len;
    } else if (conn->err == ERR_MEM) {
      conn->err = ERR_OK;
      sys_sem_wait(conn->sem);
    } else {
      goto ret;
    }
  }
 ret:
  memp_free(MEMP_API_MSG, msg);
  conn->state = NETCONN_NONE;
  if (conn->sem != SYS_SEM_NULL) {
    sys_sem_free(conn->sem);
    conn->sem = SYS_SEM_NULL;
  }
 
  return conn->err;
}
 
err_t
netconn_close(struct netconn *conn)
{
  struct api_msg *msg;
 
  if (conn == NULL) {
    return ERR_VAL;
  }
  if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {
    return (conn->err = ERR_MEM);
  }
 
  conn->state = NETCONN_CLOSE;
 again:
  msg->type = API_MSG_CLOSE;
  msg->msg.conn = conn;
  api_msg_post(msg);
  sys_mbox_fetch(conn->mbox, NULL);
  if (conn->err == ERR_MEM &&
     conn->sem != SYS_SEM_NULL) {
    sys_sem_wait(conn->sem);
    goto again;
  }
  conn->state = NETCONN_NONE;
  memp_free(MEMP_API_MSG, msg);
  return conn->err;
}
 
err_t
netconn_err(struct netconn *conn)
{
  return conn->err;
}
 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [lwIP_MCF5235_GCC/] [lwip/] [src/] [api/] [api_lib.c] - Blame information for rev 583

Line No.	Rev	Author	Line
1	583	jeremybenn	`/*`
2			`* Copyright (c) 2001-2004 Swedish Institute of Computer Science.`
3			`* All rights reserved.`
4			`*`
5			`* Redistribution and use in source and binary forms, with or without modification,`
6			`* are permitted provided that the following conditions are met:`
7			`*`
8			`* 1. Redistributions of source code must retain the above copyright notice,`
9			`* this list of conditions and the following disclaimer.`
10			`* 2. Redistributions in binary form must reproduce the above copyright notice,`
11			`* this list of conditions and the following disclaimer in the documentation`
12			`* and/or other materials provided with the distribution.`
13			`* 3. The name of the author may not be used to endorse or promote products`
14			`* derived from this software without specific prior written permission.`
15			`*`
16			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17			`* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF`
18			`* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT`
19			`* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,`
20			`* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT`
21			`* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS`
22			`* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN`
23			`* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING`
24			`* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY`
25			`* OF SUCH DAMAGE.`
26			`*`
27			`* This file is part of the lwIP TCP/IP stack.`
28			`*`
29			`* Author: Adam Dunkels <adam@sics.se>`
30			`*`
31			`*/`
32
33			`/* This is the part of the API that is linked with`
34			`the application */`
35
36			`#include "lwip/opt.h"`
37			`#include "lwip/api.h"`
38			`#include "lwip/api_msg.h"`
39			`#include "lwip/memp.h"`
40
41
42			`struct`
43			`netbuf *netbuf_new(void)`
44			`{`
45			`struct netbuf *buf;`
46
47			`buf = memp_malloc(MEMP_NETBUF);`
48			`if (buf != NULL) {`
49			`buf->p = NULL;`
50			`buf->ptr = NULL;`
51			`return buf;`
52			`} else {`
53			`return NULL;`
54			`}`
55			`}`
56
57			`void`
58			`netbuf_delete(struct netbuf *buf)`
59			`{`
60			`if (buf != NULL) {`
61			`if (buf->p != NULL) {`
62			`pbuf_free(buf->p);`
63			`buf->p = buf->ptr = NULL;`
64			`}`
65			`memp_free(MEMP_NETBUF, buf);`
66			`}`
67			`}`
68
69			`void *`
70			`netbuf_alloc(struct netbuf *buf, u16_t size)`
71			`{`
72			`/* Deallocate any previously allocated memory. */`
73			`if (buf->p != NULL) {`
74			`pbuf_free(buf->p);`
75			`}`
76			`buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM);`
77			`if (buf->p == NULL) {`
78			`return NULL;`
79			`}`
80			`buf->ptr = buf->p;`
81			`return buf->p->payload;`
82			`}`
83
84			`void`
85			`netbuf_free(struct netbuf *buf)`
86			`{`
87			`if (buf->p != NULL) {`
88			`pbuf_free(buf->p);`
89			`}`
90			`buf->p = buf->ptr = NULL;`
91			`}`
92
93			`void`
94			`netbuf_ref(struct netbuf buf, void dataptr, u16_t size)`
95			`{`
96			`if (buf->p != NULL) {`
97			`pbuf_free(buf->p);`
98			`}`
99			`buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF);`
100			`buf->p->payload = dataptr;`
101			`buf->p->len = buf->p->tot_len = size;`
102			`buf->ptr = buf->p;`
103			`}`
104
105			`void`
106			`netbuf_chain(struct netbuf head, struct netbuf tail)`
107			`{`
108			`pbuf_chain(head->p, tail->p);`
109			`head->ptr = head->p;`
110			`memp_free(MEMP_NETBUF, tail);`
111			`}`
112
113			`u16_t`
114			`netbuf_len(struct netbuf *buf)`
115			`{`
116			`return buf->p->tot_len;`
117			`}`
118
119			`err_t`
120			`netbuf_data(struct netbuf buf, void dataptr, u16_t len)`
121			`{`
122			`if (buf->ptr == NULL) {`
123			`return ERR_BUF;`
124			`}`
125			`*dataptr = buf->ptr->payload;`
126			`*len = buf->ptr->len;`
127			`return ERR_OK;`
128			`}`
129
130			`s8_t`
131			`netbuf_next(struct netbuf *buf)`
132			`{`
133			`if (buf->ptr->next == NULL) {`
134			`return -1;`
135			`}`
136			`buf->ptr = buf->ptr->next;`
137			`if (buf->ptr->next == NULL) {`
138			`return 1;`
139			`}`
140			`return 0;`
141			`}`
142
143			`void`
144			`netbuf_first(struct netbuf *buf)`
145			`{`
146			`buf->ptr = buf->p;`
147			`}`
148
149			`void`
150			`netbuf_copy_partial(struct netbuf buf, void dataptr, u16_t len, u16_t offset)`
151			`{`
152			`struct pbuf *p;`
153			`u16_t i, left;`
154
155			`left = 0;`
156
157			`if(buf == NULL \|\| dataptr == NULL) {`
158			`return;`
159			`}`
160
161			`/* This implementation is bad. It should use bcopy`
162			`instead. */`
163			`for(p = buf->p; left < len && p != NULL; p = p->next) {`
164			`if (offset != 0 && offset >= p->len) {`
165			`offset -= p->len;`
166			`} else {`
167			`for(i = offset; i < p->len; ++i) {`
168			`((u8_t )dataptr)[left] = ((u8_t )p->payload)[i];`
169			`if (++left >= len) {`
170			`return;`
171			`}`
172			`}`
173			`offset = 0;`
174			`}`
175			`}`
176			`}`
177
178			`void`
179			`netbuf_copy(struct netbuf buf, void dataptr, u16_t len)`
180			`{`
181			`netbuf_copy_partial(buf, dataptr, len, 0);`
182			`}`
183
184			`struct ip_addr *`
185			`netbuf_fromaddr(struct netbuf *buf)`
186			`{`
187			`return buf->fromaddr;`
188			`}`
189
190			`u16_t`
191			`netbuf_fromport(struct netbuf *buf)`
192			`{`
193			`return buf->fromport;`
194			`}`
195
196			`struct`
197			`netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u16_t proto,`
198			`void (callback)(struct netconn , enum netconn_evt, u16_t len))`
199			`{`
200			`struct netconn *conn;`
201			`struct api_msg *msg;`
202
203			`conn = memp_malloc(MEMP_NETCONN);`
204			`if (conn == NULL) {`
205			`return NULL;`
206			`}`
207
208			`conn->err = ERR_OK;`
209			`conn->type = t;`
210			`conn->pcb.tcp = NULL;`
211
212			`if ((conn->mbox = sys_mbox_new()) == SYS_MBOX_NULL) {`
213			`memp_free(MEMP_NETCONN, conn);`
214			`return NULL;`
215			`}`
216			`conn->recvmbox = SYS_MBOX_NULL;`
217			`conn->acceptmbox = SYS_MBOX_NULL;`
218			`conn->sem = SYS_SEM_NULL;`
219			`conn->state = NETCONN_NONE;`
220			`conn->socket = 0;`
221			`conn->callback = callback;`
222			`conn->recv_avail = 0;`
223
224			`if((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
225			`memp_free(MEMP_NETCONN, conn);`
226			`return NULL;`
227			`}`
228
229			`msg->type = API_MSG_NEWCONN;`
230			`msg->msg.msg.bc.port = proto; /* misusing the port field */`
231			`msg->msg.conn = conn;`
232			`api_msg_post(msg);`
233			`sys_mbox_fetch(conn->mbox, NULL);`
234			`memp_free(MEMP_API_MSG, msg);`
235
236			`if ( conn->err != ERR_OK ) {`
237			`memp_free(MEMP_NETCONN, conn);`
238			`return NULL;`
239			`}`
240
241			`return conn;`
242			`}`
243
244
245			`struct`
246			`netconn *netconn_new(enum netconn_type t)`
247			`{`
248			`return netconn_new_with_proto_and_callback(t,0,NULL);`
249			`}`
250
251			`struct`
252			`netconn *netconn_new_with_callback(enum netconn_type t,`
253			`void (callback)(struct netconn , enum netconn_evt, u16_t len))`
254			`{`
255			`return netconn_new_with_proto_and_callback(t,0,callback);`
256			`}`
257
258
259			`err_t`
260			`netconn_delete(struct netconn *conn)`
261			`{`
262			`struct api_msg *msg;`
263			`void *mem;`
264
265			`if (conn == NULL) {`
266			`return ERR_OK;`
267			`}`
268
269			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
270			`return ERR_MEM;`
271			`}`
272
273			`msg->type = API_MSG_DELCONN;`
274			`msg->msg.conn = conn;`
275			`api_msg_post(msg);`
276			`sys_mbox_fetch(conn->mbox, NULL);`
277			`memp_free(MEMP_API_MSG, msg);`
278
279			`/* Drain the recvmbox. */`
280			`if (conn->recvmbox != SYS_MBOX_NULL) {`
281			`while (sys_arch_mbox_fetch(conn->recvmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {`
282			`if (conn->type == NETCONN_TCP) {`
283			`if(mem != NULL)`
284			`pbuf_free((struct pbuf *)mem);`
285			`} else {`
286			`netbuf_delete((struct netbuf *)mem);`
287			`}`
288			`}`
289			`sys_mbox_free(conn->recvmbox);`
290			`conn->recvmbox = SYS_MBOX_NULL;`
291			`}`
292
293
294			`/* Drain the acceptmbox. */`
295			`if (conn->acceptmbox != SYS_MBOX_NULL) {`
296			`while (sys_arch_mbox_fetch(conn->acceptmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {`
297			`netconn_delete((struct netconn *)mem);`
298			`}`
299
300			`sys_mbox_free(conn->acceptmbox);`
301			`conn->acceptmbox = SYS_MBOX_NULL;`
302			`}`
303
304			`sys_mbox_free(conn->mbox);`
305			`conn->mbox = SYS_MBOX_NULL;`
306			`if (conn->sem != SYS_SEM_NULL) {`
307			`sys_sem_free(conn->sem);`
308			`}`
309			`/* conn->sem = SYS_SEM_NULL;*/`
310			`memp_free(MEMP_NETCONN, conn);`
311			`return ERR_OK;`
312			`}`
313
314			`enum netconn_type`
315			`netconn_type(struct netconn *conn)`
316			`{`
317			`return conn->type;`
318			`}`
319
320			`err_t`
321			`netconn_peer(struct netconn conn, struct ip_addr addr,`
322			`u16_t *port)`
323			`{`
324			`switch (conn->type) {`
325			`case NETCONN_RAW:`
326			`/* return an error as connecting is only a helper for upper layers */`
327			`return ERR_CONN;`
328			`case NETCONN_UDPLITE:`
329			`case NETCONN_UDPNOCHKSUM:`
330			`case NETCONN_UDP:`
331			`if (conn->pcb.udp == NULL \|\|`
332			`((conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0))`
333			`return ERR_CONN;`
334			`*addr = (conn->pcb.udp->remote_ip);`
335			`*port = conn->pcb.udp->remote_port;`
336			`break;`
337			`case NETCONN_TCP:`
338			`if (conn->pcb.tcp == NULL)`
339			`return ERR_CONN;`
340			`*addr = (conn->pcb.tcp->remote_ip);`
341			`*port = conn->pcb.tcp->remote_port;`
342			`break;`
343			`}`
344			`return (conn->err = ERR_OK);`
345			`}`
346
347			`err_t`
348			`netconn_addr(struct netconn conn, struct ip_addr *addr,`
349			`u16_t *port)`
350			`{`
351			`switch (conn->type) {`
352			`case NETCONN_RAW:`
353			`*addr = &(conn->pcb.raw->local_ip);`
354			`*port = conn->pcb.raw->protocol;`
355			`break;`
356			`case NETCONN_UDPLITE:`
357			`case NETCONN_UDPNOCHKSUM:`
358			`case NETCONN_UDP:`
359			`*addr = &(conn->pcb.udp->local_ip);`
360			`*port = conn->pcb.udp->local_port;`
361			`break;`
362			`case NETCONN_TCP:`
363			`*addr = &(conn->pcb.tcp->local_ip);`
364			`*port = conn->pcb.tcp->local_port;`
365			`break;`
366			`}`
367			`return (conn->err = ERR_OK);`
368			`}`
369
370			`err_t`
371			`netconn_bind(struct netconn conn, struct ip_addr addr,`
372			`u16_t port)`
373			`{`
374			`struct api_msg *msg;`
375
376			`if (conn == NULL) {`
377			`return ERR_VAL;`
378			`}`
379
380			`if (conn->type != NETCONN_TCP &&`
381			`conn->recvmbox == SYS_MBOX_NULL) {`
382			`if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {`
383			`return ERR_MEM;`
384			`}`
385			`}`
386
387			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
388			`return (conn->err = ERR_MEM);`
389			`}`
390			`msg->type = API_MSG_BIND;`
391			`msg->msg.conn = conn;`
392			`msg->msg.msg.bc.ipaddr = addr;`
393			`msg->msg.msg.bc.port = port;`
394			`api_msg_post(msg);`
395			`sys_mbox_fetch(conn->mbox, NULL);`
396			`memp_free(MEMP_API_MSG, msg);`
397			`return conn->err;`
398			`}`
399
400
401			`err_t`
402			`netconn_connect(struct netconn conn, struct ip_addr addr,`
403			`u16_t port)`
404			`{`
405			`struct api_msg *msg;`
406
407			`if (conn == NULL) {`
408			`return ERR_VAL;`
409			`}`
410
411
412			`if (conn->recvmbox == SYS_MBOX_NULL) {`
413			`if ((conn->recvmbox = sys_mbox_new()) == SYS_MBOX_NULL) {`
414			`return ERR_MEM;`
415			`}`
416			`}`
417
418			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
419			`return ERR_MEM;`
420			`}`
421			`msg->type = API_MSG_CONNECT;`
422			`msg->msg.conn = conn;`
423			`msg->msg.msg.bc.ipaddr = addr;`
424			`msg->msg.msg.bc.port = port;`
425			`api_msg_post(msg);`
426			`sys_mbox_fetch(conn->mbox, NULL);`
427			`memp_free(MEMP_API_MSG, msg);`
428			`return conn->err;`
429			`}`
430
431			`err_t`
432			`netconn_disconnect(struct netconn *conn)`
433			`{`
434			`struct api_msg *msg;`
435
436			`if (conn == NULL) {`
437			`return ERR_VAL;`
438			`}`
439
440			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
441			`return ERR_MEM;`
442			`}`
443			`msg->type = API_MSG_DISCONNECT;`
444			`msg->msg.conn = conn;`
445			`api_msg_post(msg);`
446			`sys_mbox_fetch(conn->mbox, NULL);`
447			`memp_free(MEMP_API_MSG, msg);`
448			`return conn->err;`
449
450			`}`
451
452			`err_t`
453			`netconn_listen(struct netconn *conn)`
454			`{`
455			`struct api_msg *msg;`
456
457			`if (conn == NULL) {`
458			`return ERR_VAL;`
459			`}`
460
461			`if (conn->acceptmbox == SYS_MBOX_NULL) {`
462			`conn->acceptmbox = sys_mbox_new();`
463			`if (conn->acceptmbox == SYS_MBOX_NULL) {`
464			`return ERR_MEM;`
465			`}`
466			`}`
467
468			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
469			`return (conn->err = ERR_MEM);`
470			`}`
471			`msg->type = API_MSG_LISTEN;`
472			`msg->msg.conn = conn;`
473			`api_msg_post(msg);`
474			`sys_mbox_fetch(conn->mbox, NULL);`
475			`memp_free(MEMP_API_MSG, msg);`
476			`return conn->err;`
477			`}`
478
479			`struct netconn *`
480			`netconn_accept(struct netconn *conn)`
481			`{`
482			`struct netconn *newconn;`
483
484			`if (conn == NULL) {`
485			`return NULL;`
486			`}`
487
488			`sys_mbox_fetch(conn->acceptmbox, (void **)&newconn);`
489			`/* Register event with callback */`
490			`if (conn->callback)`
491			`(*conn->callback)(conn, NETCONN_EVT_RCVMINUS, 0);`
492
493			`return newconn;`
494			`}`
495
496			`struct netbuf *`
497			`netconn_recv(struct netconn *conn)`
498			`{`
499			`struct api_msg *msg;`
500			`struct netbuf *buf;`
501			`struct pbuf *p;`
502			`u16_t len;`
503
504			`if (conn == NULL) {`
505			`return NULL;`
506			`}`
507
508			`if (conn->recvmbox == SYS_MBOX_NULL) {`
509			`conn->err = ERR_CONN;`
510			`return NULL;`
511			`}`
512
513			`if (conn->err != ERR_OK) {`
514			`return NULL;`
515			`}`
516
517			`if (conn->type == NETCONN_TCP) {`
518			`if (conn->pcb.tcp->state == LISTEN) {`
519			`conn->err = ERR_CONN;`
520			`return NULL;`
521			`}`
522
523
524			`buf = memp_malloc(MEMP_NETBUF);`
525
526			`if (buf == NULL) {`
527			`conn->err = ERR_MEM;`
528			`return NULL;`
529			`}`
530
531			`sys_mbox_fetch(conn->recvmbox, (void **)&p);`
532
533			`if (p != NULL)`
534			`{`
535			`len = p->tot_len;`
536			`conn->recv_avail -= len;`
537			`}`
538			`else`
539			`len = 0;`
540
541			`/* Register event with callback */`
542			`if (conn->callback)`
543			`(*conn->callback)(conn, NETCONN_EVT_RCVMINUS, len);`
544
545			`/* If we are closed, we indicate that we no longer wish to receive`
546			`data by setting conn->recvmbox to SYS_MBOX_NULL. */`
547			`if (p == NULL) {`
548			`memp_free(MEMP_NETBUF, buf);`
549			`sys_mbox_free(conn->recvmbox);`
550			`conn->recvmbox = SYS_MBOX_NULL;`
551			`return NULL;`
552			`}`
553
554			`buf->p = p;`
555			`buf->ptr = p;`
556			`buf->fromport = 0;`
557			`buf->fromaddr = NULL;`
558
559			`/* Let the stack know that we have taken the data. */`
560			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
561			`conn->err = ERR_MEM;`
562			`return buf;`
563			`}`
564			`msg->type = API_MSG_RECV;`
565			`msg->msg.conn = conn;`
566			`if (buf != NULL) {`
567			`msg->msg.msg.len = buf->p->tot_len;`
568			`} else {`
569			`msg->msg.msg.len = 1;`
570			`}`
571			`api_msg_post(msg);`
572
573			`sys_mbox_fetch(conn->mbox, NULL);`
574			`memp_free(MEMP_API_MSG, msg);`
575			`} else {`
576			`sys_mbox_fetch(conn->recvmbox, (void **)&buf);`
577			`conn->recv_avail -= buf->p->tot_len;`
578			`/* Register event with callback */`
579			`if (conn->callback)`
580			`(*conn->callback)(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len);`
581			`}`
582
583
584
585
586			`LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)\n", (void *)buf, conn->err));`
587
588
589			`return buf;`
590			`}`
591
592			`err_t`
593			`netconn_send(struct netconn conn, struct netbuf buf)`
594			`{`
595			`struct api_msg *msg;`
596
597			`if (conn == NULL) {`
598			`return ERR_VAL;`
599			`}`
600
601			`if (conn->err != ERR_OK) {`
602			`return conn->err;`
603			`}`
604
605			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
606			`return (conn->err = ERR_MEM);`
607			`}`
608
609			`LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %d bytes\n", buf->p->tot_len));`
610			`msg->type = API_MSG_SEND;`
611			`msg->msg.conn = conn;`
612			`msg->msg.msg.p = buf->p;`
613			`api_msg_post(msg);`
614
615			`sys_mbox_fetch(conn->mbox, NULL);`
616			`memp_free(MEMP_API_MSG, msg);`
617			`return conn->err;`
618			`}`
619
620			`err_t`
621			`netconn_write(struct netconn conn, void dataptr, u16_t size, u8_t copy)`
622			`{`
623			`struct api_msg *msg;`
624			`u16_t len;`
625
626			`if (conn == NULL) {`
627			`return ERR_VAL;`
628			`}`
629
630			`if (conn->err != ERR_OK) {`
631			`return conn->err;`
632			`}`
633
634			`if (conn->sem == SYS_SEM_NULL) {`
635			`conn->sem = sys_sem_new(0);`
636			`if (conn->sem == SYS_SEM_NULL) {`
637			`return ERR_MEM;`
638			`}`
639			`}`
640
641			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
642			`return (conn->err = ERR_MEM);`
643			`}`
644			`msg->type = API_MSG_WRITE;`
645			`msg->msg.conn = conn;`
646
647
648			`conn->state = NETCONN_WRITE;`
649			`while (conn->err == ERR_OK && size > 0) {`
650			`msg->msg.msg.w.dataptr = dataptr;`
651			`msg->msg.msg.w.copy = copy;`
652
653			`if (conn->type == NETCONN_TCP) {`
654			`if (tcp_sndbuf(conn->pcb.tcp) == 0) {`
655			`sys_sem_wait(conn->sem);`
656			`if (conn->err != ERR_OK) {`
657			`goto ret;`
658			`}`
659			`}`
660			`if (size > tcp_sndbuf(conn->pcb.tcp)) {`
661			`/* We cannot send more than one send buffer's worth of data at a`
662			`time. */`
663			`len = tcp_sndbuf(conn->pcb.tcp);`
664			`} else {`
665			`len = size;`
666			`}`
667			`} else {`
668			`len = size;`
669			`}`
670
671			`LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_write: writing %d bytes (%d)\n", len, copy));`
672			`msg->msg.msg.w.len = len;`
673			`api_msg_post(msg);`
674			`sys_mbox_fetch(conn->mbox, NULL);`
675			`if (conn->err == ERR_OK) {`
676			`dataptr = (void )((u8_t )dataptr + len);`
677			`size -= len;`
678			`} else if (conn->err == ERR_MEM) {`
679			`conn->err = ERR_OK;`
680			`sys_sem_wait(conn->sem);`
681			`} else {`
682			`goto ret;`
683			`}`
684			`}`
685			`ret:`
686			`memp_free(MEMP_API_MSG, msg);`
687			`conn->state = NETCONN_NONE;`
688			`if (conn->sem != SYS_SEM_NULL) {`
689			`sys_sem_free(conn->sem);`
690			`conn->sem = SYS_SEM_NULL;`
691			`}`
692
693			`return conn->err;`
694			`}`
695
696			`err_t`
697			`netconn_close(struct netconn *conn)`
698			`{`
699			`struct api_msg *msg;`
700
701			`if (conn == NULL) {`
702			`return ERR_VAL;`
703			`}`
704			`if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {`
705			`return (conn->err = ERR_MEM);`
706			`}`
707
708			`conn->state = NETCONN_CLOSE;`
709			`again:`
710			`msg->type = API_MSG_CLOSE;`
711			`msg->msg.conn = conn;`
712			`api_msg_post(msg);`
713			`sys_mbox_fetch(conn->mbox, NULL);`
714			`if (conn->err == ERR_MEM &&`
715			`conn->sem != SYS_SEM_NULL) {`
716			`sys_sem_wait(conn->sem);`
717			`goto again;`
718			`}`
719			`conn->state = NETCONN_NONE;`
720			`memp_free(MEMP_API_MSG, msg);`
721			`return conn->err;`
722			`}`
723
724			`err_t`
725			`netconn_err(struct netconn *conn)`
726			`{`
727			`return conn->err;`
728			`}`
729