/* | |
* 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_new(0); | |
if (conn->sem == SYS_SEM_NULL) { | |
memp_free(MEMP_NETCONN, conn); | |
return 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 ((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; | |
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; | |
} | |