diff options
Diffstat (limited to 'stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c')
| -rw-r--r-- | stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c | 766 |
1 files changed, 766 insertions, 0 deletions
diff --git a/stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c b/stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c new file mode 100644 index 0000000..38cf620 --- /dev/null +++ b/stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c @@ -0,0 +1,766 @@ +/* +* +* Copyright (c) 2018 Huawei Technologies Co.,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 "stackx_msg_handler.h" +#include "stackx_spl_share.h" +#include "stackx_spl_msg.h" +#include "nsfw_msg_api.h" +#include "common_pal_bitwide_adjust.h" +#include "stackx_res_mgr.h" +#include "stackx_prot_com.h" +#include "nstack_securec.h" +//#include "stackx_dfx_api.h" + +#define SBR_MSG_MALLOC(sk) msg_malloc(ss_get_msg_pool(sbr_get_conn(sk))) +#define SBR_MSG_FREE(msg) msg_free(msg) + +#define SBR_MSG_POST(msg, ring) \ + do { \ + if (MSG_ASYN_POST == msg->param.op_type)\ + {\ + if (msg_post(msg, ring) < 0)\ + {\ + SBR_MSG_FREE(msg); \ + NSSBR_LOGERR("msg_post failed]major=%u,minor=%u,type=%u", \ + msg->param.major_type, msg->param.minor_type, msg->param.op_type); \ + }\ + } \ + else \ + {\ + if (msg_post(msg, ring) < 0)\ + {\ + msg->param.err = ECONNABORTED; \ + NSSBR_LOGERR("msg_post_with_ref failed]major=%u,minor=%u,type=%u", \ + msg->param.major_type, msg->param.minor_type, msg->param.op_type); \ + }\ + } \ + } while (0) + +#define SBR_MSG_POST_RET(msg, ring, ret) \ + do { \ + if (MSG_ASYN_POST == msg->param.op_type)\ + {\ + if ((ret = msg_post(msg, ring)) < 0)\ + {\ + SBR_MSG_FREE(msg); \ + NSSBR_LOGERR("msg_post failed]major=%u,minor=%u,type=%u", \ + msg->param.major_type, msg->param.minor_type, msg->param.op_type); \ + }\ + } \ + else \ + {\ + if ((ret = msg_post(msg, ring)) < 0)\ + {\ + msg->param.err = ECONNABORTED; \ + NSSBR_LOGERR("msg_post_with_ref failed]major=%u,minor=%u,type=%u", \ + msg->param.major_type, msg->param.minor_type, msg->param.op_type); \ + }\ + } \ + } while (0) + +NSTACK_STATIC inline void +_sbr_construct_msg(data_com_msg * m, u16 major_type, u16 minor_type, + u16 type, sbr_socket_t * sk) +{ + m->param.module_type = MSG_MODULE_SBR; + m->param.major_type = major_type; + m->param.minor_type = minor_type; + m->param.err = 0; + m->param.op_type = type; + sys_sem_init(&m->param.op_completed); + m->param.receiver = ss_get_recv_obj(sbr_get_conn(sk)); + m->param.comm_receiver = ss_get_comm_private_data(sbr_get_conn(sk)); + m->param.extend_member_bit = 0; +} + +#define sbr_construct_msg(m, major_type, minor_type, type, sk) { \ + _sbr_construct_msg(m, major_type, minor_type, type, sk); \ + NSSBR_LOGINF("fd=%d,conn=%p,private_data=%p", sk->fd, sbr_get_conn(sk), ss_get_private_data(sbr_get_conn(sk))); \ + } + +#define sbr_construct_msg_dbg(m, major_type, minor_type, type, sk) { \ + _sbr_construct_msg(m, major_type, minor_type, type, sk); \ + NSSBR_LOGDBG("fd=%d,conn=%p,private_data=%p", sk->fd, sbr_get_conn(sk), ss_get_private_data(sbr_get_conn(sk))); \ + } + +/***************************************************************************** +* Prototype : sbr_attach_msg +* Description : use buf's msg first +* Input : sbr_socket_t * sk +* struct pbuf* buf +* Output : None +* Return Value : static inline data_com_msg* +* Calls : +* Called By : +* +*****************************************************************************/ +static inline data_com_msg *sbr_attach_msg(sbr_socket_t * sk, + struct spl_pbuf *buf) +{ + data_com_msg *m = NULL; + if (!sk) + { + return m; + } + + if (buf && buf->msg) + { + m = (data_com_msg *) ADDR_SHTOL(buf->msg); + } + else + { + m = SBR_MSG_MALLOC(sk); + } + + return m; +} + +/***************************************************************************** +* Prototype : sbr_handle_socket +* Description : create socket +* Input : sbr_socket_t * sk +* netconn_type_t type +* u8 proto +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int sbr_handle_socket(sbr_socket_t * sk, spl_netconn_type_t type, u8 proto) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_NEWCONN, + MSG_SYN_POST, sk); + msg_new_netconn *p = (msg_new_netconn *) m->buffer; + p->conn = (spl_netconn_t *) ADDR_LTOSH(sbr_get_conn(sk)); + p->type = type; + p->proto = proto; + p->socket = sk->fd; + p->extend_member_bit = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + int err = sbr_spl_err_to_errno(m->param.err); + SBR_MSG_FREE(m); + if (err != 0) + { + NSSBR_LOGERR("handle socket failed]fd=%d,type=%d,proto=%u,err=%d", + sk->fd, type, proto, err); + sbr_set_sk_errno(sk, err); + return -1; + } + + return 0; +} + +/***************************************************************************** +* Prototype : sbr_handle_bind +* Description : bind +* Input : sbr_socket_t * sk +* spl_ip_addr_t * addr +* u16 port +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int sbr_handle_bind(sbr_socket_t * sk, spl_ip_addr_t * addr, u16 port) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_BIND, MSG_SYN_POST, + sk); + msg_bind *p = (msg_bind *) m->buffer; + p->ipaddr = *addr; + p->port = port; + p->extend_member_bit = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + int err = sbr_spl_err_to_errno(m->param.err); + SBR_MSG_FREE(m); + if (err != 0) + { + NSSBR_LOGERR("handle bind failed]fd=%d,err=%d", sk->fd, err); + sbr_set_sk_errno(sk, err); + return -1; + } + + return 0; +} + +int sbr_handle_listen(sbr_socket_t * sk, int backlog) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_LISTEN, + MSG_SYN_POST, sk); + msg_listen *p = (msg_listen *) m->buffer; + p->conn_pool = sbr_get_conn_pool(); + p->backlog = backlog; + p->extend_member_bit = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + int err = sbr_spl_err_to_errno(m->param.err); + SBR_MSG_FREE(m); + if (err != 0) + { + NSSBR_LOGERR("handle listen failed]fd=%d,err=%d", sk->fd, err); + sbr_set_sk_errno(sk, err); + return -1; + } + + return 0; +} + +/***************************************************************************** +* Prototype : sbr_handle_connect +* Description : connect +* Input : sbr_socket_t * sk +* spl_ip_addr_t * addr +* u16 port +* spl_ip_addr_t* local_ip +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int +sbr_handle_connect(sbr_socket_t * sk, spl_ip_addr_t * addr, u16 port, + spl_ip_addr_t * local_ip) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_CONNECT, + MSG_SYN_POST, sk); + msg_connect *p = (msg_connect *) m->buffer; + p->local_ip = *local_ip; + p->ipaddr = *addr; + p->port = port; + p->extend_member_bit = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + int err = sbr_spl_err_to_errno(m->param.err); + SBR_MSG_FREE(m); + if (err != 0) + { + NSSBR_LOGERR("handle connect failed]fd=%d,err=%d", sk->fd, err); + sbr_set_sk_errno(sk, err); + return -1; + } + + return 0; +} + +/***************************************************************************** +* Prototype : sbr_handle_get_name +* Description : get name +* Input : sbr_socket_t * sk +* struct sockaddr * name +* socklen_t * namelen +* u8 cmd +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int +sbr_handle_get_name(sbr_socket_t * sk, struct sockaddr *name, + socklen_t * namelen, u8 cmd) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_GETSOCK_NAME, + MSG_SYN_POST, sk); + msg_getaddrname *p = (msg_getaddrname *) m->buffer; + p->cmd = cmd; + p->extend_member_bit = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + int err = sbr_spl_err_to_errno(m->param.err); + if (err != 0) + { + NSSBR_LOGERR("handle get name failed]fd=%d,err=%d", sk->fd, err); + goto error; + } + else + { + if (*namelen > sizeof(p->sock_addr)) + { + *namelen = sizeof(p->sock_addr); + } + + int ret = memcpy_s(name, *namelen, &p->sock_addr, *namelen); + if (0 != ret) + { + NSSBR_LOGERR("MEMCPY_S failed]fd=%d,ret=%d", sk->fd, ret); + err = EINVAL; + goto error; + } + + *namelen = sizeof(p->sock_addr); + } + + SBR_MSG_FREE(m); + return 0; + + error: + sbr_set_sk_errno(sk, err); + SBR_MSG_FREE(m); + return -1; +} + +/***************************************************************************** +* Prototype : sbr_handle_setsockopt +* Description : msg box will changed in IP_TOS +* Input : sbr_socket_t * sk +* int level +* int optname +* const void *optval +* socklen_t optlen +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int +sbr_handle_setsockopt(sbr_socket_t * sk, int level, int optname, + const void *optval, socklen_t optlen) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_SET_SOCK_OPT, + MSG_SYN_POST, sk); + msg_setgetsockopt *p = (msg_setgetsockopt *) m->buffer; + p->extend_member_bit = 0; + p->level = level; + p->optname = optname; + p->msg_box = NULL; /* init the value to avoid unexpected consequences */ + + if (optlen > sizeof(p->optval)) + { + optlen = sizeof(p->optval); + } + + p->optlen = optlen; + int err; + int ret = memcpy_s(&p->optval, sizeof(p->optval), optval, optlen); + if (0 != ret) + { + NSSBR_LOGERR("MEMCPY_S failed]fd=%d,ret=%d", sk->fd, ret); + err = EINVAL; + goto error; + } + + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + err = sbr_spl_err_to_errno(m->param.err); + if (err != 0) + { + NSSBR_LOGERR("handle setsockopt failed]fd=%d,err=%d", sk->fd, err); + goto error; + } + + if (IPPROTO_IP == level && IP_TOS == optname && p->msg_box) + { + ss_set_msg_box(sbr_get_conn(sk), + (mring_handle) ADDR_SHTOL(p->msg_box)); + } + + SBR_MSG_FREE(m); + return 0; + + error: + sbr_set_sk_errno(sk, err); + SBR_MSG_FREE(m); + return -1; +} + +/***************************************************************************** +* Prototype : sbr_handle_getsockopt +* Description : get sockopt +* Input : sbr_socket_t * sk +* int level +* int optname +* void *optval +* socklen_t* optlen +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int +sbr_handle_getsockopt(sbr_socket_t * sk, int level, int optname, + void *optval, socklen_t * optlen) +{ + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_GET_SOCK_OPT, + MSG_SYN_POST, sk); + msg_setgetsockopt *p = (msg_setgetsockopt *) m->buffer; + p->extend_member_bit = 0; + p->level = level; + p->optname = optname; + + if (*optlen > sizeof(p->optval)) + { + *optlen = sizeof(p->optval); + } + + p->optlen = *optlen; + int err; + int ret = memcpy_s(&p->optval, sizeof(p->optval), optval, *optlen); + if (0 != ret) + { + NSSBR_LOGERR("MEMCPY_S failed]fd=%d,ret=%d", sk->fd, ret); + err = EINVAL; + goto error; + } + + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + + err = sbr_spl_err_to_errno(m->param.err); + if (err != 0) + { + NSSBR_LOGERR("handle getsockopt failed]fd=%d,err=%d", sk->fd, err); + goto error; + } + + ret = memcpy_s(optval, *optlen, &p->optval.int_optval, *optlen); + if (0 != ret) + { + NSSBR_LOGERR("MEMCPY_S failed]fd=%d,ret=%d", sk->fd, ret); + err = EINVAL; + goto error; + } + + SBR_MSG_FREE(m); + return 0; + + error: + sbr_set_sk_errno(sk, err); + SBR_MSG_FREE(m); + return -1; +} + +/***************************************************************************** +* Prototype : sbr_handle_close +* Description : need care msg_box_ref,make sure to finalize this message +* Input : sbr_socket_t * sk +* u8 how +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int sbr_handle_close(sbr_socket_t * sk, u8 how) +{ + data_com_msg *m = sbr_attach_msg(sk, + (struct spl_pbuf *) + ADDR_SHTOL(sbr_get_fd_share + (sk)->recoder.head)); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_DELCON, + MSG_ASYN_POST, sk); + msg_delete_netconn *p = (msg_delete_netconn *) m->buffer; + p->extend_member_bit = 0; + p->buf = NULL; + p->time_started = sys_now(); + p->shut = how; + p->pid = get_sys_pid(); + p->conn = (spl_netconn_t *) ADDR_LTOSH(sbr_get_conn(sk)); + p->notify_omc = FALSE; + p->msg_box_ref = SPL_MSG_BOX_NUM; + + /* to ensure that the last deal with SPL_API_DO_DELCON message */ + int i; + for (i = 0; i < SPL_MSG_BOX_NUM; ++i) + { + SBR_MSG_POST(m, + ss_get_instance_msg_box(ss_get_bind_thread_index + (sbr_get_conn(sk)), i)); + } + + return 0; +} + +/***************************************************************************** +* Prototype : sbr_handle_udp_send +* Description : udp send +* Input : sbr_socket_t * sk +* struct netbuf *buf +* spl_ip_addr_t* local_ip +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int +sbr_handle_udp_send(sbr_socket_t * sk, struct spl_netbuf *buf, + spl_ip_addr_t * local_ip) +{ + data_com_msg *m = + sbr_attach_msg(sk, (struct spl_pbuf *) ADDR_SHTOL(buf->p)); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + sbr_set_sk_io_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg_dbg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_SEND, + MSG_ASYN_POST, sk); + msg_send_buf *p = (msg_send_buf *) m->buffer; + p->local_ip.addr = local_ip->addr; + int ret = memcpy_s(&p->addr, sizeof(spl_ip_addr_t), &buf->addr, + sizeof(spl_ip_addr_t)); + if (ret != 0) + { + NSSBR_LOGERR("MEMCPY_S failed]fd=%d,ret=%d", sk->fd, ret); + sbr_set_sk_io_errno(sk, EINVAL); + SBR_MSG_FREE(m); + return -1; + } + + p->p = buf->p; + p->port = buf->port; + p->extend_member_bit = 0; + SBR_MSG_POST_RET(m, sbr_get_msg_box(sk), ret); + + if (0 == ret) + { + return 0; + } + else + { + NSSBR_LOGERR("post msg failed]fd=%d", sk->fd); + sbr_set_sk_io_errno(sk, EAGAIN); + return -1; + } +} + +/***************************************************************************** +* Prototype : sbr_handle_free_recv_buf +* Description : free recv buf,can't free buf in app +* Input : sbr_socket_t * sk +* Output : None +* Return Value : void +* Calls : +* Called By : +* +*****************************************************************************/ +void sbr_handle_free_recv_buf(sbr_socket_t * sk) +{ + data_com_msg *m = sbr_attach_msg(sk, + (struct spl_pbuf *) + ADDR_SHTOL(sbr_get_fd_share + (sk)->recoder.head)); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + return; + } + + sbr_construct_msg_dbg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_PBUF_FREE, + MSG_ASYN_POST, sk); + msg_free_buf *p = (msg_free_buf *) m->buffer; + p->extend_member_bit = 0; + p->buf = sbr_get_fd_share(sk)->recoder.head; + sbr_get_fd_share(sk)->recoder.head = NULL; + sbr_get_fd_share(sk)->recoder.tail = NULL; + sbr_get_fd_share(sk)->recoder.totalLen = 0; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); +} + +void sbr_handle_free_send_buf(sbr_socket_t * sk, struct spl_pbuf *buf) +{ + if (buf != NULL) + { + data_com_msg *m = sbr_attach_msg(sk, buf); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + return; + } + + sbr_construct_msg_dbg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_PBUF_FREE, + MSG_ASYN_POST, sk); + msg_free_buf *p = (msg_free_buf *) m->buffer; + p->extend_member_bit = 0; + p->buf = (struct spl_pbuf *) ADDR_LTOSH(buf); + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + } +} + +/***************************************************************************** +* Prototype : sbr_handle_shutdown +* Description : shut down +* Input : sbr_socket_t * sk +* u8 how +* Output : None +* Return Value : int +* Calls : +* Called By : +* +*****************************************************************************/ +int sbr_handle_shutdown(sbr_socket_t * sk, u8 how) +{ + int err; + data_com_msg *m = SBR_MSG_MALLOC(sk); + + if (!m) + { + NSSBR_LOGERR("malloc msg failed]fd=%d", sk->fd); + sbr_set_sk_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_CLOSE, + MSG_SYN_POST, sk); + msg_close *p = (msg_close *) m->buffer; + p->extend_member_bit = 0; + p->time_started = sys_now(); + p->shut = how; + SBR_MSG_POST(m, sbr_get_msg_box(sk)); + err = sbr_spl_err_to_errno(m->param.err); + SBR_MSG_FREE(m); + if (err != 0) + { + NSSBR_LOGERR("handle getsockopt failed]fd=%d,err=%d", sk->fd, err); + sbr_set_sk_errno(sk, err); + return -1; + } + + return 0; +} + +void sbr_handle_tcp_recv(sbr_socket_t * sk, u32 len, struct spl_pbuf *buf) +{ + data_com_msg *m = sbr_attach_msg(sk, buf); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + return; + } + + sbr_construct_msg_dbg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_RECV, + MSG_ASYN_POST, sk); + msg_recv_buf *p = (msg_recv_buf *) m->buffer; + p->extend_member_bit = 0; + p->len = len; + p->p = (struct spl_pbuf *) ADDR_LTOSH(buf); + SBR_MSG_POST(m, sbr_get_msg_box(sk)); +} + +int +sbr_handle_tcp_send(sbr_socket_t * sk, size_t size, struct spl_pbuf *buf, + u8 api_flag) +{ + int ret; + data_com_msg *m = sbr_attach_msg(sk, buf); + + if (!m) + { + NSSBR_LOGERR("attach msg failed]fd=%d", sk->fd); + sbr_set_sk_io_errno(sk, ENOMEM); + return -1; + } + + sbr_construct_msg_dbg(m, SPL_TCPIP_NEW_MSG_API, SPL_API_DO_WRITE, + MSG_ASYN_POST, sk); + msg_write_buf *p = (msg_write_buf *) m->buffer; + p->extend_member_bit = 0; + p->len = size; + p->p = (struct spl_pbuf *) ADDR_LTOSH(buf); + p->apiflags = api_flag; + SBR_MSG_POST_RET(m, sbr_get_msg_box(sk), ret); + + if (0 == ret) + { + return 0; + } + else + { + NSSBR_LOGERR("post msg failed]fd=%d", sk->fd); + sbr_set_sk_io_errno(sk, EAGAIN); + return -1; + } +} + +/* need delete sbr_handle_app_touch */ +void sbr_handle_app_touch(void) +{ +} |