高通DSS模块问题

向上的小强

已于 2023-09-11 20:06:58 修改

阅读量151

点赞数

文章标签：算法

于 2023-09-11 20:03:50 首次发布

本文链接：https://blog.csdn.net/weixin_43647723/article/details/132816533

版权

以下为部分代码编写情况：
提供了三个主要的接口函数代码实现

//这里的s是我们内部管理的fd，无需关注

int msi_connect(int s, const ml_sockaddr_t *name, ml_socklen_t namelen)
{
    if(NULL == name || s - SOCKET_OFFSET < 0)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_connect name is null or s is invalid");
        return ML_SOCK_ERRNO;
    }
    int16_t sock_errno = ML_SOCK_ERRNO;

    sock_errno = socket_start_net(netHandle_fd[s - SOCKET_OFFSET].cid, (int16_t *)&netHandle_fd[s - SOCKET_OFFSET].netHandle);
    if(ML_SOCK_ERRNO == sock_errno)
    {
        socket_close_net(&netHandle_fd[s - SOCKET_OFFSET].netHandle);
    }

    int16_t sockfd = dss_socket(netHandle_fd[s - SOCKET_OFFSET].netHandle, (uint8_t)netHandle_fd[s - SOCKET_OFFSET].family,
                               (uint8_t)netHandle_fd[s - SOCKET_OFFSET].type, netHandle_fd[s - SOCKET_OFFSET].protocol/*0 1 6 17*/, &sock_errno);

    if(ML_SOCK_ERRNO == sockfd)
    {
         MSI_LOGE(0, 0, "MSI_LOGE::dss_socket sockfd is -1");
         return ML_SOCK_ERRNO;
    }
    set_socket(s, sockfd);

    int opt_value = 0;
    uint32 opt_len = 0;
    int16_t result = ML_SOCK_ERRNO;
    /* Set socket fd options */
    opt_value = TRUE;
    opt_len = sizeof(opt_value);
    result = dss_setsockopt(sockfd, DSS_SOCK, DSS_SO_REUSEADDR, (void *)&opt_value, &opt_len, &sock_errno);
    if (DSS_ERROR == result)
    {
        DS_AT_MSG1_ERROR("Client setsockopt SO_REUSEADDR error:%d", sock_errno);
        return DSS_ERROR;
    }

    /* Set the socket receive buffer to 45k bytes */
    opt_value = 45 * 1024;
    opt_len = sizeof(opt_value);
    result = dss_setsockopt(sockfd, DSS_SOCK, DSS_SO_RCVBUF, (void *)&opt_value, &opt_len, &sock_errno);
    if (DSS_ERROR == result)
    {
        DS_AT_MSG1_ERROR("Client setsockopt DSS_SO_RCVBUF error:%d", sock_errno);
        return DSS_ERROR;
    }
    else
    {
        dss_getsockopt(sockfd, DSS_SOCK, DSS_SO_RCVBUF, (void *)&opt_value, &opt_len, &sock_errno);
        DS_AT_MSG2_ERROR("Client %d set SO_RCVBUF to %d", sockfd, opt_value);
    }

    /* Set the socket send buffer to 32k bytes */
    opt_value = 32 * 1024;
    result = dss_setsockopt(sockfd, DSS_SOCK, DSS_SO_SNDBUF, (void *)&opt_value, &opt_len, &sock_errno);
    if (DSS_ERROR == result)
    {
        DS_AT_MSG1_ERROR("Client setsockopt DSS_SO_SNDBUF error:%d", sock_errno);
        return DSS_ERROR;
    }
    else
    {
        dss_getsockopt(sockfd, DSS_SOCK, DSS_SO_SNDBUF, (void *)&opt_value, &opt_len, &sock_errno);
        DS_AT_MSG2_HIGH("Client %d set SO_SNDBUF to %d", sockfd, opt_value);
    }
 #if 1
    int flag = 1;
    result = dss_setsockopt(sockfd, DSS_SOCK, DSS_SO_KEEPALIVE, (void *)&flag, &opt_len, &sock_errno);

    struct ps_sockaddr remoteaddr;
    memset(&remoteaddr, 0, sizeof(struct ps_sockaddr));
    remoteaddr.ps_sa_family = name->ml_sa_family;
    AdaptiveIpType( (uint8_t *)&(remoteaddr.ps_sa_family) );

    memcpy(remoteaddr.ps_sa_data, name->ml_sa_data, sizeof(name->ml_sa_data));
    uint16 remotelen = (uint16)namelen;
   
    int16_t retval = dss_connect(sockfd, (struct ps_sockaddr *)&remoteaddr, remotelen, &sock_errno);
    if(ML_SOCK_ERRNO == retval)
    {
        if(sock_errno == DS_EWOULDBLOCK)
        {
            retval = dss_async_select(sockfd, DS_WRITE_EVENT, &sock_errno);
            #if  MSI_CFW_TCP_DEF_H
            msi_cfw_event(s, (int)((0x11<<8) | s));
            #endif
            return ML_SOCK_SUCCESS;
        }
        else
        {
            #if  MSI_CFW_TCP_DEF_H
            msi_cfw_event(s,(int)((0x12<<8) | s));
            #endif
        }
        MSI_LOGE(0, 0, "MSI_LOGE::msi_connect dss_connect retval %d sock_errno: %d", retval, sock_errno);
        return ML_SOCK_ERRNO;
    }
    #endif
    return ML_SOCK_SUCCESS;
}

