linux socketpair(UNIX domain socket)

最新推荐文章于 2024-05-28 16:15:01 发布
最新推荐文章于 2024-05-28 16:15:01 发布
阅读量2k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/win_lin/article/details/8831079
版权

阻塞方式

使用阻塞方法读取socketpair，代码如下： 
/*
g++ sp_block.cpp -g -O0 -o sp_block
*/
#include <unistd.h>
#include <stdio.h>
#include <time.h>

// socketpair
#include <sys/types.h>
#include <sys/socket.h>

// fork
#include <sys/types.h>
#include <unistd.h>

// atoi
#include <stdlib.h>

// errno
#include <errno.h>
// strerror
#include <string.h>

#define srs_trace(msg, ...) \
    printf("[%d][%d]", time(NULL), getpid()); \
    printf(msg, ##__VA_ARGS__); \
    if(errno) \
        printf(", errno=%d(%s)\n", errno, strerror(errno)); \
    else \
        printf("\n")

int RecvFD(int fd, int* pfd){
    *pfd = 0;
    
    msghdr msg;
    
    // msg_iov
    iovec iov[1];
    iov[0].iov_base = pfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen  = 1;
    
    // msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // msg_control
    union { // union to create a 8B aligned memory.
        struct cmsghdr cm; // 16B = 8+4+4
        char space[CMSG_SPACE(sizeof(int))]; // 24B = 16+4+4
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    if((recvmsg(fd, &msg, 0)) == -1){
        srs_trace("st_recvmsg recv fd error.");
        return -1;
    }
    
    *pfd = *(int *)CMSG_DATA(&cmsg.cm);
    
    if(*pfd <= 0){
        srs_trace("if transfer fd, the fd must be positive. actual is %d", *pfd);
        return -1;
    }
    
    srs_trace("get a fd from msg, fd=%d", *pfd);
    
    return 0;
}

int SendFD(int fd, int clientfd){
    // transfer the fd.
    msghdr msg;
    union {
        struct cmsghdr cm;
        char space[CMSG_SPACE(sizeof(int))];
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    cmsg.cm.cmsg_level = SOL_SOCKET;
    cmsg.cm.cmsg_type = SCM_RIGHTS; // we are sending fd.
    cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    *(int *)CMSG_DATA(&cmsg.cm) = clientfd;
    
    // init msg_iov
    iovec iov[1];
    iov[0].iov_base = &clientfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
    
    // init msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // send fd
    if(sendmsg(fd, &msg, 0) == -1){
        srs_trace("st_sendmsg failed");
        return -1;
    }
    
    srs_trace("st_sendmsg send fd=%d", clientfd);
    
    return 0;
}

int main(int argc, char** argv){
    srs_trace("Error value trace:");
    srs_trace("     EMSGSIZE=%d(%s)", EMSGSIZE, strerror(EMSGSIZE));
    srs_trace("     EAGAIN=%d(%s)", EAGAIN, strerror(EAGAIN));
    if(argc <= 7){
        srs_trace("Usage: <%s> "
            "<send_count> <send_size> <send_sleep> "
            "<recv_count> <recv_size> <recv_sleep> "
            "<transfer_fd>", 
            argv[0]);
        return -1;
    }
    int send_count = atoi(argv[1]);
    int send_size = atoi(argv[2]);
    int send_sleep = atoi(argv[3]);
    int recv_count = atoi(argv[4]);
    int recv_size = atoi(argv[5]);
    int recv_sleep = atoi(argv[6]);
    int transfer_fd = atoi(argv[7]);
    srs_trace("send_size=%dB send_count=%d send_sleep=%dms "
        "recv_size=%dB recv_count=%d recv_sleep=%dms transfer_fd=%d", 
        send_size, send_count, send_sleep, recv_size, recv_count, 
        recv_sleep, transfer_fd);
        
    char* packet_send = new char[send_size];
    char* packet_recv = new char[recv_size];
    int size = 0;
    
    int fds[2];
    if((socketpair(PF_UNIX, SOCK_STREAM, 0, fds)) == -1){
        srs_trace("create socketpair failed");
        return -1;
    }
    srs_trace("create socketpair success");
    
    int pid = fork();
    if(pid == -1){
        srs_trace("create [sender] failed");
        return -1;
    }
    
    if(pid == 0){
        int client = socket(PF_INET, SOCK_STREAM, 0);
        int fd = fds[1];
        srs_trace("[sender] pid=%d, fd=%d, peer=%d, client=%d", getpid(), fd, fds[0], client);
        
        int nb_sent = 0;
        for(int i = 0; send_size > 0 && i < send_count; i++){
            errno = 0;
            srs_trace("[sender] start to send msg");
            
            if((size = send(fd, packet_send, send_size, 0)) != send_size){
                srs_trace("[sender] send packet error. i=%d, size=%d", i, size);
                return -1;
            }
            nb_sent += size;
            srs_trace("[sender] send packet. size=%d", size);
            
            if(send_sleep > 0 && i < send_count - 1){
                usleep(send_sleep * 1000);
            }
        }
        srs_trace("[sender] send send_count=%d send_size=%dB sent=%dB, sleep=%dms success", 
            send_count, send_size, nb_sent, send_sleep);
        
        if(transfer_fd && SendFD(fd, client) == -1){
            srs_trace("[sender] send fd error");
            return -1;
        }
        srs_trace("[sender] send fd ok, fd=%d", client);
    }
    else{
        int fd = fds[0];
        srs_trace("[receiver] pid=%d, fd=%d, peer=%d", getpid(), fd, fds[1]);
        
        int nb_recv = 0;
        for(int i = 0; recv_size > 0 && i < recv_count; i++){
            errno = 0;
            srs_trace("start to read msg");
            
            if((size = recv(fd, packet_recv, recv_size, 0)) == -1){
                srs_trace("[receiver] recv packet error. i=%d, size=%d", i, size);
                return -1;
            }
            nb_recv += size;
            srs_trace("[receiver] recv packet. size=%d", size);
            
            if(recv_sleep > 0 && i < recv_count - 1){
                usleep(recv_sleep * 1000);
            }
        }
        srs_trace("[receiver] recv recv_count=%d recv_size=%dB recv=%dB, sleep=%dms success", 
            recv_count, recv_size, nb_recv, recv_sleep);
        
        int client = 0;
        if(transfer_fd && RecvFD(fd, &client) == -1){
            srs_trace("[receiver] recv fd error");
            return -1;
        }
        srs_trace("[receiver] recv fd ok, fd=%d", client);
    }
    
    srs_trace("test completed, sleep a while then exit");
    sleep(30);
    
    return 0;
}

1. 小数据方式，发送两次2字节，发送间隔3秒；接收1次，每次4字节；不发送msg(fd)。可见只接收到了2字节： 
./sp_block 2 2 3000 1 4 0 0
[1414330113][13832][receiver] pid=13832, fd=3, peer=4
[1414330113][13833][sender] pid=13833, fd=4, peer=3, client=5
[1414330113][13832][receiver] recv recv_count=1 recv_size=4B recv=2B, sleep=0ms success
[1414330116][13833][sender] send send_count=2 send_size=2B sent=4B, sleep=3000ms success

2. 小数据方式，缩小发送的间隔，改为0秒，发送2次，每次2字节；接收1次，每次4字节；不发送msg(fd)。可见内核做了合并，接收到了4字节： 
./sp_block 2 2 0 1 4 0 0
[1414330176][13849][receiver] pid=13849, fd=3, peer=4
[1414330176][13850][sender] pid=13850, fd=4, peer=3, client=5
[1414330176][13850][sender] send send_count=2 send_size=2B sent=4B, sleep=0ms success
[1414330176][13849][receiver] recv recv_count=1 recv_size=4B recv=4B, sleep=0ms success

3. 小数据方式，发送两次每次2字节，间隔3秒；接收1次每次4字节；发送msg(fd)。可见接收fd错误，原因是把第2个2字节作为msg： 
./sp_block 2 2 3000 1 4 0 1
[1414330769][13986][receiver] pid=13986, fd=3, peer=4
[1414330769][13987][sender] pid=13987, fd=4, peer=3, client=5
[1414330769][13986][receiver] recv recv_count=1 recv_size=4B recv=2B, sleep=0ms success
[1414330772][13987][sender] send send_count=2 send_size=2B sent=4B, sleep=3000ms success
[1414330772][13986][receiver] recv fd error
[1414330772][13987][sender] send fd ok, fd=5

4. 小数据方式，发送2次每次2字节，间隔0秒；接收1次每次4字节；发送msg(fd)。可见内核合并，收到了4字节和后面的fd： 
./sp_block 2 2 0 1 4 0 1
[1414330912][14018][receiver] pid=14018, fd=3, peer=4
[1414330912][14019][sender] pid=14019, fd=4, peer=3, client=5
[1414330912][14019][sender] send send_count=2 send_size=2B sent=4B, sleep=0ms success
[1414330912][14018][receiver] recv recv_count=1 recv_size=4B recv=4B, sleep=0ms success
[1414330912][14019][sender] send fd ok, fd=5
[1414330912][14018][receiver] recv fd ok, fd=5

结论：
1. 阻塞方式收发时，收的单元不能大于发的单元。譬如每次发送2个包，那么收的时候可以收<=2个包。譬如每次发送2字节，那么收的时候可以收<=2字节。否则阻塞方式也可能收到某个包，导致后面的包解析错误，譬如第3个命令遇到的把发送的后2字节当作msg解析。
2. 发送时间较短时，内核会组包。但是不能因为这个就违反第一个结论。即不能依靠这种机制，并不能保证组合成大包一起发送，也就是说，接收必须小于发送的单元。

其他方式见下面。


非阻塞方式

使用非阻塞方法读取socketpair： 
/*
g++ sp_noblock.cpp -g -O0 -o sp_noblock
*/
#include <unistd.h>
#include <stdio.h>
#include <time.h>

// socketpair
#include <sys/types.h>
#include <sys/socket.h>

// fork
#include <sys/types.h>
#include <unistd.h>

// atoi
#include <stdlib.h>

// errno
#include <errno.h>
// strerror
#include <string.h>

#define srs_trace(msg, ...) \
    printf("[%d][%d]", time(NULL), getpid()); \
    printf(msg, ##__VA_ARGS__); \
    if(errno) \
        printf(", errno=%d(%s)\n", errno, strerror(errno)); \
    else \
        printf("\n")

int RecvFD(int fd, int* pfd){
    *pfd = 0;
    
    msghdr msg;
    
    // msg_iov
    iovec iov[1];
    iov[0].iov_base = pfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen  = 1;
    
    // msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // msg_control
    union { // union to create a 8B aligned memory.
        struct cmsghdr cm; // 16B = 8+4+4
        char space[CMSG_SPACE(sizeof(int))]; // 24B = 16+4+4
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    if((recvmsg(fd, &msg, MSG_DONTWAIT)) == -1){
        srs_trace("st_recvmsg recv fd error.");
        return -1;
    }
    
    *pfd = *(int *)CMSG_DATA(&cmsg.cm);
    
    if(*pfd <= 0){
        srs_trace("if transfer fd, the fd must be positive. actual is %d", *pfd);
        return -1;
    }
    
    srs_trace("get a fd from msg, fd=%d", *pfd);
    
    return 0;
}

int SendFD(int fd, int clientfd){
    // transfer the fd.
    msghdr msg;
    union {
        struct cmsghdr cm;
        char space[CMSG_SPACE(sizeof(int))];
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    cmsg.cm.cmsg_level = SOL_SOCKET;
    cmsg.cm.cmsg_type = SCM_RIGHTS; // we are sending fd.
    cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    *(int *)CMSG_DATA(&cmsg.cm) = clientfd;
    
    // init msg_iov
    iovec iov[1];
    iov[0].iov_base = &clientfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
    
    // init msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // send fd
    if(sendmsg(fd, &msg, MSG_DONTWAIT) == -1){
        srs_trace("st_sendmsg failed");
        return -1;
    }
    
    srs_trace("st_sendmsg send fd=%d", clientfd);
    
    return 0;
}

int main(int argc, char** argv){
    srs_trace("Error value trace:");
    srs_trace("     EMSGSIZE=%d(%s)", EMSGSIZE, strerror(EMSGSIZE));
    srs_trace("     EAGAIN=%d(%s)", EAGAIN, strerror(EAGAIN));
    if(argc <= 7){
        srs_trace("Usage: <%s> "
            "<send_count> <send_size> <send_sleep> "
            "<recv_count> <recv_size> <recv_sleep> "
            "<transfer_fd>", 
            argv[0]);
        return -1;
    }
    int send_count = atoi(argv[1]);
    int send_size = atoi(argv[2]);
    int send_sleep = atoi(argv[3]);
    int recv_count = atoi(argv[4]);
    int recv_size = atoi(argv[5]);
    int recv_sleep = atoi(argv[6]);
    int transfer_fd = atoi(argv[7]);
    srs_trace("send_size=%dB send_count=%d send_sleep=%dms "
        "recv_size=%dB recv_count=%d recv_sleep=%dms transfer_fd=%d", 
        send_size, send_count, send_sleep, recv_size, recv_count, 
        recv_sleep, transfer_fd);
        
    char* packet_send = new char[send_size];
    char* packet_recv = new char[recv_size];
    int size = 0;
    
    int fds[2];
    if((socketpair(PF_UNIX, SOCK_STREAM, 0, fds)) == -1){
        srs_trace("create socketpair failed");
        return -1;
    }
    srs_trace("create socketpair success");
    
    int pid = fork();
    if(pid == -1){
        srs_trace("create [sender] failed");
        return -1;
    }
    
    if(pid == 0){
        int client = socket(PF_INET, SOCK_STREAM, 0);
        int fd = fds[1];
        srs_trace("[sender] pid=%d, fd=%d, peer=%d, client=%d", getpid(), fd, fds[0], client);
        
        int nb_sent = 0;
        for(int i = 0; send_size > 0 && i < send_count; i++){
            errno = 0;
            srs_trace("[sender] start to send msg");
            
            if(send_sleep > 0){
                usleep(send_sleep * 1000);
            }
            
            if((size = send(fd, packet_send, send_size, MSG_DONTWAIT)) != send_size){
                srs_trace("[sender] send packet error. i=%d, size=%d", i, size);
                return -1;
            }
            nb_sent += size;
            srs_trace("[sender] send packet. size=%d", size);
        }
        srs_trace("[sender] send send_count=%d send_size=%dB sent=%dB, sleep=%dms success", 
            send_count, send_size, nb_sent, send_sleep);
        
        if(transfer_fd && SendFD(fd, client) == -1){
            srs_trace("[sender] send fd error");
            return -1;
        }
        srs_trace("[sender] send fd ok, fd=%d", client);
    }
    else{
        int fd = fds[0];
        srs_trace("[receiver] pid=%d, fd=%d, peer=%d", getpid(), fd, fds[1]);
        
        int nb_recv = 0;
        for(int i = 0; recv_size > 0 && i < recv_count; i++){
            errno = 0;
            srs_trace("start to read msg");
            
            if(recv_sleep > 0){
                usleep(recv_sleep * 1000);
            }
            
            if((size = recv(fd, packet_recv, recv_size, MSG_DONTWAIT)) == -1){
                srs_trace("[receiver] recv packet error. i=%d, size=%d", i, size);
                return -1;
            }
            nb_recv += size;
            srs_trace("[receiver] recv packet. size=%d", size);
        }
        srs_trace("[receiver] recv recv_count=%d recv_size=%dB recv=%dB, sleep=%dms success", 
            recv_count, recv_size, nb_recv, recv_sleep);
        
        int client = 0;
        if(transfer_fd && RecvFD(fd, &client) == -1){
            srs_trace("[receiver] recv fd error");
            return -1;
        }
        srs_trace("[receiver] recv fd ok, fd=%d", client);
    }
    
    srs_trace("test completed, sleep a while then exit");
    sleep(30);
    
    return 0;
}

非阻塞读取socketpair，都得处理读取出来的字节少于期待的字节的情况。


ST的处理方式

附上st的处理方式:

/*
g++ sp_st_fd.cpp -g -O0 -Ist-1.9/obj st-1.9/obj/libst.a -o sp_st_fd
*/
#include <unistd.h>
#include <stdio.h>

// socketpair
#include <sys/types.h>
#include <sys/socket.h>

// fork
#include <sys/types.h>
#include <unistd.h>

// atoi
#include <stdlib.h>

// errno
#include <errno.h>
// strerror
#include <string.h>

#include <st.h>

int RecvFD(st_netfd_t stfd, int* pfd){
    *pfd = 0;
    
    msghdr msg;
    
    // msg_iov
    iovec iov[1];
    iov[0].iov_base = pfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen  = 1;
    
    // msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // msg_control
    union { // union to create a 8B aligned memory.
        struct cmsghdr cm; // 16B = 8+4+4
        char space[CMSG_SPACE(sizeof(int))]; // 24B = 16+4+4
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    if((st_recvmsg(stfd, &msg, 0, ST_UTIME_NO_TIMEOUT)) == -1){
        printf("st_recvmsg recv fd error. errno=%d(%#x)\n", errno, errno);
        return -1;
    }
    
    *pfd = *(int *)CMSG_DATA(&cmsg.cm);
    
    if(*pfd <= 0){
        printf("if transfer fd, the fd must be positive. actual is %d\n", *pfd);
        return -1;
    }
    
    printf("get a fd from msg, fd=%d\n", *pfd);
    
    return 0;
}

int SendFD(st_netfd_t stfd, int clientfd){
    // transfer the fd.
    msghdr msg;
    union {
        struct cmsghdr cm;
        char space[CMSG_SPACE(sizeof(int))];
    } cmsg;
    memset(&cmsg, 0, sizeof(cmsg));
    
    cmsg.cm.cmsg_level = SOL_SOCKET;
    cmsg.cm.cmsg_type = SCM_RIGHTS; // we are sending fd.
    cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
    
    msg.msg_control = (cmsghdr*)&cmsg;
    msg.msg_controllen = sizeof(cmsg);
    
    *(int *)CMSG_DATA(&cmsg.cm) = clientfd;
    
    // init msg_iov
    iovec iov[1];
    iov[0].iov_base = &clientfd;
    iov[0].iov_len  = sizeof(int);
    
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
    
    // init msg_name
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
    
    // send fd
    if(st_sendmsg(stfd, &msg, 0, ST_UTIME_NO_TIMEOUT) == -1){
        printf("st_sendmsg failed, errno=%d(%#x)\n", errno, errno);
        return -1;
    }
    
    printf("st_sendmsg send fd=%d\n", clientfd);
    
    return 0;
}

void* thread(void* arg){
    for(;;){
        printf("in st thread.\n");
        st_sleep(1);
    }
    return NULL;
}

int main(int argc, char** argv){
    #if 1
    printf("errno=EMSGSIZE(%d), %s\n", EMSGSIZE, strerror(EMSGSIZE));
    if(argc <= 6){
        printf("Usage: <%s> <send_count> <recv_count> <packet_send_size> <packet_recv_size> <parent_process_sleep> <sub_process_sleep>\n", argv[0]);
        return -1;
    }
    int send_count = atoi(argv[1]);
    int recv_count = atoi(argv[2]);
    int packet_send_size = atoi(argv[3]);
    int packet_recv_size = atoi(argv[4]);
    int parent_process_sleep = atoi(argv[5]);
    int sub_process_sleep = atoi(argv[6]);
    printf("packet_send_size=%dB packet_recv_size=%dB send_count=%d recv_count=%d parent_process_sleep=%dms sub_process_sleep=%dms\n", 
        packet_send_size, packet_recv_size, send_count, recv_count, parent_process_sleep, sub_process_sleep);
        
    char* packet_send = new char[packet_send_size];
    char* packet_recv = new char[packet_recv_size];
    int size = 0;
    #endif
    
    int fds[2];
    if((socketpair(PF_UNIX, SOCK_STREAM, 0, fds)) == -1){
        printf("create socketpair failed\n");
        return -1;
    }
    printf("create socketpair success\n");
    
    int pid = fork();
    if(pid == -1){
        printf("create [sub] failed\n");
        return -1;
    }
    
    // init st.
    if(st_init() == -1){
        printf("st_init error\n");
        return -1;
    }
    if(st_thread_create(thread, NULL, 0, 0) == NULL){
        printf("create st thread error.\n");
        return -1;
    }
    
    if(pid == 0){
        int client = socket(PF_INET, SOCK_STREAM, 0);
        int fd = fds[1];
        printf("[sub] pid=%d, fd=%d, peer=%d, client=%d\n", getpid(), fd, fds[0], client);
        
        st_netfd_t stfd = st_netfd_open(fd);
        if(stfd == NULL){
            printf("[sub] open stfd failed.\n");
            return -1;
        }
        
        for(int i = 0; i < send_count; i++){
            errno = 0;
            if(sub_process_sleep > 0){
                usleep(sub_process_sleep * 1000);
            }
            
            printf("[sub] start to send msg and fd.\n");
            if(packet_send_size > 0){
                if((size = st_write(stfd, packet_send, packet_send_size, ST_UTIME_NO_TIMEOUT)) != packet_send_size){
                    printf("[sub] send packet error. i=%d, size=%d, errno=%d, msg=%s\n", i, size, errno, strerror(errno));
                    return -1;
                }
                printf("[sub] send packet. size=%d, errno=%d(%s)\n", size, errno, strerror(errno));
            }
        }
        
        if(SendFD(stfd, client) == -1){
            printf("[sub] send fd error. errno=%d, msg=%s\n", errno, strerror(errno));
            return -1;
        }
        printf("[sub] send send_count=%d packet_send_size=%dB, sleep=%dms success\n", send_count, packet_send_size, sub_process_sleep);
    }
    else{
        int fd = fds[0];
        printf("[parent] pid=%d, fd=%d, peer=%d\n", getpid(), fd, fds[1]);
        
        st_netfd_t stfd = st_netfd_open(fd);
        if(stfd == NULL){
            printf("[parent] open stfd failed.\n");
            return -1;
        }
        
        int client = 0;
        for(int i = 0; i < recv_count; i++){
            errno = 0;
            if(parent_process_sleep > 0){
                usleep(parent_process_sleep * 1000);
            }
            if(client > 0){
                close(client);
            }
            
            printf("start to read msg and fd.\n");
            if(packet_recv_size > 0){
                if((size = st_read(stfd, packet_recv, packet_recv_size, ST_UTIME_NO_TIMEOUT)) == -1){
                    printf("[parent] recv packet error. i=%d, size=%d, errno=%d, msg=%s\n", i, size, errno, strerror(errno));
                    return -1;
                }
                printf("[parent] recv packet. size=%d, errno=%d(%s)\n", size, errno, strerror(errno));
            }
        }
        
        if(RecvFD(stfd, &client) == -1){
            printf("[sub] send fd error. errno=%d, msg=%s", errno, strerror(errno));
            return -1;
        }
        printf("[parent] recv recv_count=%d packet_recv_size=%dB, sleep=%dms success\n", recv_count, packet_recv_size, parent_process_sleep);
    }
    
    sleep(30);
    
    return 0;
}

./sp_st_fd 2 2 10 20 0 3000

发送2次，每次发送10字节。

收取时，每次收取20字节，就会有EAGAIN消息。

第1次收取，收取10字节。

第2次收取，收取10字节。

[parent] recv packet. size=10, errno=11(Resource temporarily unavailable)

[parent] recv packet. size=10, errno=11(Resource temporarily unavailable)

[parent] recv recv_count=2 packet_recv_size=20B, sleep=0ms success

然后正常的收到fd。


结论

结论是：

1. 发送端和接收端，同时操作的数据应该是一样的。譬如，发送端一次发送100个字节的头，接收端先接受100个字节的头。发送端再发送x字节的数据，接收端接受x字节的数据。

2.发送端对于每次来回不能发送多次，否则接收端就会出现EAGAIN或者其他的情况。譬如头是100字节，发送端就必须一次发送100字节，而不能做两次发送，一次发送20一次发送80.

3.可见每个消息不超过16000，超过后需要分多次发送了。

4.只要单次一次发送，不管是否是非阻塞，都能收到。譬如发送fd，一次发送一个msghdr，只要发送端一次发送，接收端一次接收，就没有问题。不会出现收到一半的情况。

5.只有当发送端因为某种原因发送了一部分，接收端一次接收的超过了发送的部分，就会出现非阻塞的EAGAIN。

再论结论

原因就是因为sendmsg和recvmsg是原子操作。

譬如有以下协议：

1. 发送4字节类型

2. 发送4字节长度

3. 发送长度指定的数据

4. 发送一个cmsg消息

读取时不能超过发送的组合单元，譬如假设是分四次发送的，那么就必须分四次接收，因为不能保证1和2是一起收到的。

假设1和2是一起发送，3单独发送，4单独发送；那么接收时可以一起接收1和2，但是不能一起接收1和2和3。也可以分开接收1，然后收2.

打个比方，这个就像包裹一样的，如果快递时1和2是一起打包的，到门口接收时肯定是1和2一起到的，进门接收时可以收1，然后收2，或者一起收。

winlinvip
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
UNIX网络编程--socket中的同步/异步 阻塞/非阻塞
鱼思故渊的专栏
09-23 3739
1. 概念理解      在进行网络编程时，我们常常见到同步(Sync)/异步(Async)，阻塞(Block)/非阻塞(Unblock)四种调用方式： 同步：       所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做,等前一件做完了才能做下一件事。 例如普通B/S模式（同步）：提交请求->等待服务器处理->处理完毕返回 这
Linux Socket Unix Domain介绍
WeinKee的博客
06-10 861
以下内容引述至《Linux/Unix系统编程手册》 Unix domain socket允许同一系统上不同进程之间相互通信的一种方式 Unix domain socket地址 在Unix domain中，socket地址以路径名来表示，domain特定的socket地址结构的定义如下所示： struct socketaddr_un { sa_family_t sum_family; char sun_path[108]; } sockaddr_un 结构中字段 sun_前缀是根据socket unix
记录一次安卓unix domain socket卡死，导致整个系统卡死的问题
cf125313的专栏
04-13 350
2）使用ss工具查看该uds的缓冲区，发现居然是0。猜测是需要打开内核模块的某个配置才行。找到缓冲区数据结构的关键信息，反推内核源码，发现是需要打开CONFIG_UNIX_DIAG。1）dump出monkey的call trace,发现是unix socket write阻塞。分析内核源码，发现只有缓冲区满了，才会阻塞。
Linux Unix domain socket 详解
最新发布
lizhengyu891231的博客
05-28 285
Linux Unix domain socket 详解
Linux下socketpair系统API调用使用说明
hsy12342611的专栏
06-02 965
socketpair系统API调用使用说明
关于socketpair 的实验(基于linux)
Yasin Lee
02-09 1086
实验结果： 向s0写入数据，则可从s1读到数据，反之亦然。 如果没有向s0写入数据，则读取s1的动作会阻塞住，直到s0被写入数据。 在进程A中向s0写入数据后，也可在进程A中从s1把该数据读出来，当然也可以在进程B中从s1把该数据读出来。作为进程间通信的方法，通常的用法都是后者。 这样看来，通讯似乎是单向的，其实socketpair的全双工用法也很简单： 让进程A使用s0，则进程A可
socketpair的用法和理解
oykotxuyang的博客
05-11 606
转载：https://blog.csdn.net/weixin_40039738/article/details/81095013?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522158918635519725219904734%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=15891863551972521990
Linux socketpair详解
caoli98033的专栏
03-24 4330
socketpair函数概要如下： #include  定义一些C宏常量 #include  定义socketpair函数原型 int socketpair(int domain, int type, int protocol, int sv[2]); socketpair函数需要四个参数： domain-套接口的域 type-套接口类型 protocol-使用的协议 sv[2
Linux Socket学习
05-08
- 第 23-28 行：检查 `socketpair()` 的执行结果，如果失败则输出错误信息并退出程序。 - 第 33-34 行：输出创建的两个 Socket 的文件描述符。 - 第 36 行：使用 `netstat` 命令查看当前系统中所有的 Unix 域 ...
socket programing
05-08
Socket编程的主要内容包括预备知识、系统调用、系统I/O模型、调度模型、TCP编程、多进程并发编程、多线程并发编程、UDP编程、广播与多播编程、UNIX domain编程、嵌入式环境下的网络编程以及实现简单的WEB服务器等。...
socket详解
06-13
通常需要结合 `bind`, `listen`, `connect` 和 `socketpair` 等函数使用。 - **应用场景**：进程间的通信（IPC）。 2. **AF_INET**：IPv4 协议族，支持基于 IPv4 地址的互联网通信。 - **应用场景**：客户端...
unix网络编程1和2
03-01
8. **域套接字（Unix Domain Socket）**：用于同一台机器上的进程间通信，具有类似于TCP/IP套接字的功能。 通过学习这两卷书，读者不仅可以掌握网络编程的基本原理和实践，还能了解各种进程间通信机制，从而能够...
Java网络编程--Unix域协议：实现
12-25
此外，还有一些与管道（pipe）和套接字对（socket pair）相关的系统调用，它们也依赖于这些Unix域协议函数。 17.3 Unix domain和protosw结构 `domain`结构体（如图17-4所示）存储了关于协议家族的信息，包括协议族...
【流媒体服务器Mediasoup】 NodeJs与C++信令通信详解及Linux下管道通信的详解（五）
流媒体巅峰之路
08-04 1153
目录 前言 匿名管道进程间通信 进程间管道 的创建与图解 MediaSoup中的管道创建 MediaSoup Channel的创建 NodeJs和 C++ 管道通信的过程 MediaSoup 消息确认与事件通知 小结 前言 上篇文章对MediaSoup源码的调试方法以及运行时分析、调试、查看核心信息 【流媒体服务器Mediasoup】 源码中重要类基本概念 、上层代码作用详解、底层C++类关系详解(四)，本章节主要对MediaSoup的源码中源码中NodeJs与C++信令通信...
Linux socket编程(12):Unix套接字之socketpair、sendmsg和recvmsg详解
主要分享硬件、嵌入式软件部分知识
12-07 1778
在上一篇文章中，我们对Unix套接字编程有一个基本的了解。socketpairsendmsg和recvmsg，它们为实现本地进程间通信提供了便捷的方式。
《Linux高性能服务器编程》笔记二
weixin_44708428的博客
03-05 125
1. SIGPIPE信号 当向读端已经关闭的管道或套接字中写数据会引发SIGPIPE信号，而该信号默认结束进程，而我们绝对不希望因为错误的写操作而导致程序退出，引起SIGPIPE信号的写操作设置errno为EPIPE。在代码中需要不会并处理该信号，至少需要忽略它。 避免写操作触发SIGPIPE的方法： 通过send函数的MSG_NOSIGNAL来禁止触发SIGPIPE信号，这种情况如果send返回-1，应该根据errno的值来判断管道或socket连接的读端是否已经关闭。 还可以利用I/O复用系统调
Linux中的高级IO函数（一）pipe & socketpair & dup
Lyajpunov的博客
04-22 850
Linux提供了很多高级的I/O函数。它们并不像Linux基础I/O函数（比如open和read）那么常用（编写内核模块时一般要实现这些I/O函数），但在特定的条件下却表现出优秀的性能。这些函数大致分为三类：用于创建文件描述符的函数，包括pipe、socketpair、dup/dup2函数。用于读写数据的函数，包括readv/writev、sendfile、mmap/munmap、splice和tee函数。用于控制I/O行为和属性的函数，包括fcntl函数。本节先介绍第一类。
linux创建子进程通信,Linux进程间通信的socketpair()函数
weixin_34051133的博客
04-28 411
Linux的socketpair()函数，是创建一对互相连接着的socket描述符。类似TCP连接，两个文件描述符都可以读写，sv[0]写入的数据在sv[1]读出，sv[1]写入的数据在sv[0]读出。它的参数与socket()类似，只是多了一个int sv[2]项用于返回这两个文件描述符，返回值用于提示创建是否成功。而socket()函数的返回值就是文件描述符，用返回-1提示失败。上图为它的ma...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

winlinvip

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值