mirror of
https://github.com/espressif/ESP8266_RTOS_SDK.git
synced 2025-05-24 02:28:21 +08:00
935 lines
25 KiB
C
935 lines
25 KiB
C
|
|
#include "lwip/opt.h"
|
|
|
|
#ifdef SOCKETS_MT
|
|
|
|
#include "../../lwip/src/api/sockets.c"
|
|
|
|
#ifndef LWIP_SYNC_MT_SLEEP_MS
|
|
#define LWIP_SYNC_MT_SLEEP_MS 10
|
|
#endif
|
|
|
|
#ifndef SOCK_MT_DEBUG_LEVEL
|
|
#define SOCK_MT_DEBUG_LEVEL 255
|
|
#endif
|
|
|
|
typedef int (*lwip_io_mt_fn)(int , int );
|
|
|
|
enum sock_mt_stat{
|
|
SOCK_MT_STATE_NONE = 0,
|
|
SOCK_MT_STATE_BIND,
|
|
SOCK_MT_STATE_LISTEN,
|
|
SOCK_MT_STATE_ACCEPT,
|
|
SOCK_MT_STATE_CONNECT,
|
|
SOCK_MT_STATE_SEND,
|
|
};
|
|
|
|
enum sock_mt_shutdown {
|
|
SOCK_MT_SHUTDOWN_OK = 0,
|
|
SOCK_MT_SHUTDOWN_NONE
|
|
};
|
|
|
|
enum sock_mt_module {
|
|
SOCK_MT_STATE,
|
|
SOCK_MT_RECV,
|
|
SOCK_MT_IOCTL,
|
|
SOCK_MT_SELECT,
|
|
|
|
SOCK_MT_SHUTDOWN,
|
|
|
|
SOCK_MT_CLOSE,
|
|
|
|
SOCK_MT_MODULE_MAX,
|
|
};
|
|
|
|
enum sock_mt_lock {
|
|
SOCK_MT_STATE_LOCK,
|
|
SOCK_MT_RECV_LOCK,
|
|
SOCK_MT_IOCTRL_LOCK,
|
|
|
|
SOCK_MT_LOCK_MAX,
|
|
};
|
|
|
|
struct _sock_mt {
|
|
|
|
enum sock_mt_shutdown shutdown;
|
|
|
|
enum sock_mt_stat state;
|
|
|
|
int sel;
|
|
|
|
sys_mutex_t lock[SOCK_MT_LOCK_MAX];
|
|
};
|
|
typedef struct _sock_mt 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
|
|
|
|
#if 0
|
|
#define SOCK_MT_LOCK(s, l) \
|
|
{ \
|
|
SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \
|
|
sys_mutex_lock(&sockets_mt[s].lock[l]); \
|
|
SOCK_MT_DEBUG(1, "OK\n"); \
|
|
}
|
|
|
|
#define SOCK_MT_LOCK_RET(s, l, r) \
|
|
{ \
|
|
SOCK_MT_LOCK(s, l); \
|
|
r = ERR_OK; \
|
|
}
|
|
#else
|
|
#define SOCK_MT_LOCK(s, l) \
|
|
{ \
|
|
SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \
|
|
while (1) { \
|
|
err_t err; \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
\
|
|
SYS_ARCH_PROTECT(lev); \
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) \
|
|
err = ERR_CLSD; \
|
|
else \
|
|
err = ERR_OK; \
|
|
if (err == ERR_OK) { \
|
|
if (sockets_mt[s].lock[l]) \
|
|
err = sys_mutex_trylock(&sockets_mt[s].lock[l]); \
|
|
else \
|
|
err = ERR_VAL; \
|
|
} \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
\
|
|
if (err == ERR_OK) \
|
|
break; \
|
|
else if (err == ERR_VAL || err == ERR_CLSD) \
|
|
return -1; \
|
|
\
|
|
vTaskDelay(1); \
|
|
} \
|
|
SOCK_MT_DEBUG(1, "OK\n"); \
|
|
}
|
|
|
|
#define SOCK_MT_LOCK_RET(s, l, r) \
|
|
{ \
|
|
SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \
|
|
while (1) { \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
\
|
|
SYS_ARCH_PROTECT(lev); \
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) \
|
|
r = ERR_CLSD; \
|
|
else \
|
|
r = ERR_OK; \
|
|
if (r == ERR_OK) { \
|
|
if (sockets_mt[s].lock[l]) \
|
|
r = sys_mutex_trylock(&sockets_mt[s].lock[l]); \
|
|
else \
|
|
r = ERR_VAL; \
|
|
} \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
\
|
|
if (r == ERR_OK || r == ERR_VAL || r == ERR_CLSD) \
|
|
break; \
|
|
vTaskDelay(1); \
|
|
} \
|
|
SOCK_MT_DEBUG(1, "OK\n"); \
|
|
}
|
|
#endif
|
|
|
|
#define SOCK_MT_TRYLOCK(s, l, r) \
|
|
{ \
|
|
SOCK_MT_DEBUG(1, "s %d l %d try enter ", s, l); \
|
|
r = sys_mutex_trylock(&sockets_mt[s].lock[l]); \
|
|
SOCK_MT_DEBUG(1, "ret %d OK\n", r); \
|
|
}
|
|
|
|
#define SOCK_MT_UNLOCK(s, l) \
|
|
{ \
|
|
SOCK_MT_DEBUG(1, "s %d l %d exit ", s, l); \
|
|
sys_mutex_unlock(&sockets_mt[s].lock[l]); \
|
|
SOCK_MT_DEBUG(1, "OK\n"); \
|
|
}
|
|
|
|
|
|
#define SOCK_MT_SET_STATE(s, stat) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].state = stat; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_GET_STATE(s) \
|
|
sockets_mt[s].state
|
|
|
|
#define SOCK_MT_SET_SHUTDOWN(s, d) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].shutdown = d; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_GET_SHUTDOWN(s) \
|
|
sockets_mt[s].shutdown
|
|
|
|
#define SOCK_MT_SET_WRITE_SEL(s) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].sel |= 0x1; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_RESET_WRITE_SEL(s) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].sel &= ~0x1; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_GET_WRITE_SEL(s) \
|
|
(sockets_mt[s].sel & 0x01)
|
|
|
|
#define SOCK_MT_SET_READ_SEL(s) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].sel |= 0x2; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_RESET_READ_SEL(s) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sockets_mt[s].sel &= ~0x2; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define SOCK_MT_GET_READ_SEL(s) \
|
|
(sockets_mt[s].sel & 0x02)
|
|
|
|
#define SOCK_MT_GET_SEL(s) \
|
|
sockets_mt[s].sel
|
|
|
|
#define SOCK_MT_SET_LINGER(sock) \
|
|
{ \
|
|
SYS_ARCH_DECL_PROTECT(lev); \
|
|
SYS_ARCH_PROTECT(lev); \
|
|
sock->conn->linger = 1; \
|
|
SYS_ARCH_UNPROTECT(lev); \
|
|
}
|
|
|
|
#define LWIP_ENTER_MT(s, m, p) \
|
|
{ \
|
|
int r; \
|
|
SOCK_MT_DEBUG(1, "enter s %d module %d args %d\n", s, m, p); \
|
|
r = lwip_enter_mt_table[m](s, p); \
|
|
SOCK_MT_DEBUG(1, "enter s %d ret %d\n", s, r); \
|
|
if (r) \
|
|
return -1; \
|
|
}
|
|
|
|
#define LWIP_EXIT_MT(s, m, p) \
|
|
{ \
|
|
int r; \
|
|
SOCK_MT_DEBUG(1, "exit s %d module %d args %d\n", s, m, p); \
|
|
r = lwip_exit_mt_table[m](s, p); \
|
|
SOCK_MT_DEBUG(1, "exit s %d ret %d\n", s, r); \
|
|
if (r) \
|
|
return -1; \
|
|
}
|
|
|
|
|
|
static sock_mt_t sockets_mt[NUM_SOCKETS];
|
|
|
|
static int lwip_enter_mt_state(int s, int arg)
|
|
{
|
|
if(tryget_socket(s) == NULL ||
|
|
SOCK_MT_GET_STATE(s) != SOCK_MT_STATE_NONE ||
|
|
SOCK_MT_GET_WRITE_SEL(s))
|
|
return -1;
|
|
|
|
SOCK_MT_LOCK(s, SOCK_MT_STATE_LOCK);
|
|
SOCK_MT_SET_STATE(s, arg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_enter_mt_recv(int s, int arg)
|
|
{
|
|
if(tryget_socket(s) == NULL ||
|
|
SOCK_MT_GET_READ_SEL(s))
|
|
return -1;
|
|
|
|
SOCK_MT_LOCK(s, SOCK_MT_RECV_LOCK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_enter_mt_shutdown(int s, int arg)
|
|
{
|
|
if(tryget_socket(s) == NULL
|
|
|| SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE)
|
|
return -1;
|
|
|
|
SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_OK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_enter_mt_close(int s, int arg)
|
|
{
|
|
if(tryget_socket(s) == NULL)
|
|
return -1;
|
|
|
|
SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_OK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int lwip_enter_mt_select(int s, int arg)
|
|
{
|
|
int i;
|
|
int *fdset = (int *)arg;
|
|
fd_set *read_set = (fd_set *)fdset[0];
|
|
fd_set *write_set = (fd_set *)fdset[1];
|
|
|
|
if (s > NUM_SOCKETS || s < 0)
|
|
return -1;
|
|
|
|
for (i = 0; i < s; i++) {
|
|
if(FD_ISSET(i, read_set) || FD_ISSET(i, write_set))
|
|
if (tryget_socket(i) == NULL)
|
|
goto failed1;
|
|
|
|
if (FD_ISSET(i, read_set)) {
|
|
err_t err;
|
|
|
|
SOCK_MT_SET_READ_SEL(i);
|
|
SOCK_MT_LOCK_RET(i, SOCK_MT_RECV_LOCK, err);
|
|
if (err != ERR_OK) {
|
|
goto failed2;
|
|
}
|
|
}
|
|
|
|
if (FD_ISSET(i, write_set)) {
|
|
err_t err;
|
|
|
|
SOCK_MT_SET_WRITE_SEL(i);
|
|
SOCK_MT_LOCK_RET(i, SOCK_MT_STATE_LOCK, err);
|
|
if (err != ERR_OK) {
|
|
goto failed3;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
failed3:
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK);
|
|
SOCK_MT_RESET_WRITE_SEL(i);
|
|
failed2:
|
|
if (FD_ISSET(i, read_set)) {
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK);
|
|
SOCK_MT_RESET_READ_SEL(i);
|
|
}
|
|
failed1:
|
|
for (i--; i >=0; i--) {
|
|
if (FD_ISSET(i, read_set) ){
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK);
|
|
SOCK_MT_RESET_READ_SEL(i);
|
|
}
|
|
|
|
if (FD_ISSET(i, write_set)) {
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK);
|
|
SOCK_MT_RESET_WRITE_SEL(i);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int lwip_enter_mt_ioctrl(int s, int arg)
|
|
{
|
|
if(tryget_socket(s) == NULL)
|
|
return -1;
|
|
|
|
SOCK_MT_LOCK(s, SOCK_MT_IOCTRL_LOCK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_state(int s, int arg)
|
|
{
|
|
SOCK_MT_SET_STATE(s, SOCK_MT_STATE_NONE);
|
|
SOCK_MT_UNLOCK(s, SOCK_MT_STATE_LOCK);
|
|
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_recv(int s, int arg)
|
|
{
|
|
SOCK_MT_UNLOCK(s, SOCK_MT_RECV_LOCK);
|
|
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_shutdown(int s, int arg)
|
|
{
|
|
//SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_STATE_NONE);
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_close(int s, int arg)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_select(int s, int arg)
|
|
{
|
|
int i;
|
|
int *fdset = (int *)arg;
|
|
fd_set *read_set = (fd_set *)fdset[0];
|
|
fd_set *write_set = (fd_set *)fdset[1];
|
|
|
|
for (i = 0; i < s; i++) {
|
|
if (FD_ISSET(i, read_set)) {
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK);
|
|
SOCK_MT_RESET_READ_SEL(i);
|
|
}
|
|
|
|
if (FD_ISSET(i, write_set)) {
|
|
SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK);
|
|
SOCK_MT_RESET_WRITE_SEL(i);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < s; i++) {
|
|
if ((FD_ISSET(i, read_set) || FD_ISSET(i, write_set)) \
|
|
&& SOCK_MT_GET_SHUTDOWN(i) != SOCK_MT_SHUTDOWN_NONE) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int lwip_exit_mt_ioctrl(int s, int arg)
|
|
{
|
|
SOCK_MT_UNLOCK(s, SOCK_MT_IOCTRL_LOCK);
|
|
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const lwip_io_mt_fn lwip_enter_mt_table[] = {
|
|
lwip_enter_mt_state,
|
|
lwip_enter_mt_recv,
|
|
lwip_enter_mt_ioctrl,
|
|
lwip_enter_mt_select,
|
|
lwip_enter_mt_shutdown,
|
|
lwip_enter_mt_close
|
|
};
|
|
|
|
static const lwip_io_mt_fn lwip_exit_mt_table[] = {
|
|
lwip_exit_mt_state,
|
|
lwip_exit_mt_recv,
|
|
lwip_exit_mt_ioctrl,
|
|
lwip_exit_mt_select,
|
|
lwip_exit_mt_shutdown,
|
|
lwip_exit_mt_close
|
|
};
|
|
|
|
static void lwip_do_sync_send(void *arg)
|
|
{
|
|
struct netconn *conn = arg;
|
|
|
|
SYS_ARCH_DECL_PROTECT(lev);
|
|
SYS_ARCH_PROTECT(lev);
|
|
if (conn->current_msg) {
|
|
conn->current_msg->err = ERR_OK;
|
|
conn->current_msg = NULL;
|
|
}
|
|
conn->state = NETCONN_NONE;
|
|
SYS_ARCH_UNPROTECT(lev);
|
|
if (sys_sem_valid(&(conn->snd_op_completed)))
|
|
sys_sem_signal(&(conn->snd_op_completed));
|
|
|
|
/*
|
|
* if we use "op_completed" for its sync semaphore, then socket functions
|
|
* which are blocked by op_completed will be waked up.
|
|
*
|
|
* So we had better use a specific semaphore for the function, ioctrl_completed
|
|
* may be a good choise.
|
|
*/
|
|
sys_sem_signal(&(conn->ioctrl_completed));
|
|
}
|
|
|
|
static void lwip_do_sync_rst_state(void *arg)
|
|
{
|
|
struct netconn *conn = arg;
|
|
|
|
SYS_ARCH_DECL_PROTECT(lev);
|
|
SYS_ARCH_PROTECT(lev);
|
|
conn->state = NETCONN_NONE;
|
|
SYS_ARCH_UNPROTECT(lev);
|
|
|
|
sys_sem_signal(&(conn->ioctrl_completed));
|
|
}
|
|
|
|
static void lwip_sync_state_mt(struct lwip_sock *sock , int state)
|
|
{
|
|
SOCK_MT_DEBUG(1, "sync state %d\n", state);
|
|
|
|
switch (state) {
|
|
case SOCK_MT_STATE_ACCEPT :
|
|
if (sys_mbox_valid(&sock->conn->acceptmbox))
|
|
sys_mbox_trypost(&sock->conn->acceptmbox, NULL);
|
|
break;
|
|
case SOCK_MT_STATE_SEND :
|
|
{
|
|
tcpip_callback(lwip_do_sync_send, sock->conn);
|
|
sys_arch_sem_wait(&sock->conn->ioctrl_completed, 0);
|
|
break;
|
|
}
|
|
case SOCK_MT_STATE_CONNECT :
|
|
if (sys_sem_valid(&(sock->conn->op_completed)))
|
|
sys_sem_signal(&(sock->conn->op_completed));
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void lwip_sync_recv_mt(struct lwip_sock *sock)
|
|
{
|
|
SOCK_MT_DEBUG(1, "sync recv %d\n", sock->conn->socket);
|
|
if (sys_mbox_valid(&sock->conn->recvmbox))
|
|
sys_mbox_trypost(&sock->conn->recvmbox, NULL);
|
|
}
|
|
|
|
static void lwip_sync_select_mt(struct lwip_sock *sock)
|
|
{
|
|
SOCK_MT_DEBUG(1, "sync select %d\n", sock->conn->socket);
|
|
event_callback(sock->conn, NETCONN_EVT_ERROR, 0);
|
|
}
|
|
|
|
|
|
static void lwip_sync_mt(int s)
|
|
{
|
|
int module = 0;
|
|
int ret;
|
|
struct lwip_sock *sock;
|
|
|
|
while (module < SOCK_MT_SELECT) {
|
|
extern void sys_arch_msleep(int ms);
|
|
int ret;
|
|
|
|
SOCK_MT_TRYLOCK(s, module, ret);
|
|
if (ret == ERR_OK) {
|
|
/*
|
|
* we always lock the mutex in case of other thread entering,
|
|
* other thread will be blocked at "SOCK_MT_LOCK" and poll-check
|
|
*/
|
|
//SOCK_MT_UNLOCK(s, module);
|
|
module++;
|
|
continue;
|
|
}
|
|
|
|
sock = get_socket(s);
|
|
#if LWIP_SO_LINGER
|
|
if (SOCK_MT_GET_STATE(s) == SOCK_MT_STATE_SEND) {
|
|
SOCK_MT_SET_LINGER(sock);
|
|
}
|
|
#endif
|
|
if (!SOCK_MT_GET_SEL(s)) {
|
|
switch (module) {
|
|
case SOCK_MT_STATE:
|
|
lwip_sync_state_mt(sock, SOCK_MT_GET_STATE(s));
|
|
break;
|
|
case SOCK_MT_RECV:
|
|
lwip_sync_recv_mt(sock);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
} else {
|
|
lwip_sync_select_mt(sock);
|
|
}
|
|
|
|
sys_arch_msleep(LWIP_SYNC_MT_SLEEP_MS);
|
|
}
|
|
|
|
sock = tryget_socket(s);
|
|
if (sock) {
|
|
tcpip_callback(lwip_do_sync_rst_state, sock->conn);
|
|
sys_arch_sem_wait(&sock->conn->ioctrl_completed, 0);
|
|
}
|
|
}
|
|
|
|
int lwip_socket_mt(int domain, int type, int protocol)
|
|
{
|
|
int s;
|
|
int i;
|
|
|
|
s = lwip_socket(domain, type, protocol);
|
|
if (s < 0)
|
|
return -1;
|
|
|
|
for (i = 0; i < SOCK_MT_LOCK_MAX; i++) {
|
|
if (sys_mutex_new(&sockets_mt[s].lock[i]) != ERR_OK)
|
|
break;
|
|
}
|
|
if (i < SOCK_MT_LOCK_MAX) {
|
|
for (i-- ; i >= 0; i--) {
|
|
sys_mutex_free(&sockets_mt[s].lock[i]);
|
|
sockets_mt[s].lock[i] = NULL;
|
|
}
|
|
|
|
lwip_close(s);
|
|
s = -1;
|
|
}
|
|
|
|
if (s >= 0)
|
|
SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_NONE);
|
|
|
|
return s;
|
|
}
|
|
|
|
int lwip_bind_mt(int s, const struct sockaddr *name, socklen_t namelen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_BIND);
|
|
|
|
ret = lwip_bind(s, name, namelen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_BIND);
|
|
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_connect_mt(int s, const struct sockaddr *name, socklen_t namelen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_CONNECT);
|
|
|
|
ret = lwip_connect(s, name, namelen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_CONNECT);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_listen_mt(int s, int backlog)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_LISTEN);
|
|
|
|
ret = lwip_listen(s, backlog);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_LISTEN);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_accept_mt(int s, struct sockaddr *addr, socklen_t *addrlen)
|
|
{
|
|
int i;
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_ACCEPT)
|
|
|
|
ret = lwip_accept(s, addr, addrlen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_ACCEPT);
|
|
|
|
if (ret < 0)
|
|
return -1;
|
|
|
|
for (i = 0; i < SOCK_MT_LOCK_MAX; i++) {
|
|
if (sys_mutex_new(&sockets_mt[ret].lock[i]) != ERR_OK)
|
|
break;
|
|
}
|
|
if (i < SOCK_MT_LOCK_MAX) {
|
|
for (i-- ; i >= 0; i--) {
|
|
sys_mutex_free(&sockets_mt[ret].lock[i]);
|
|
sockets_mt[ret].lock[i] = NULL;
|
|
}
|
|
|
|
lwip_close(ret);
|
|
ret = -1;
|
|
}
|
|
|
|
if (ret >= 0)
|
|
SOCK_MT_SET_SHUTDOWN(ret, SOCK_MT_SHUTDOWN_NONE);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_getpeername_mt(int s, struct sockaddr *name, socklen_t *namelen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
ret = lwip_getpeername(s, name, namelen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_getsockname_mt(int s, struct sockaddr *name, socklen_t *namelen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
ret = lwip_getsockname(s, name, namelen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_setsockopt_mt(int s, int level, int optname, const void *optval, socklen_t optlen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
ret = lwip_setsockopt(s, level, optname, optval, optlen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_getsockopt_mt(int s, int level, int optname, void *optval, socklen_t *optlen)
|
|
{
|
|
int ret;
|
|
|
|
if (optname == SO_ERROR ) {
|
|
int retval = 0;
|
|
|
|
if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE)
|
|
retval = ENOTCONN;
|
|
|
|
if (retval) {
|
|
*(int *)optval = retval;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
ret = lwip_getsockopt(s, level, optname, optval, optlen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_ioctl_mt(int s, long cmd, void *argp)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0)
|
|
|
|
ret = lwip_ioctl(s, cmd, argp);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_sendto_mt(int s, const void *data, size_t size, int flags,
|
|
const struct sockaddr *to, socklen_t tolen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND);
|
|
|
|
ret = lwip_sendto(s, data, size, flags, to, tolen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_send_mt(int s, const void *data, size_t size, int flags)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND);
|
|
|
|
ret = lwip_send(s, data, size, flags);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_recvfrom_mt(int s, void *mem, size_t len, int flags,
|
|
struct sockaddr *from, socklen_t *fromlen)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_RECV, 0);
|
|
|
|
ret = lwip_recvfrom(s, mem, len, flags, from, fromlen);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_RECV, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_recv_mt(int s, void *mem, size_t len, int flags)
|
|
{
|
|
return lwip_recvfrom_mt(s, mem, len, flags, NULL, NULL);
|
|
}
|
|
|
|
int lwip_read_mt(int s, void *mem, size_t len)
|
|
{
|
|
return lwip_recvfrom_mt(s, mem, len, 0, NULL, NULL);
|
|
}
|
|
|
|
int lwip_write_mt(int s, const void *data, size_t size)
|
|
{
|
|
return lwip_send_mt(s, data, size, 0);
|
|
}
|
|
|
|
int lwip_fcntl_mt(int s, int cmd, int val)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
ret = lwip_fcntl(s, cmd, val);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int __lwip_shutdown_mt(int s, int how)
|
|
{
|
|
int ret;
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_SHUTDOWN, 0);
|
|
|
|
lwip_sync_mt(s);
|
|
|
|
ret = lwip_shutdown(s, how);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_SHUTDOWN, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_shutdown_mt(int s, int how)
|
|
{
|
|
return lwip_shutdown(s, how);
|
|
}
|
|
|
|
int lwip_close_mt(int s)
|
|
{
|
|
int ret;
|
|
int i;
|
|
SYS_ARCH_DECL_PROTECT(lev);
|
|
sys_mutex_t lock_tmp[SOCK_MT_LOCK_MAX];
|
|
|
|
__lwip_shutdown_mt(s, SHUT_RDWR);
|
|
|
|
LWIP_ENTER_MT(s, SOCK_MT_CLOSE, 0);
|
|
|
|
ret = lwip_close(s);
|
|
|
|
LWIP_EXIT_MT(s, SOCK_MT_CLOSE, 0);
|
|
|
|
SYS_ARCH_PROTECT(lev);
|
|
for (i = 0 ; i < SOCK_MT_LOCK_MAX; i++) {
|
|
lock_tmp[i] = sockets_mt[s].lock[i];
|
|
sockets_mt[s].lock[i] = NULL;
|
|
}
|
|
SYS_ARCH_UNPROTECT(lev);
|
|
|
|
for (i = 0 ; i < SOCK_MT_LOCK_MAX; i++) {
|
|
sys_mutex_free(&lock_tmp[i]);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int lwip_select_mt(int maxfdp1, fd_set *readset, fd_set *writeset,
|
|
fd_set *exceptset, struct timeval *timeout)
|
|
{
|
|
int ret;
|
|
fd_set read_set, write_set;
|
|
int pset[2] = {(int)&read_set, (int)&write_set};
|
|
|
|
FD_ZERO(&read_set);
|
|
FD_ZERO(&write_set);
|
|
|
|
if (readset)
|
|
MEMCPY(&read_set, readset, sizeof(fd_set));
|
|
|
|
if (writeset)
|
|
MEMCPY(&write_set, writeset, sizeof(fd_set));
|
|
|
|
LWIP_ENTER_MT(maxfdp1, SOCK_MT_SELECT, (int)pset);
|
|
|
|
ret = lwip_select(maxfdp1, readset, writeset, exceptset, timeout);
|
|
|
|
LWIP_EXIT_MT(maxfdp1, SOCK_MT_SELECT, (int)pset);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef SOCKETS_TCP_TRACE
|
|
|
|
int lwip_trace_tcp(int s, int cmd, void *arg)
|
|
{
|
|
struct lwip_sock *sock;
|
|
u32_t *pbuf = (u32_t *)arg;
|
|
|
|
if (!(sock = tryget_socket(s)))
|
|
return -1;
|
|
|
|
ADD_TCP_SEND_BYTES_GET(sock->conn, &pbuf[0]);
|
|
ADD_TCP_SEND_BYTES_OK_GET(sock->conn, &pbuf[2]);
|
|
ADD_TCP_SEND_BYTES_NOMEM_GET(sock->conn, &pbuf[4]);
|
|
|
|
ADD_TCP_RECV_BYTES_GET(sock->conn, &pbuf[6]);
|
|
ADD_TCP_RECV_BYTES_ERR_GET(sock->conn, &pbuf[8]);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#endif
|