//这里的s是我们内部管理的fd，无需关注
int msi_sendto(int s, const void *dataptr, int size, int flags,
    const ml_sockaddr_t *to, ml_socklen_t tolen)
{
    if(NULL == dataptr || size <= 0)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto dataptr is null and size:%d", size);
        return ML_SOCK_ERRNO;
    }
    int16_t sockfd = get_socket(s);
    if(ML_SOCK_ERRNO == sockfd)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto sockfd is -1");
        return ML_SOCK_ERRNO;
    }

    int16_t sock_errno  = ML_SOCK_ERRNO;
    struct ps_sockaddr toaddr;
    memset(&toaddr, 0, sizeof(struct ps_sockaddr));
	//这里就是一个数据转换，IP类型跟数据的转换，无需关注
    if(to != NULL && tolen != 0)
    {
        toaddr.ps_sa_family = to->ml_sa_family;
        AdaptiveIpType( (uint8_t *)&(toaddr.ps_sa_family) );
        memcpy(toaddr.ps_sa_data, to->ml_sa_data, sizeof(to->ml_sa_data));
    }
	///
    MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto sockfd:%d, ps_sa_family:%d", sockfd, toaddr.ps_sa_family);
    int16_t retval = dss_sendto(sockfd, dataptr, size, flags, (struct ps_sockaddr *)&toaddr, sizeof(struct ps_sockaddr), &sock_errno);
    if( ML_SOCK_ERRNO == retval)
    {
        //MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto dss_sendto retval %d sock_errno: %d", retval, sock_errno);
        if( sock_errno == DS_EWOULDBLOCK )
        {
            /* Register for socket write event */
            dss_async_select( sockfd, DS_READ_EVENT | DS_WRITE_EVENT, &sock_errno) ;
            dss_sendto(sockfd, dataptr, size, flags, (struct ps_sockaddr *)&toaddr, sizeof(struct ps_sockaddr), &sock_errno);
            return ML_SOCK_SUCCESS;
        }
    }
    else
    {
        dss_async_select( sockfd, DS_READ_EVENT, &sock_errno ) ;
    }
    return retval;
}

//这里的s是我们内部管理的fd，无需关注

int msi_sendto(int s, const void *dataptr, int size, int flags,
    const ml_sockaddr_t *to, ml_socklen_t tolen)
{
    if(NULL == dataptr || size <= 0)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto dataptr is null and size:%d", size);
        return ML_SOCK_ERRNO;
    }
    int16_t sockfd = get_socket(s);
    if(ML_SOCK_ERRNO == sockfd)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto sockfd is -1");
        return ML_SOCK_ERRNO;
    }

    int16_t sock_errno  = ML_SOCK_ERRNO;
    struct ps_sockaddr toaddr;
    memset(&toaddr, 0, sizeof(struct ps_sockaddr));
	//这里就是一个数据转换，IP类型跟数据的转换，无需关注
    if(to != NULL && tolen != 0)
    {
        toaddr.ps_sa_family = to->ml_sa_family;
        AdaptiveIpType( (uint8_t *)&(toaddr.ps_sa_family) );
        memcpy(toaddr.ps_sa_data, to->ml_sa_data, sizeof(to->ml_sa_data));
    }
	///
    MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto sockfd:%d, ps_sa_family:%d", sockfd, toaddr.ps_sa_family);
    int16_t retval = dss_sendto(sockfd, dataptr, size, flags, (struct ps_sockaddr *)&toaddr, sizeof(struct ps_sockaddr), &sock_errno);
    if( ML_SOCK_ERRNO == retval)
    {
        //MSI_LOGE(0, 0, "MSI_LOGE::msi_sendto dss_sendto retval %d sock_errno: %d", retval, sock_errno);
        if( sock_errno == DS_EWOULDBLOCK )
        {
            /* Register for socket write event */
            dss_async_select( sockfd, DS_READ_EVENT | DS_WRITE_EVENT, &sock_errno) ;
            dss_sendto(sockfd, dataptr, size, flags, (struct ps_sockaddr *)&toaddr, sizeof(struct ps_sockaddr), &sock_errno);
            return ML_SOCK_SUCCESS;
        }
    }
    else
    {
        dss_async_select( sockfd, DS_READ_EVENT, &sock_errno ) ;
    }
    return retval;
}

//这里的s是我们内部管理的fd，无需关注

//这里的s是我们内部管理的fd，无需关注
int msi_write(int s, const void *dataptr, int size)
{
    if(NULL == dataptr || size <= 0)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_write dataptr is null and size:%d", size);
        return ML_SOCK_ERRNO;
    }
    MSI_LOGE(0, 0, "MSI_LOGE::msi_write s:%d", s);
    int16_t sockfd = get_socket(s);
    if(ML_SOCK_ERRNO == sockfd)
    {
        MSI_LOGE(0, 0, "MSI_LOGE::msi_write sockfd is -1");
        return ML_SOCK_ERRNO;
    }
    int sock_opt_len = sizeof(int);
    int sock_opt_val = 0;
    int send_data_len = 0;
    int16_t sock_errno  = ML_SOCK_ERRNO;
	while(size > 0)
    {
        send_data_len = dss_write(sockfd, dataptr, size, &sock_errno);
        MSI_LOGE(0, 0, "MSI_LOGE::msi_write sockfd:%d, send_data_len:%d, size:%d, sock_errno:%d",sockfd, send_data_len, size, sock_errno);
        if (send_data_len < 0)
        {
            if( sock_errno == DS_EWOULDBLOCK )
            {
                /* Register for socket write event */
                int result = dss_async_select( sockfd, DS_READ_EVENT | DS_WRITE_EVENT, &sock_errno);
                if (result < 0)
                {
                    return ML_SOCK_ERRNO;
                }
                else
                {
					dss_write(sockfd, dataptr, size, &sock_errno);
                    return ML_SOCK_SUCCESS;
                }

            }
            send_data_len = 0;
        }
        else if (0 == send_data_len)
        {
            continue;
        }
        size -= send_data_len;
    }
    return ML_SOCK_SUCCESS;
}