mirror of
https://github.com/espressif/ESP8266_RTOS_SDK.git
synced 2025-08-05 22:11:04 +08:00
feat(lwip): update lwip component from idf
This commit is contained in:
yuanjm
826
components/lwip/apps/multi-threads/sockets_mt.c
Normal file
826
components/lwip/apps/multi-threads/sockets_mt.c
Normal file
@ -0,0 +1,826 @@
|
||||
// Copyright 2018-2019 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "lwip/opt.h"
|
||||
|
||||
#ifdef SOCKETS_MT
|
||||
|
||||
#define SOCKETS_MT_DISABLE_SHUTDOWN
|
||||
|
||||
#include "lwip/priv/api_msg.h"
|
||||
|
||||
/* disable all LWIP socket API when compiling LWIP raw socket */
|
||||
|
||||
#undef lwip_accept
|
||||
#undef lwip_bind
|
||||
#undef lwip_shutdown
|
||||
#undef lwip_getpeername
|
||||
#undef lwip_getsockname
|
||||
#undef lwip_setsockopt
|
||||
#undef lwip_getsockopt
|
||||
#undef lwip_close
|
||||
#undef lwip_connect
|
||||
#undef lwip_listen
|
||||
#undef lwip_recv
|
||||
#undef lwip_recvfrom
|
||||
#undef lwip_send
|
||||
#undef lwip_sendmsg
|
||||
#undef lwip_sendto
|
||||
#undef lwip_socket
|
||||
#undef lwip_select
|
||||
#undef lwip_ioctlsocket
|
||||
|
||||
#define lwip_accept lwip_accept_esp
|
||||
#define lwip_bind lwip_bind_esp
|
||||
#define lwip_shutdown lwip_shutdown_esp
|
||||
#define lwip_getpeername lwip_getpeername_esp
|
||||
#define lwip_getsockname lwip_getsockname_esp
|
||||
#define lwip_setsockopt lwip_setsockopt_esp
|
||||
#define lwip_getsockopt lwip_getsockopt_esp
|
||||
#define lwip_close lwip_closesocket_esp
|
||||
#define lwip_connect lwip_connect_esp
|
||||
#define lwip_listen lwip_listen_esp
|
||||
#define lwip_recv lwip_recv_esp
|
||||
#define lwip_recvfrom lwip_recvfrom_esp
|
||||
#define lwip_send lwip_send_esp
|
||||
#define lwip_sendmsg lwip_sendmsg_esp
|
||||
#define lwip_sendto lwip_sendto_esp
|
||||
#define lwip_socket lwip_socket_esp
|
||||
#define lwip_select lwip_select_esp
|
||||
#define lwip_ioctlsocket lwip_ioctl_esp
|
||||
|
||||
#undef lwip_read
|
||||
#undef lwip_write
|
||||
#undef lwip_writev
|
||||
#undef lwip_close
|
||||
#undef closesocket
|
||||
#undef lwip_fcntl
|
||||
#undef lwip_ioctl
|
||||
|
||||
#define lwip_read lwip_read_esp
|
||||
#define lwip_write lwip_write_esp
|
||||
#define lwip_writev lwip_writev_esp
|
||||
#define lwip_close lwip_close_esp
|
||||
#define lwip_fcntl lwip_fcntl_esp
|
||||
#define lwip_ioctl lwip_ioctl_esp
|
||||
|
||||
#include "../../lwip/src/api/sockets.c"
|
||||
|
||||
/* disable macros to enable LWIP function */
|
||||
|
||||
#undef lwip_accept
|
||||
#undef lwip_bind
|
||||
#undef lwip_shutdown
|
||||
#undef lwip_getpeername
|
||||
#undef lwip_getsockname
|
||||
#undef lwip_setsockopt
|
||||
#undef lwip_getsockopt
|
||||
#undef lwip_close
|
||||
#undef lwip_connect
|
||||
#undef lwip_listen
|
||||
#undef lwip_recv
|
||||
#undef lwip_recvfrom
|
||||
#undef lwip_send
|
||||
#undef lwip_sendmsg
|
||||
#undef lwip_sendto
|
||||
#undef lwip_socket
|
||||
#undef lwip_select
|
||||
#undef lwip_ioctlsocket
|
||||
|
||||
#undef lwip_read
|
||||
#undef lwip_write
|
||||
#undef lwip_writev
|
||||
#undef lwip_close
|
||||
#undef closesocket
|
||||
#undef lwip_fcntl
|
||||
#undef lwip_ioctl
|
||||
|
||||
/********************************************************************/
|
||||
#define LWIP_SYNC_MT_SLEEP_MS 10
|
||||
|
||||
#define SOCK_MT_DEBUG_LEVEL 255
|
||||
|
||||
typedef struct socket_conn_sync {
|
||||
struct tcpip_api_call_data call;
|
||||
struct netconn *conn;
|
||||
} socket_conn_sync_t;
|
||||
|
||||
typedef int (*lwip_io_mt_fn)(int, int );
|
||||
|
||||
/* Use about 2 bit */
|
||||
#define SOCK_MT_STATE_SOCK 0
|
||||
#define SOCK_MT_STATE_ACCEPT 1
|
||||
#define SOCK_MT_STATE_CONNECT 2
|
||||
#define SOCK_MT_STATE_SEND 3
|
||||
#define SOCK_MT_STATE_ILL 4
|
||||
|
||||
#define SOCK_MT_LOCK_SEND (1 << 0)
|
||||
#define SOCK_MT_LOCK_RECV (1 << 1)
|
||||
#define SOCK_MT_LOCK_IOCTL (1 << 2)
|
||||
|
||||
#define SOCK_MT_LOCK_MIN SOCK_MT_LOCK_SEND
|
||||
#define SOCK_MT_LOCK_MAX SOCK_MT_LOCK_IOCTL
|
||||
|
||||
#define SOCK_MT_SELECT_RECV (1 << 0)
|
||||
#define SOCK_MT_SELECT_SEND (1 << 1)
|
||||
|
||||
typedef struct _sock_mt {
|
||||
uint8_t opened : 1;
|
||||
uint8_t state : 2;
|
||||
uint8_t select : 2;
|
||||
uint8_t lock : 3;
|
||||
} sock_mt_t;
|
||||
|
||||
#if (SOCK_MT_DEBUG_LEVEL < 16)
|
||||
#define SOCK_MT_DEBUG(level, ...) \
|
||||
if (level >= SOCK_MT_DEBUG_LEVEL) \
|
||||
printf(__VA_ARGS__);
|
||||
#else
|
||||
#define SOCK_MT_DEBUG(level, ...)
|
||||
#endif
|
||||
|
||||
#define SOCK_MT_ENTER_CHECK(s, l, st) \
|
||||
{ \
|
||||
if (_sock_lock(s, l) != ERR_OK) \
|
||||
return -1; \
|
||||
if (st != SOCK_MT_STATE_ILL) \
|
||||
_sock_set_state(s, st); \
|
||||
}
|
||||
|
||||
#define SOCK_MT_EXIT_CHECK(s, l, st) \
|
||||
{ \
|
||||
if (st != SOCK_MT_STATE_ILL) \
|
||||
_sock_set_state(s, SOCK_MT_STATE_SOCK); \
|
||||
if (_sock_unlock(s, l) != ERR_OK) \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
static volatile sock_mt_t DRAM_ATTR sockets_mt[NUM_SOCKETS];
|
||||
|
||||
static inline void _sock_mt_init(int s)
|
||||
{
|
||||
memset((void *)&sockets_mt[s - LWIP_SOCKET_OFFSET], 0, sizeof(sock_mt_t));
|
||||
}
|
||||
|
||||
static inline int _sock_is_opened(int s)
|
||||
{
|
||||
return sockets_mt[s - LWIP_SOCKET_OFFSET].opened != 0;
|
||||
}
|
||||
|
||||
static inline void _sock_set_open(int s, int opened)
|
||||
{
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].opened = opened;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
}
|
||||
|
||||
static inline void _sock_set_state(int s, int state)
|
||||
{
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].state = state;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
}
|
||||
|
||||
static inline int _sock_get_state(int s)
|
||||
{
|
||||
return sockets_mt[s - LWIP_SOCKET_OFFSET].state;
|
||||
}
|
||||
|
||||
static inline int _sock_get_select(int s, int select)
|
||||
{
|
||||
return sockets_mt[s - LWIP_SOCKET_OFFSET].select & select;
|
||||
}
|
||||
|
||||
static int inline _sock_is_lock(int s, int l)
|
||||
{
|
||||
return sockets_mt[s - LWIP_SOCKET_OFFSET].lock & l;
|
||||
}
|
||||
|
||||
static int inline _sock_next_lock(int lock)
|
||||
{
|
||||
return lock << 1;
|
||||
}
|
||||
|
||||
static void inline _sock_set_select(int s, int select)
|
||||
{
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].select |= select;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
}
|
||||
|
||||
static void inline _sock_reset_select(int s, int select)
|
||||
{
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].select &= ~select;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
}
|
||||
|
||||
static int _sock_try_lock(int s, int l)
|
||||
{
|
||||
int ret = ERR_OK;
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
if (!_sock_is_opened(s)) {
|
||||
ret = ERR_CLSD;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (sockets_mt[s - LWIP_SOCKET_OFFSET].lock & l) {
|
||||
ret = ERR_INPROGRESS;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].lock |= l;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
exit:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int _sock_lock(int s, int l)
|
||||
{
|
||||
int ret = ERR_OK;
|
||||
if (tryget_socket_unconn_nouse(s) == NULL)
|
||||
return -1;
|
||||
|
||||
SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l);
|
||||
|
||||
while (1) {
|
||||
ret = _sock_try_lock(s, l);
|
||||
|
||||
if (ret != ERR_INPROGRESS)
|
||||
break;
|
||||
|
||||
vTaskDelay(1);
|
||||
}
|
||||
|
||||
SOCK_MT_DEBUG(1, "OK %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int _sock_unlock(int s, int l)
|
||||
{
|
||||
int ret = 0;
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
SOCK_MT_DEBUG(1, "s %d l %d exit ", s, l);
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
sockets_mt[s - LWIP_SOCKET_OFFSET].lock &= ~l;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
if (!_sock_is_opened(s)) {
|
||||
ret = ERR_CLSD;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
exit:
|
||||
SOCK_MT_DEBUG(1, "OK %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int lwip_enter_mt_select(int s, fd_set *read_set, fd_set *write_set)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (s > NUM_SOCKETS + LWIP_SOCKET_OFFSET || s < LWIP_SOCKET_OFFSET)
|
||||
return -1;
|
||||
|
||||
for (i = 0; i < s; i++) {
|
||||
if(FD_ISSET(i, read_set) || FD_ISSET(i, write_set))
|
||||
if (tryget_socket_unconn_nouse(i) == NULL)
|
||||
goto failed1;
|
||||
|
||||
if (FD_ISSET(i, read_set)) {
|
||||
err_t err;
|
||||
|
||||
_sock_set_select(i, SOCK_MT_SELECT_RECV);
|
||||
err = _sock_lock(i, SOCK_MT_LOCK_RECV);
|
||||
if (err != ERR_OK) {
|
||||
goto failed2;
|
||||
}
|
||||
}
|
||||
|
||||
if (FD_ISSET(i, write_set)) {
|
||||
err_t err;
|
||||
|
||||
_sock_set_select(i, SOCK_MT_SELECT_SEND);
|
||||
err = _sock_lock(i, SOCK_MT_LOCK_SEND);
|
||||
if (err != ERR_OK) {
|
||||
goto failed3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
failed3:
|
||||
_sock_unlock(i, SOCK_MT_LOCK_SEND);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_SEND);
|
||||
failed2:
|
||||
if (FD_ISSET(i, read_set)) {
|
||||
_sock_unlock(i, SOCK_MT_LOCK_RECV);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_RECV);
|
||||
}
|
||||
failed1:
|
||||
for (i--; i >=0; i--) {
|
||||
if (FD_ISSET(i, read_set) ) {
|
||||
_sock_unlock(i, SOCK_MT_LOCK_RECV);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_RECV);
|
||||
}
|
||||
|
||||
if (FD_ISSET(i, write_set)) {
|
||||
_sock_unlock(i, SOCK_MT_LOCK_SEND);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_SEND);
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void lwip_exit_mt_select(int s, fd_set *read_set, fd_set *write_set)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < s; i++) {
|
||||
if (FD_ISSET(i, read_set)) {
|
||||
_sock_unlock(i, SOCK_MT_LOCK_RECV);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_RECV);
|
||||
}
|
||||
|
||||
if (FD_ISSET(i, write_set)) {
|
||||
_sock_unlock(i, SOCK_MT_LOCK_SEND);
|
||||
_sock_reset_select(i, SOCK_MT_SELECT_SEND);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static err_t lwip_do_sync_accept(struct tcpip_api_call_data *call)
|
||||
{
|
||||
socket_conn_sync_t *sync = (socket_conn_sync_t *)call;
|
||||
struct netconn *conn = sync->conn;
|
||||
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
if (sys_mbox_valid(&conn->acceptmbox))
|
||||
sys_mbox_trypost(&conn->acceptmbox, NULL);
|
||||
conn->state = NETCONN_NONE;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t lwip_do_sync_send(struct tcpip_api_call_data *call)
|
||||
{
|
||||
socket_conn_sync_t *sync = (socket_conn_sync_t *)call;
|
||||
struct netconn *conn = sync->conn;
|
||||
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
if (conn->current_msg) {
|
||||
conn->current_msg->err = ERR_OK;
|
||||
if (sys_sem_valid(conn->current_msg->op_completed_sem))
|
||||
sys_sem_signal(conn->current_msg->op_completed_sem);
|
||||
conn->current_msg = NULL;
|
||||
}
|
||||
conn->state = NETCONN_NONE;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t lwip_do_sync_recv_state(struct tcpip_api_call_data *call)
|
||||
{
|
||||
socket_conn_sync_t *sync = (socket_conn_sync_t *)call;
|
||||
struct netconn *conn = sync->conn;
|
||||
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
SOCK_MT_DEBUG(1, "sync recv %d\n", conn->socket);
|
||||
if (sys_mbox_valid(&conn->recvmbox))
|
||||
sys_mbox_trypost(&conn->recvmbox, NULL);
|
||||
conn->state = NETCONN_NONE;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t lwip_do_sync_select_state(struct tcpip_api_call_data *call)
|
||||
{
|
||||
socket_conn_sync_t *sync = (socket_conn_sync_t *)call;
|
||||
struct netconn *conn = sync->conn;
|
||||
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
event_callback(conn, NETCONN_EVT_ERROR, 0);
|
||||
conn->state = NETCONN_NONE;
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static void lwip_sync_state_mt(int s)
|
||||
{
|
||||
struct lwip_sock *sock = tryget_socket_unconn_nouse(s);
|
||||
int state = _sock_get_state(s);
|
||||
socket_conn_sync_t sync = {
|
||||
.conn = sock->conn,
|
||||
};
|
||||
|
||||
SOCK_MT_DEBUG(1, "sync state %d\n", state);
|
||||
|
||||
switch (state) {
|
||||
case SOCK_MT_STATE_ACCEPT :
|
||||
tcpip_api_call(lwip_do_sync_accept, &sync.call);
|
||||
break;
|
||||
case SOCK_MT_STATE_CONNECT:
|
||||
case SOCK_MT_STATE_SEND :
|
||||
tcpip_api_call(lwip_do_sync_send, &sync.call);
|
||||
break;
|
||||
default :
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void lwip_sync_recv_mt(int s)
|
||||
{
|
||||
struct lwip_sock *sock = tryget_socket_unconn_nouse(s);
|
||||
socket_conn_sync_t sync = {
|
||||
.conn = sock->conn,
|
||||
};
|
||||
|
||||
tcpip_api_call(lwip_do_sync_recv_state, &sync.call);
|
||||
}
|
||||
|
||||
static void lwip_sync_select_mt(int s)
|
||||
{
|
||||
struct lwip_sock *sock = tryget_socket_unconn_nouse(s);
|
||||
socket_conn_sync_t sync = {
|
||||
.conn = sock->conn,
|
||||
};
|
||||
|
||||
tcpip_api_call(lwip_do_sync_select_state, &sync.call);
|
||||
}
|
||||
|
||||
static void lwip_sync_mt(int s, int how)
|
||||
{
|
||||
int lock = SOCK_MT_LOCK_MIN;
|
||||
|
||||
do {
|
||||
if (_sock_is_lock(s, lock)) {
|
||||
int need_wait = 0;
|
||||
|
||||
if (!_sock_get_select(s, SOCK_MT_SELECT_RECV | SOCK_MT_SELECT_SEND)) {
|
||||
switch (lock) {
|
||||
case SOCK_MT_LOCK_SEND:
|
||||
lwip_sync_state_mt(s);
|
||||
need_wait = 1;
|
||||
break;
|
||||
case SOCK_MT_LOCK_RECV:
|
||||
lwip_sync_recv_mt(s);
|
||||
need_wait = 1;
|
||||
break;
|
||||
default :
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
lwip_sync_select_mt(s);
|
||||
need_wait = 1;
|
||||
}
|
||||
|
||||
if (need_wait)
|
||||
sys_delay_ms(LWIP_SYNC_MT_SLEEP_MS);
|
||||
} else
|
||||
lock = _sock_next_lock(lock);
|
||||
} while (lock < SOCK_MT_LOCK_MAX);
|
||||
}
|
||||
|
||||
#if SET_SOLINGER_DEFAULT
|
||||
#if LWIP_SO_LINGER
|
||||
static void lwip_socket_set_so_link(int s, int linger)
|
||||
{
|
||||
struct lwip_sock *sock = tryget_socket_unconn_nouse(s);
|
||||
|
||||
if (sock) {
|
||||
/*
|
||||
* linker:
|
||||
* -1: nothing
|
||||
* 0: free sent_buf immediately
|
||||
*/
|
||||
sock->conn->linger = linger;
|
||||
}
|
||||
}
|
||||
#else
|
||||
#error "LWIP_SO_LINGER must be enable"
|
||||
#endif /* LWIP_SO_LINGER */
|
||||
#else /* SET_SOLINGER_DEFAULT */
|
||||
#define lwip_socket_set_so_link(_s, _linger)
|
||||
#endif /* SET_SOLINGER_DEFAULT */
|
||||
|
||||
int lwip_socket(int domain, int type, int protocol)
|
||||
{
|
||||
int s;
|
||||
|
||||
s = lwip_socket_esp(domain, type, protocol);
|
||||
if (s < 0)
|
||||
return -1;
|
||||
|
||||
lwip_socket_set_so_link(s, 0);
|
||||
_sock_mt_init(s);
|
||||
_sock_set_open(s, 1);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_bind_esp(s, name, namelen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_CONNECT);
|
||||
|
||||
ret = lwip_connect_esp(s, name, namelen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_CONNECT);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_listen(int s, int backlog)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL);
|
||||
|
||||
lwip_socket_set_so_link(s, -1);
|
||||
|
||||
ret = lwip_listen_esp(s, backlog);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ACCEPT)
|
||||
|
||||
lwip_socket_set_so_link(s, -1);
|
||||
|
||||
ret = lwip_accept_esp(s, addr, addrlen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ACCEPT);
|
||||
|
||||
if (ret < 0)
|
||||
return -1;
|
||||
|
||||
lwip_socket_set_so_link(ret, 0);
|
||||
_sock_mt_init(ret);
|
||||
_sock_set_open(ret, 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_getpeername_esp(s, name, namelen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_getsockname_esp(s, name, namelen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_setsockopt_esp(s, level, optname, optval, optlen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (tryget_socket_unconn_nouse(s) == NULL)
|
||||
return -1;
|
||||
|
||||
if (optname == SO_ERROR) {
|
||||
int retval = 0;
|
||||
|
||||
if (!_sock_is_opened(s))
|
||||
retval = ENOTCONN;
|
||||
|
||||
if (retval) {
|
||||
*(int *)optval = retval;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_getsockopt_esp(s, level, optname, optval, optlen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_ioctl(int s, long cmd, void *argp)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL)
|
||||
|
||||
ret = lwip_ioctl_esp(s, cmd, argp);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_sendto(int s, const void *data, size_t size, int flags,
|
||||
const struct sockaddr *to, socklen_t tolen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND);
|
||||
|
||||
ret = lwip_sendto_esp(s, data, size, flags, to, tolen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_send(int s, const void *data, size_t size, int flags)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND);
|
||||
|
||||
ret = lwip_send_esp(s, data, size, flags);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_recvfrom(int s, void *mem, size_t len, int flags,
|
||||
struct sockaddr *from, socklen_t *fromlen)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_RECV, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_recvfrom_esp(s, mem, len, flags, from, fromlen);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_RECV, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_recv(int s, void *mem, size_t len, int flags)
|
||||
{
|
||||
return lwip_recvfrom(s, mem, len, flags, NULL, NULL);
|
||||
}
|
||||
|
||||
int lwip_read(int s, void *mem, size_t len)
|
||||
{
|
||||
return lwip_recvfrom(s, mem, len, 0, NULL, NULL);
|
||||
}
|
||||
|
||||
int lwip_write(int s, const void *data, size_t size)
|
||||
{
|
||||
return lwip_send(s, data, size, 0);
|
||||
}
|
||||
|
||||
int lwip_fcntl(int s, int cmd, int val)
|
||||
{
|
||||
int ret;
|
||||
|
||||
SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
ret = lwip_fcntl_esp(s, cmd, val);
|
||||
|
||||
SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_shutdown(int s, int how)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lwip_close(int s)
|
||||
{
|
||||
int ret;
|
||||
SYS_ARCH_DECL_PROTECT(lev);
|
||||
|
||||
if (tryget_socket_unconn_nouse(s) == NULL)
|
||||
return -1;
|
||||
|
||||
SYS_ARCH_PROTECT(lev);
|
||||
if (_sock_is_opened(s)) {
|
||||
_sock_set_open(s, 0);
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
} else {
|
||||
SYS_ARCH_UNPROTECT(lev);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
lwip_sync_mt(s, SHUT_RDWR);
|
||||
|
||||
ret = lwip_close_esp(s);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset,
|
||||
fd_set *exceptset, struct timeval *timeout)
|
||||
{
|
||||
int ret;
|
||||
fd_set read_set, write_set;
|
||||
|
||||
if (readset)
|
||||
MEMCPY(&read_set, readset, sizeof(fd_set));
|
||||
else
|
||||
FD_ZERO(&read_set);
|
||||
|
||||
if (writeset)
|
||||
MEMCPY(&write_set, writeset, sizeof(fd_set));
|
||||
else
|
||||
FD_ZERO(&write_set);
|
||||
|
||||
ret = lwip_enter_mt_select(maxfdp1, &read_set, &write_set);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = lwip_select_esp(maxfdp1, readset, writeset, exceptset, timeout);
|
||||
|
||||
lwip_exit_mt_select(maxfdp1, &read_set, &write_set);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -112,13 +112,15 @@ static int esp_ping_receive(esp_ping_t *ep)
|
||||
struct sockaddr_in *from4 = (struct sockaddr_in *)&from;
|
||||
inet_addr_to_ip4addr(ip_2_ip4(&ep->recv_addr), &from4->sin_addr);
|
||||
IP_SET_TYPE_VAL(ep->recv_addr, IPADDR_TYPE_V4);
|
||||
} else {
|
||||
}
|
||||
#if LWIP_IPV6
|
||||
else {
|
||||
// IPv6
|
||||
struct sockaddr_in6 *from6 = (struct sockaddr_in6 *)&from;
|
||||
inet6_addr_to_ip6addr(ip_2_ip6(&ep->recv_addr), &from6->sin6_addr);
|
||||
IP_SET_TYPE_VAL(ep->recv_addr, IPADDR_TYPE_V6);
|
||||
}
|
||||
|
||||
#endif
|
||||
// Currently we only process IPv4
|
||||
if (IP_IS_V4_VAL(ep->recv_addr)) {
|
||||
struct ip_hdr *iphdr = (struct ip_hdr *)buf;
|
||||
@ -236,12 +238,18 @@ esp_err_t esp_ping_new_session(const esp_ping_config_t *config, const esp_ping_c
|
||||
d[i] = 'A' + i;
|
||||
}
|
||||
|
||||
/* create socket */
|
||||
if (IP_IS_V4(&config->target_addr) || ip6_addr_isipv4mappedipv6(ip_2_ip6(&config->target_addr))) {
|
||||
#if LWIP_IPV4 && LWIP_IPV6
|
||||
if (IP_IS_V4(&config->target_addr) || ip6_addr_isipv4mappedipv6(ip_2_ip6(&config->target_addr))) {
|
||||
ep->sock = socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP);
|
||||
} else {
|
||||
ep->sock = socket(AF_INET6, SOCK_RAW, IP6_NEXTH_ICMP6);
|
||||
}
|
||||
#else
|
||||
if (IP_IS_V4(&config->target_addr)) {
|
||||
ep->sock = socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP);
|
||||
} else {
|
||||
ep->sock = socket(AF_INET6, SOCK_RAW, IP6_NEXTH_ICMP6);
|
||||
}
|
||||
#endif
|
||||
|
||||
PING_CHECK(ep->sock > 0, "create socket failed: %d", err, ESP_FAIL, ep->sock);
|
||||
|
||||
struct timeval timeout;
|
||||
@ -259,11 +267,13 @@ esp_err_t esp_ping_new_session(const esp_ping_config_t *config, const esp_ping_c
|
||||
to4->sin_family = AF_INET;
|
||||
inet_addr_from_ip4addr(&to4->sin_addr, ip_2_ip4(&config->target_addr));
|
||||
}
|
||||
#if LWIP_IPV6
|
||||
if (IP_IS_V6(&config->target_addr)) {
|
||||
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&ep->target_addr;
|
||||
to6->sin6_family = AF_INET6;
|
||||
inet6_addr_from_ip6addr(&to6->sin6_addr, ip_2_ip6(&config->target_addr));
|
||||
}
|
||||
#endif
|
||||
/* return ping handle to user */
|
||||
*hdl_out = (esp_ping_handle_t)ep;
|
||||
return ESP_OK;
|
||||
|
||||
Reference in New Issue
Block a user