/** | |
* @file | |
* Sequential API External module | |
* | |
*/ | |
/* | |
* 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" | |
#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ | |
#include "lwip/api.h" | |
#include "lwip/tcpip.h" | |
#include "lwip/memp.h" | |
#include "lwip/ip.h" | |
#include "lwip/raw.h" | |
#include "lwip/udp.h" | |
#include "lwip/tcp.h" | |
#include <string.h> | |
/** | |
* Create a new netconn (of a specific type) that has a callback function. | |
* The corresponding pcb is also created. | |
* | |
* @param t the type of 'connection' to create (@see enum netconn_type) | |
* @param proto the IP protocol for RAW IP pcbs | |
* @param callback a function to call on status changes (RX available, TX'ed) | |
* @return a newly allocated struct netconn or | |
* NULL on memory error | |
*/ | |
struct netconn* | |
netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback) | |
{ | |
struct netconn *conn; | |
struct api_msg msg; | |
conn = netconn_alloc(t, callback); | |
if (conn != NULL ) { | |
msg.function = do_newconn; | |
msg.msg.msg.n.proto = proto; | |
msg.msg.conn = conn; | |
TCPIP_APIMSG(&msg); | |
if (conn->err != ERR_OK) { | |
LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL); | |
LWIP_ASSERT("conn has no op_completed", conn->op_completed != SYS_SEM_NULL); | |
LWIP_ASSERT("conn has no recvmbox", conn->recvmbox != SYS_MBOX_NULL); | |
LWIP_ASSERT("conn->acceptmbox shouldn't exist", conn->acceptmbox == SYS_MBOX_NULL); | |
sys_sem_free(conn->op_completed); | |
sys_mbox_free(conn->recvmbox); | |
memp_free(MEMP_NETCONN, conn); | |
return NULL; | |
} | |
} | |
return conn; | |
} | |
/** | |
* Close a netconn 'connection' and free its resources. | |
* UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate | |
* after this returns. | |
* | |
* @param conn the netconn to delete | |
* @return ERR_OK if the connection was deleted | |
*/ | |
err_t | |
netconn_delete(struct netconn *conn) | |
{ | |
struct api_msg msg; | |
/* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */ | |
if (conn == NULL) { | |
return ERR_OK; | |
} | |
msg.function = do_delconn; | |
msg.msg.conn = conn; | |
tcpip_apimsg(&msg); | |
conn->pcb.tcp = NULL; | |
netconn_free(conn); | |
return ERR_OK; | |
} | |
/** | |
* Get the type of a netconn (as enum netconn_type). | |
* | |
* @param conn the netconn of which to get the type | |
* @return the netconn_type of conn | |
*/ | |
enum netconn_type | |
netconn_type(struct netconn *conn) | |
{ | |
LWIP_ERROR("netconn_type: invalid conn", (conn != NULL), return NETCONN_INVALID;); | |
return conn->type; | |
} | |
/** | |
* Get the local or remote IP address and port of a netconn. | |
* For RAW netconns, this returns the protocol instead of a port! | |
* | |
* @param conn the netconn to query | |
* @param addr a pointer to which to save the IP address | |
* @param port a pointer to which to save the port (or protocol for RAW) | |
* @param local 1 to get the local IP address, 0 to get the remote one | |
* @return ERR_CONN for invalid connections | |
* ERR_OK if the information was retrieved | |
*/ | |
err_t | |
netconn_getaddr(struct netconn *conn, struct ip_addr *addr, u16_t *port, u8_t local) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;); | |
LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;); | |
LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;); | |
msg.function = do_getaddr; | |
msg.msg.conn = conn; | |
msg.msg.msg.ad.ipaddr = addr; | |
msg.msg.msg.ad.port = port; | |
msg.msg.msg.ad.local = local; | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Bind a netconn to a specific local IP address and port. | |
* Binding one netconn twice might not always be checked correctly! | |
* | |
* @param conn the netconn to bind | |
* @param addr the local IP address to bind the netconn to (use IP_ADDR_ANY | |
* to bind to all addresses) | |
* @param port the local port to bind the netconn to (not used for RAW) | |
* @return ERR_OK if bound, any other err_t on failure | |
*/ | |
err_t | |
netconn_bind(struct netconn *conn, struct ip_addr *addr, u16_t port) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_bind; | |
msg.msg.conn = conn; | |
msg.msg.msg.bc.ipaddr = addr; | |
msg.msg.msg.bc.port = port; | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Connect a netconn to a specific remote IP address and port. | |
* | |
* @param conn the netconn to connect | |
* @param addr the remote IP address to connect to | |
* @param port the remote port to connect to (no used for RAW) | |
* @return ERR_OK if connected, return value of tcp_/udp_/raw_connect otherwise | |
*/ | |
err_t | |
netconn_connect(struct netconn *conn, struct ip_addr *addr, u16_t port) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_connect; | |
msg.msg.conn = conn; | |
msg.msg.msg.bc.ipaddr = addr; | |
msg.msg.msg.bc.port = port; | |
/* This is the only function which need to not block tcpip_thread */ | |
tcpip_apimsg(&msg); | |
return conn->err; | |
} | |
/** | |
* Disconnect a netconn from its current peer (only valid for UDP netconns). | |
* | |
* @param conn the netconn to disconnect | |
* @return TODO: return value is not set here... | |
*/ | |
err_t | |
netconn_disconnect(struct netconn *conn) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_disconnect; | |
msg.msg.conn = conn; | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Set a TCP netconn into listen mode | |
* | |
* @param conn the tcp netconn to set to listen mode | |
* @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1 | |
* @return ERR_OK if the netconn was set to listen (UDP and RAW netconns | |
* don't return any error (yet?)) | |
*/ | |
err_t | |
netconn_listen_with_backlog(struct netconn *conn, u8_t backlog) | |
{ | |
struct api_msg msg; | |
/* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */ | |
LWIP_UNUSED_ARG(backlog); | |
LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_listen; | |
msg.msg.conn = conn; | |
#if TCP_LISTEN_BACKLOG | |
msg.msg.msg.lb.backlog = backlog; | |
#endif /* TCP_LISTEN_BACKLOG */ | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Accept a new connection on a TCP listening netconn. | |
* | |
* @param conn the TCP listen netconn | |
* @return the newly accepted netconn or NULL on timeout | |
*/ | |
struct netconn * | |
netconn_accept(struct netconn *conn) | |
{ | |
struct netconn *newconn; | |
LWIP_ERROR("netconn_accept: invalid conn", (conn != NULL), return NULL;); | |
LWIP_ERROR("netconn_accept: invalid acceptmbox", (conn->acceptmbox != SYS_MBOX_NULL), return NULL;); | |
#if LWIP_SO_RCVTIMEO | |
if (sys_arch_mbox_fetch(conn->acceptmbox, (void *)&newconn, conn->recv_timeout) == SYS_ARCH_TIMEOUT) { | |
newconn = NULL; | |
} else | |
#else | |
sys_arch_mbox_fetch(conn->acceptmbox, (void *)&newconn, 0); | |
#endif /* LWIP_SO_RCVTIMEO*/ | |
{ | |
/* Register event with callback */ | |
API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0); | |
#if TCP_LISTEN_BACKLOG | |
if (newconn != NULL) { | |
/* Let the stack know that we have accepted the connection. */ | |
struct api_msg msg; | |
msg.function = do_recv; | |
msg.msg.conn = conn; | |
TCPIP_APIMSG(&msg); | |
} | |
#endif /* TCP_LISTEN_BACKLOG */ | |
} | |
return newconn; | |
} | |
/** | |
* Receive data (in form of a netbuf containing a packet buffer) from a netconn | |
* | |
* @param conn the netconn from which to receive data | |
* @return a new netbuf containing received data or NULL on memory error or timeout | |
*/ | |
struct netbuf * | |
netconn_recv(struct netconn *conn) | |
{ | |
struct api_msg msg; | |
struct netbuf *buf = NULL; | |
struct pbuf *p; | |
u16_t len; | |
LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return NULL;); | |
if (conn->recvmbox == SYS_MBOX_NULL) { | |
/* @todo: should calling netconn_recv on a TCP listen conn be fatal (ERR_CONN)?? */ | |
/* TCP listen conns don't have a recvmbox! */ | |
conn->err = ERR_CONN; | |
return NULL; | |
} | |
if (ERR_IS_FATAL(conn->err)) { | |
return NULL; | |
} | |
if (conn->type == NETCONN_TCP) { | |
#if LWIP_TCP | |
if (conn->state == NETCONN_LISTEN) { | |
/* @todo: should calling netconn_recv on a TCP listen conn be fatal?? */ | |
conn->err = ERR_CONN; | |
return NULL; | |
} | |
buf = memp_malloc(MEMP_NETBUF); | |
if (buf == NULL) { | |
conn->err = ERR_MEM; | |
return NULL; | |
} | |
#if LWIP_SO_RCVTIMEO | |
if (sys_arch_mbox_fetch(conn->recvmbox, (void *)&p, conn->recv_timeout)==SYS_ARCH_TIMEOUT) { | |
conn->err = ERR_TIMEOUT; | |
p = NULL; | |
} | |
#else | |
sys_arch_mbox_fetch(conn->recvmbox, (void *)&p, 0); | |
#endif /* LWIP_SO_RCVTIMEO*/ | |
if (p != NULL) { | |
len = p->tot_len; | |
SYS_ARCH_DEC(conn->recv_avail, len); | |
} else { | |
len = 0; | |
} | |
/* Register event with callback */ | |
API_EVENT(conn, NETCONN_EVT_RCVMINUS, len); | |
/* If we are closed, we indicate that we no longer wish to use the socket */ | |
if (p == NULL) { | |
memp_free(MEMP_NETBUF, buf); | |
/* Avoid to lose any previous error code */ | |
if (conn->err == ERR_OK) { | |
conn->err = ERR_CLSD; | |
} | |
return NULL; | |
} | |
buf->p = p; | |
buf->ptr = p; | |
buf->port = 0; | |
buf->addr = NULL; | |
/* Let the stack know that we have taken the data. */ | |
msg.function = do_recv; | |
msg.msg.conn = conn; | |
if (buf != NULL) { | |
msg.msg.msg.r.len = buf->p->tot_len; | |
} else { | |
msg.msg.msg.r.len = 1; | |
} | |
TCPIP_APIMSG(&msg); | |
#endif /* LWIP_TCP */ | |
} else { | |
#if (LWIP_UDP || LWIP_RAW) | |
#if LWIP_SO_RCVTIMEO | |
if (sys_arch_mbox_fetch(conn->recvmbox, (void *)&buf, conn->recv_timeout)==SYS_ARCH_TIMEOUT) { | |
buf = NULL; | |
} | |
#else | |
sys_arch_mbox_fetch(conn->recvmbox, (void *)&buf, 0); | |
#endif /* LWIP_SO_RCVTIMEO*/ | |
if (buf!=NULL) { | |
SYS_ARCH_DEC(conn->recv_avail, buf->p->tot_len); | |
/* Register event with callback */ | |
API_EVENT(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len); | |
} | |
#endif /* (LWIP_UDP || LWIP_RAW) */ | |
} | |
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)\n", (void *)buf, conn->err)); | |
return buf; | |
} | |
/** | |
* Send data (in form of a netbuf) to a specific remote IP address and port. | |
* Only to be used for UDP and RAW netconns (not TCP). | |
* | |
* @param conn the netconn over which to send data | |
* @param buf a netbuf containing the data to send | |
* @param addr the remote IP address to which to send the data | |
* @param port the remote port to which to send the data | |
* @return ERR_OK if data was sent, any other err_t on error | |
*/ | |
err_t | |
netconn_sendto(struct netconn *conn, struct netbuf *buf, struct ip_addr *addr, u16_t port) | |
{ | |
if (buf != NULL) { | |
buf->addr = addr; | |
buf->port = port; | |
return netconn_send(conn, buf); | |
} | |
return ERR_VAL; | |
} | |
/** | |
* Send data over a UDP or RAW netconn (that is already connected). | |
* | |
* @param conn the UDP or RAW netconn over which to send data | |
* @param buf a netbuf containing the data to send | |
* @return ERR_OK if data was sent, any other err_t on error | |
*/ | |
err_t | |
netconn_send(struct netconn *conn, struct netbuf *buf) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_send: invalid conn", (conn != NULL), return ERR_ARG;); | |
LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %d bytes\n", buf->p->tot_len)); | |
msg.function = do_send; | |
msg.msg.conn = conn; | |
msg.msg.msg.b = buf; | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Send data over a TCP netconn. | |
* | |
* @param conn the TCP netconn over which to send data | |
* @param dataptr pointer to the application buffer that contains the data to send | |
* @param size size of the application data to send | |
* @param apiflags combination of following flags : | |
* - NETCONN_COPY (0x01) data will be copied into memory belonging to the stack | |
* - NETCONN_MORE (0x02) for TCP connection, PSH flag will be set on last segment sent | |
* @return ERR_OK if data was sent, any other err_t on error | |
*/ | |
err_t | |
netconn_write(struct netconn *conn, const void *dataptr, int size, u8_t apiflags) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;); | |
LWIP_ERROR("netconn_write: invalid conn->type", (conn->type == NETCONN_TCP), return ERR_VAL;); | |
msg.function = do_write; | |
msg.msg.conn = conn; | |
msg.msg.msg.w.dataptr = dataptr; | |
msg.msg.msg.w.apiflags = apiflags; | |
msg.msg.msg.w.len = size; | |
/* For locking the core: this _can_ be delayed on low memory/low send buffer, | |
but if it is, this is done inside api_msg.c:do_write(), so we can use the | |
non-blocking version here. */ | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
/** | |
* Close a TCP netconn (doesn't delete it). | |
* | |
* @param conn the TCP netconn to close | |
* @return ERR_OK if the netconn was closed, any other err_t on error | |
*/ | |
err_t | |
netconn_close(struct netconn *conn) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_close: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_close; | |
msg.msg.conn = conn; | |
tcpip_apimsg(&msg); | |
return conn->err; | |
} | |
#if LWIP_IGMP | |
/** | |
* Join multicast groups for UDP netconns. | |
* | |
* @param conn the UDP netconn for which to change multicast addresses | |
* @param multiaddr IP address of the multicast group to join or leave | |
* @param interface the IP address of the network interface on which to send | |
* the igmp message | |
* @param join_or_leave flag whether to send a join- or leave-message | |
* @return ERR_OK if the action was taken, any err_t on error | |
*/ | |
err_t | |
netconn_join_leave_group(struct netconn *conn, | |
struct ip_addr *multiaddr, | |
struct ip_addr *interface, | |
enum netconn_igmp join_or_leave) | |
{ | |
struct api_msg msg; | |
LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;); | |
msg.function = do_join_leave_group; | |
msg.msg.conn = conn; | |
msg.msg.msg.jl.multiaddr = multiaddr; | |
msg.msg.msg.jl.interface = interface; | |
msg.msg.msg.jl.join_or_leave = join_or_leave; | |
TCPIP_APIMSG(&msg); | |
return conn->err; | |
} | |
#endif /* LWIP_IGMP */ | |
#if LWIP_DNS | |
/** | |
* Execute a DNS query, only one IP address is returned | |
* | |
* @param name a string representation of the DNS host name to query | |
* @param addr a preallocated struct ip_addr where to store the resolved IP address | |
* @return ERR_OK: resolving succeeded | |
* ERR_MEM: memory error, try again later | |
* ERR_ARG: dns client not initialized or invalid hostname | |
* ERR_VAL: dns server response was invalid | |
*/ | |
err_t | |
netconn_gethostbyname(const char *name, struct ip_addr *addr) | |
{ | |
struct dns_api_msg msg; | |
err_t err; | |
sys_sem_t sem; | |
LWIP_ERROR("netconn_gethostbyname: invalid name", (name != NULL), return ERR_ARG;); | |
LWIP_ERROR("netconn_gethostbyname: invalid addr", (addr != NULL), return ERR_ARG;); | |
sem = sys_sem_new(0); | |
if (sem == SYS_SEM_NULL) { | |
return ERR_MEM; | |
} | |
msg.name = name; | |
msg.addr = addr; | |
msg.err = &err; | |
msg.sem = sem; | |
tcpip_callback(do_gethostbyname, &msg); | |
sys_sem_wait(sem); | |
sys_sem_free(sem); | |
return err; | |
} | |
#endif /* LWIP_DNS*/ | |
#endif /* LWIP_NETCONN */ |