OpenHarmony网络编程及多播相关总结

企业开发 2024-01-08 20:30:25 阅读次数: 0

1.多播

多播的概念与组播地址范围及协议描述参考：

https://support.huawei.com/enterprise/zh/doc/EDOC1000017255/17fa1d44

2.组播

2.1 发送方
int32_t ret  = IndustrialSocketCreate(AF_INET, SOCK_DGRAM, 0, &softbus->publishFd_);
if (ret != 0) {
    IBHILOGE("IndustrialSocketCreate send cast udp failed");
    return ;
}
while (softbus->GetPublishState()) {
    struct ip_mreq mreq;
    // 设置多播地址
    mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP);
    // 设置使用该多播地址发送数据时使用的网卡ip
    mreq.imr_interface.s_addr = inet_addr(softbus->localIp_.c_str());
    // 调用setsockopt
    ret = setsockopt(softbus->publishFd_, IPPROTO_IP, IP_MULTICAST_IF, &mreq,sizeof(mreq));
    if ( ret < 0) {
        IBHILOGE("Fail to join udp group, err: %{public}s", strerror(errno));
        usleep(PUBLISH_INTERVAL);
    } else {
        break;
    }
}
while (softbus->GetPublishState()) {
    // 禁止组播回送（防止收到自己发送的组播包）
    int op = 0;
    ret = setsockopt(softbus->publishFd_, IPPROTO_IP, IP_MULTICAST_LOOP, &op, sizeof(op));
    if (ret < 0) {
        IBHILOGE("Fail to disable multicast loop, err: %{public}s", strerror(errno));
        usleep(PUBLISH_INTERVAL);
    } else {
        break;
    }
}
// 指定发送的组播地址和端口
struct sockaddr_in mcast_addr;
memset(&mcast_addr, 0, sizeof(mcast_addr));
mcast_addr.sin_family = AF_INET;
mcast_addr.sin_addr.s_addr = inet_addr(MULTICAST_IP);
mcast_addr.sin_port = htons(MULTICAST_PORT);
softbus->publishThread.SetThreadState(true);
int32_t stopPublishNum = 0;
while (softbus->publishThread.GetThreadState()) {
    if (softbus->GetPublishState() && softbus->publishCount_ < MAX_PUBLISH_TIME) {
        std::string sendMulicastData(MULTICAST_DATA);
        sendMulicastData = sendMulicastData + softbus->localMac_;
        sendMulicastData.append(buffer);
        IBHILOGI("publishFd_ :%{public}d multicast data:%{public}s begin",
                 softbus->publishFd_,sendMulicastData.c_str());
        ret = sendto(softbus->publishFd_, sendMulicastData.c_str(),
                     sendMulicastData.length(), 0, (const struct sockaddr *)&mcast_addr, sizeof(mcast_addr));
        if (ret < 0) {
            IBHILOGE("sendto publish msg:%{public}d fail,sendLength:%{public}d", softbus->publishFd_, ret);
        } else {
            // IBHILOGI("sendto publish msg:%{public}d succ,sendLength:%{public}d", softbus->publishFd_, ret);
        }
        softbus->publishCount_++;
        usleep(PUBLISH_INTERVAL);
    } else {
        stopPublishNum++;
        usleep(PUBLISH_INTERVAL);
        if (stopPublishNum >= STOP_PUBLISH_TIME) {
            softbus->publishCount_ = 0;
            stopPublishNum = 0;
        }
    }
}
DestroyBusSocket(&softbus->publishFd_);
2.2 接收方
int32_t ret  = IndustrialSocketCreate(AF_INET, SOCK_DGRAM, 0, &softbus->discoveryFd_);
if (ret != 0) 
    IBHILOGE("IndustrialSocketCreate recv cast udp failed");
    return ;
}
while (softbus->GetDiscoveryState()) {
    int reuse_addr_opt = 1;
    int error = setsockopt(softbus->discoveryFd_, SOL_SOCKET, SO_REUSEADDR, &reuse_addr_opt, sizeof(int));
    if (error < 0) {
        IBHILOGE("setsockopt fail error:%{public}d,errno:%{public}d", error, errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
while (softbus->GetDiscoveryState()) {
    // 设置超时
    struct timeval timeout;
    timeout.tv_sec = 0;//秒
    timeout.tv_usec = USER_TIMEOUT_MS;//微秒
    if (setsockopt(softbus->discoveryFd_, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
        IBHILOGE("setsockopt SO_RCVTIMEO failed errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
struct sockaddr_in server_socket;
while (softbus->GetDiscoveryState()) {
    bzero(&server_socket, sizeof(server_socket));
    server_socket.sin_family = AF_INET;
    server_socket.sin_addr.s_addr = htonl(INADDR_ANY);
    server_socket.sin_port = htons(MULTICAST_PORT);

    // 调用bind绑定socket地址
    if (bind(softbus->discoveryFd_, (struct sockaddr*)&server_socket, sizeof(struct sockaddr)) == -1) {
        IBHILOGE("bind error errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
struct ip_mreq mreq;
while (softbus->GetDiscoveryState()) {
    // 加入组播，接收组播信息
    mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_IP);
    mreq.imr_interface.s_addr = inet_addr(softbus->localIp_.c_str());
    int error = setsockopt(softbus->discoveryFd_, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
    if (error < 0) {
        IBHILOGE("setsockopt fail error:%{public}d,errno:%{public}d", error, errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
char recvBuff[100] = {0};
softbus->discoveryThread.SetThreadState(true);
while (softbus->discoveryThread.GetThreadState()) {
    if (softbus->GetDiscoveryState()) {
        struct sockaddr_in recvAddr;
        memset(recvBuff, 0, sizeof(recvBuff));
        memset(&recvAddr, 0, sizeof(struct sockaddr));
        int sinSize = sizeof(struct sockaddr_in);
        int ret = recvfrom(softbus->discoveryFd_, recvBuff, sizeof(recvBuff) - 1, 0,
                           (struct sockaddr*)&recvAddr, (socklen_t *)&sinSize);
        if (ret > 0 ) {
            IBHILOGI("recvfrom client IP:%{public}s cast:%{public}s ret:%{public}d",
                     inet_ntoa(recvAddr.sin_addr), recvBuff, ret);
            std::string recvMulticastData = recvBuff;
            if (recvMulticastData.length() != (MULTICAST_LEN + MAC_ADDR_LEN + TIME_STAMP_LEN)) {
                usleep(DISCOVERY_INTERVAL);
                continue;
            } else {
                std::string auth = recvMulticastData.substr(0, MULTICAST_LEN);
                std::string peerMac = recvMulticastData.substr(MULTICAST_LEN, MAC_ADDR_LEN);
                if (auth.compare(MULTICAST_DATA) == 0 && softbus->localMac_.compare(peerMac) != 0) { // 校验组播数据
                    std::string peerStamp = 
                        recvMulticastData.substr(MULTICAST_LEN + MAC_ADDR_LEN, TIME_STAMP_LEN);
                    std::string peerAddr = inet_ntoa(recvAddr.sin_addr);
                    int32_t iFound = softbus->DiscoveryUpdateDeviceInfo(peerMac, peerAddr, peerStamp);
                    if (iFound >=0) {
                        softbus->NotifyDeviceFound(peerMac, peerAddr, peerStamp);
                        if (iFound > 0) {
                            softbus->UpdatePeerJoinInfo(peerAddr);
                        }
                    }
                }
                usleep(DISCOVERY_INTERVAL);
            }
        } else {
            IBHILOGI("recvfrom error:%{public}d ret:%{public}d, retry recvfrom cast", errno, ret);
            usleep(DISCOVERY_INTERVAL);
            continue;
        }
    } else {
        IBHILOGI("UnDiscoverySoftbus................");
        usleep(DISCOVERY_INTERVAL);
    }
}
DestroyBusSocket(&softbus->discoveryFd_);

3.广播

广播方式可以通过本地地址与掩码方式计算出广播地址，本例中采用255.255.255.255地址，不需要路由器直接全网发送

3.1 发送方
int32_t ret  = IndustrialSocketCreate(AF_INET, SOCK_DGRAM, 0, &softbus->publishFd_);
if (ret != 0) {
    IBHILOGE("IndustrialSocketCreate send cast udp failed");
    return ;
}
while (softbus->GetPublishState()) {
    // 允许发送广播
    int on_off = 1;
    ret = setsockopt(softbus->publishFd_, SOL_SOCKET, SO_BROADCAST, &on_off, sizeof(on_off));
    if ( ret < 0) {
        IBHILOGE("Fail to send broadcast, err: %{public}s", strerror(errno));
        usleep(PUBLISH_INTERVAL);
    } else {
        break;
    }
}
// 指定发送的广播地址和端口
struct sockaddr_in mcast_addr;
memset(&mcast_addr, 0, sizeof(mcast_addr));
mcast_addr.sin_family = AF_INET;
mcast_addr.sin_addr.s_addr = inet_addr("255.255.255.255"); // 不经由路由器全网发送
mcast_addr.sin_port = htons(MULTICAST_PORT);
softbus->publishThread.SetThreadState(true);
int32_t stopPublishNum = 0;
while (softbus->publishThread.GetThreadState()) {
    if (softbus->GetPublishState() && softbus->publishCount_ < MAX_PUBLISH_TIME) {
        std::string sendMulicastData(MULTICAST_DATA);
        sendMulicastData = sendMulicastData + softbus->localMac_;
        sendMulicastData.append(buffer);
        IBHILOGI("publishFd_ :%{public}d multicast data:%{public}s begin",
                 softbus->publishFd_,sendMulicastData.c_str());
        ret = sendto(softbus->publishFd_, sendMulicastData.c_str(),
                     sendMulicastData.length(), 0, (const struct sockaddr *)&mcast_addr, sizeof(mcast_addr));
        if (ret < 0) {
            IBHILOGE("sendto publish msg:%{public}d fail,sendLength:%{public}d", softbus->publishFd_, ret);
        } else {
            // IBHILOGI("sendto publish msg:%{public}d succ,sendLength:%{public}d", softbus->publishFd_, ret);
        }
        softbus->publishCount_++;
        usleep(PUBLISH_INTERVAL);
    } else {
        stopPublishNum++;
        usleep(PUBLISH_INTERVAL);
        if (stopPublishNum >= STOP_PUBLISH_TIME) {
            softbus->publishCount_ = 0;
            stopPublishNum = 0;
        }
    }
}
DestroyBusSocket(&softbus->publishFd_);
3.2 接收方
int32_t ret  = IndustrialSocketCreate(AF_INET, SOCK_DGRAM, 0, &softbus->discoveryFd_);
if (ret != 0) {
    IBHILOGE("IndustrialSocketCreate recv cast udp failed");
    return ;
}
while (softbus->GetDiscoveryState()) {
    int reuse_addr_opt = 1;
    int error = setsockopt(softbus->discoveryFd_, SOL_SOCKET, SO_REUSEADDR, &reuse_addr_opt, sizeof(int));
    if (error < 0) {
        IBHILOGE("setsockopt fail error:%{public}d,errno:%{public}d", error, errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
while (softbus->GetDiscoveryState()) {
    // 设置超时
    struct timeval timeout;
    timeout.tv_sec = 0;//秒
    timeout.tv_usec = USER_TIMEOUT_MS;//微秒
    if (setsockopt(softbus->discoveryFd_, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
        IBHILOGE("setsockopt SO_RCVTIMEO failed errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
struct sockaddr_in server_socket;
while (softbus->GetDiscoveryState()) {
    bzero(&server_socket, sizeof(server_socket));
    server_socket.sin_family = AF_INET;
    server_socket.sin_addr.s_addr = htonl(INADDR_ANY);
    server_socket.sin_port = htons(MULTICAST_PORT);

    // 调用bind绑定socket地址
    if (bind(softbus->discoveryFd_, (struct sockaddr*)&server_socket, sizeof(struct sockaddr)) == -1) {
        IBHILOGE("bind error errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
char recvBuff[100] = {0};
softbus->discoveryThread.SetThreadState(true);
while (softbus->discoveryThread.GetThreadState()) {
    if (softbus->GetDiscoveryState()) {
        struct sockaddr_in recvAddr;
        memset(recvBuff, 0, sizeof(recvBuff));
        memset(&recvAddr, 0, sizeof(struct sockaddr));
        int sinSize = sizeof(struct sockaddr_in);
        int ret = recvfrom(softbus->discoveryFd_, recvBuff, sizeof(recvBuff) - 1, 0,
                           (struct sockaddr*)&recvAddr, (socklen_t *)&sinSize);
        if (ret > 0 ) {
            IBHILOGI("recvfrom client IP:%{public}s cast:%{public}s ret:%{public}d",
                     inet_ntoa(recvAddr.sin_addr), recvBuff, ret);
            std::string recvMulticastData = recvBuff;
            if (recvMulticastData.length() != (MULTICAST_LEN + MAC_ADDR_LEN + TIME_STAMP_LEN)) {
                usleep(DISCOVERY_INTERVAL);
                continue;
            } else {
                std::string auth = recvMulticastData.substr(0, MULTICAST_LEN);
                std::string peerMac = recvMulticastData.substr(MULTICAST_LEN, MAC_ADDR_LEN);
                if (auth.compare(MULTICAST_DATA) == 0 && softbus->localMac_.compare(peerMac) != 0) { // 校验组播数据
                    std::string peerStamp = 
                        recvMulticastData.substr(MULTICAST_LEN + MAC_ADDR_LEN, TIME_STAMP_LEN);
                    std::string peerAddr = inet_ntoa(recvAddr.sin_addr);
                    int32_t iFound = softbus->DiscoveryUpdateDeviceInfo(peerMac, peerAddr, peerStamp);
                    if (iFound >=0) {
                        softbus->NotifyDeviceFound(peerMac, peerAddr, peerStamp);
                        if (iFound > 0) {
                            softbus->UpdatePeerJoinInfo(peerAddr);
                        }
                    }
                }
                usleep(DISCOVERY_INTERVAL);
            }
        } else {
            IBHILOGI("recvfrom error:%{public}d ret:%{public}d, retry recvfrom cast", errno, ret);
            usleep(DISCOVERY_INTERVAL);
            continue;
        }
    } else {
        IBHILOGI("UnDiscoverySoftbus................");
        usleep(DISCOVERY_INTERVAL);
    }
}
DestroyBusSocket(&softbus->discoveryFd_);

4.关于非阻塞

4.1 connect的非阻塞
// man connect说明
// The  socket  is  nonblocking and the connection cannot be completed immediately.  (UNIX domain sockets failed with EAGAIN     // instead.)  It is possible to select(2) or poll(2) for completion by selecting the socket for writing.  After select(2)     
// indicates writability, use getsockopt(2) to read the SO_ERROR option  at  level  SOL_SOCKET  to determine whether connect()   // completed successfully (SO_ERROR is zero) or unsuccessfully (SO_ERROR is one of the usual error codes listed here, explaining // the reason for the failure).
// 示例代码如下：
int32_t fd = -1;
int32_t ret  = IndustrialSocketCreate(AF_INET, SOCK_STREAM, 0, &fd);
struct sockaddr_in sendAddr;
bzero(&sendAddr, sizeof(sendAddr));
sendAddr.sin_family = AF_INET;
sendAddr.sin_port = htons(SEND_DATA_PORT);
sendAddr.sin_addr.s_addr = inet_addr(peerIp.c_str());
ChangeNonBlockMode(fd, true);

ret = connect(fd, (struct sockaddr*)&sendAddr, sizeof(sendAddr));
if (ret < 0 && errno != EINPROGRESS) {
    IBHILOGI("connect server fd:%{public}d fail, errno=%{public}d", fd, errno);
    DestroyBusSocket(&fd);
    return -1;
}
// 判断是否可写
fd_set wset;
FD_ZERO(&wset);
FD_SET(fd,&wset);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = USER_TIMEOUT_MS;
if (select(fd+1, NULL, &wset, NULL, &tv) == 0) {
    IBHILOGI("select server fd:%{public}d fail, errno=%{public}d", fd, errno);
    DestroyBusSocket(&fd);
    return -1;
}
// at  level  SOL_SOCKET  to determine whether connect() completed successfully (SO_ERROR is zero) or unsuccessfully (SO_ERROR // is one of the usual error codes listed here, explaining the reason for the failure).
if (FD_ISSET(fd,&wset))
{
    int error;
    socklen_t len = sizeof(error);
    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
    if (ret < 0 || (ret == 0 && error != 0)) {
        IBHILOGI("getsockopt server fd:%{public}d fail, "
                 "error:%{public}d, errno=%{public}d", fd, error, errno);
        DestroyBusSocket(&fd);
        return -1;
    }
}
4.2 recvfrom的非阻塞
4.2.1 阻塞socket
// 通过SO_RCVTIMEO设置接收超时时间
// 设置超时
while (softbus->GetDiscoveryState()) {
    // 设置超时
    struct timeval timeout;
    timeout.tv_sec = 0;//秒
    timeout.tv_usec = USER_TIMEOUT_MS;//微秒
    if (setsockopt(softbus->discoveryFd_, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
        IBHILOGE("setsockopt SO_RCVTIMEO failed errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
struct sockaddr_in server_socket;
while (softbus->GetDiscoveryState()) {
    bzero(&server_socket, sizeof(server_socket));
    server_socket.sin_family = AF_INET;
    server_socket.sin_addr.s_addr = htonl(INADDR_ANY);
    server_socket.sin_port = htons(MULTICAST_PORT);

    // 调用bind绑定socket地址
    if (bind(softbus->discoveryFd_, (struct sockaddr*)&server_socket, sizeof(struct sockaddr)) == -1) {
        IBHILOGE("bind error errno:%{public}d", errno);
        usleep(DISCOVERY_INTERVAL);
    } else {
        break;
    }
}
softbus->discoveryThread.SetThreadState(true);
while (softbus->discoveryThread.GetThreadState()) {
    if (softbus->GetDiscoveryState()) {
        struct sockaddr_in recvAddr;
        memset(recvBuff, 0, sizeof(recvBuff));
        memset(&recvAddr, 0, sizeof(struct sockaddr));
        int sinSize = sizeof(struct sockaddr_in);
        int ret = recvfrom(softbus->discoveryFd_, recvBuff, sizeof(recvBuff) - 1, 0,
                           (struct sockaddr*)&recvAddr, (socklen_t *)&sinSize);
        if (ret > 0 ) {
            IBHILOGI("recvfrom client IP:%{public}s cast:%{public}s ret:%{public}d",
                     inet_ntoa(recvAddr.sin_addr), recvBuff, ret);
            std::string recvMulticastData = recvBuff;
            if (recvMulticastData.length() != (MULTICAST_LEN + MAC_ADDR_LEN + TIME_STAMP_LEN)) {
                usleep(DISCOVERY_INTERVAL);
                continue;
            } else {
                std::string auth = recvMulticastData.substr(0, MULTICAST_LEN);
                std::string peerMac = recvMulticastData.substr(MULTICAST_LEN, MAC_ADDR_LEN);
                if (auth.compare(MULTICAST_DATA) == 0 && softbus->localMac_.compare(peerMac) != 0) { // 校验组播数据
                    std::string peerStamp = 
                        recvMulticastData.substr(MULTICAST_LEN + MAC_ADDR_LEN, TIME_STAMP_LEN);
                    std::string peerAddr = inet_ntoa(recvAddr.sin_addr);
                    int32_t iFound = softbus->DiscoveryUpdateDeviceInfo(peerMac, peerAddr, peerStamp);
                    if (iFound >=0) {
                        softbus->NotifyDeviceFound(peerMac, peerAddr, peerStamp);
                        if (iFound > 0) {
                            softbus->UpdatePeerJoinInfo(peerAddr);
                        }
                    }
                }
                usleep(DISCOVERY_INTERVAL);
            }
        } else {
            IBHILOGI("recvfrom error:%{public}d ret:%{public}d, retry recvfrom cast", errno, ret);
            usleep(DISCOVERY_INTERVAL);
            continue;
        }
    } else {
        IBHILOGI("UnDiscoverySoftbus................");
        usleep(DISCOVERY_INTERVAL);
    }
}
4.2.2 设置非阻塞
// recv与recvfrom处理相同
if (IndustrialWaitEvent(fd, INDUSTRIAL_SOCKET_IN, USER_TIMEOUT_MS) > 0) {
    int32_t bytesReceived = IndustrialSocketRecv(fd, buffer + valread, dataLength-valread, 0);
    if (bytesReceived == -1) {
        if (errno == EINTR || errno == EAGAIN) {
            retry++;
        } else {
            IBHILOGE("processData:read failed");
            retry++;
        }
    } else if (bytesReceived == 0) {
        IBHILOGE("processData:socket error");
        return;
    } else {
        valread += bytesReceived;
    }
} else{
    IBHILOGE("processData:IndustrialWaitEvent failed");
    retry++;
}
上述相关函数汇总
void DestroyBusSocket(int32_t *socketFd)
{
    IBHILOGE("DestroyBusSocket socketF:%{public}d", *socketFd);
    if(*socketFd > 0) {
        close(*socketFd);
        *socketFd = -1;
    }
}
int32_t IndustrialSocketSelect(int32_t nfds, fd_set *readFds, fd_set *writeFds, fd_set *exceptFds,
    struct timeval *timeOut)
{
    if (timeOut == NULL) {
        IBHILOGE("timeOut is null");
        return -1;
    }

    int32_t ret = select(nfds, readFds, writeFds, exceptFds, timeOut);
    if (ret < 0) {
        IBHILOGE("select : %{public}s", strerror(errno));
    }

    return ret;
}
int32_t IndustrialSocketCreate(int32_t domain, int32_t type, int32_t protocol, int32_t *socketFd)
{
    if (socketFd == NULL) {
        IBHILOGE("socketFd is null");
        return -1;
    }
    int32_t ret;
    ret = socket(domain, type, protocol);
    if (ret < 0) {
        IBHILOGE("socket %{public}s", strerror(errno));
        return -1;
    } else {
        *socketFd = ret;
        return 0;
    }
}
int32_t ChangeNonBlockMode(int32_t fd, bool isNonBlock)
{
    if (fd < 0) {
        return -1;
    }
    int32_t flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) {
        IBHILOGE("fd=%{public}d,fcntl get flag failed, errno=%{public}d", fd, errno);
        return -1;
    }
    if (isNonBlock && ((uint32_t)flags & O_NONBLOCK) == 0) {
        flags = (int32_t)((uint32_t)flags | O_NONBLOCK);
        IBHILOGI("fd=%{public}d set to nonblock", fd);
    } else if (!isNonBlock && ((uint32_t)flags & O_NONBLOCK) != 0) {
        flags = (int32_t)((uint32_t)flags & ~O_NONBLOCK);
        IBHILOGI("fd=%{public}d set to block", fd);
    } else {
        IBHILOGI("fd=%{public}d nonblock state is already ok", fd);
        return 0;
    }
    return fcntl(fd, F_SETFL, flags);
}
int32_t IndustrialSocketSend(int32_t socketFd, const void *buf, uint32_t len, int32_t flags)
{
    int32_t wrapperFlag = flags | MSG_NOSIGNAL;
    int32_t ret = send(socketFd, buf, len, wrapperFlag);
    if (ret < 0) {
        IBHILOGI("send : %{public}s, errno:%{public}d", strerror(errno), errno);
        return ret;
    }

    return ret;
}

int32_t IndustrialSocketRecv(int32_t socketFd, void *buf, uint32_t len, int32_t flags)
{
    int32_t ret = recv(socketFd, buf, len, flags);
    if (ret < 0) {
        IBHILOGI("recv : %{public}s errno:%{public}d", strerror(errno), errno);
        return ret;
    }

    return ret;
}

int IndustrialWaitEvent(int fd, short events, int timeout)
{
    if (fd < 0) {
        IBHILOGI("%{public}s:%{public}d:fd=%{public}d invalid params", __func__, __LINE__, fd);
        return -1;
    }
    struct timeval tv = {0};
    tv.tv_sec = 0;
    tv.tv_usec = timeout;
    int rc = 0;
    switch (events) {
        case INDUSTRIAL_SOCKET_OUT: {
                fd_set writeSet;
                FD_ZERO(&writeSet);
                FD_SET(fd, &writeSet);
                rc = IndustrialSocketSelect(fd + 1, NULL, &writeSet, NULL, &tv);
            }
        case INDUSTRIAL_SOCKET_IN: {
                fd_set readSet;
                FD_ZERO(&readSet);
                FD_SET(fd, &readSet);
                rc = IndustrialSocketSelect(fd + 1, &readSet, NULL, NULL, &tv);
            }
        default:
            break;
    }
    return rc;
}

猜你喜欢

转载自blog.csdn.net/procedurecode/article/details/134329468
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022