path: root/stacks/lwip_stack/lwip_src/socket/stackx_msg_handler.c

/*
*
* 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)
{
}