• linux下读取socket相关的系统调用总结

    recv

    函数原型

    1. /* Read N bytes into BUF from socket FD.
    2.    Returns the number read or -1 for errors.
    4.    This function is a cancellation point and therefore not marked with
    5.    __THROW.  */
    6. extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);

    所属文件

    sys/socket.h

    参数介绍

    1. 第一个参数指定接收端套接字描述符； 
    2. 第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据； 
    3. 第三个参数指明buf的长度；
    4. 第四个参数一般置0或者以下组合: 
    • MSG_DONTROUTE：不查找路由表,是send函数使用的标志.这个标志告诉IP协议.目的主机在本地网络上面,没有必要查找路由表.这个标志一般用网络诊断和路由程式里面
    • MSG_OOB：接受或发送带外数据,表示能够接收和发送带外的数据.
    • MSG_PEEK：查看数据,并不从系统缓冲区移走数据，是recv函数的使用标志，表示只是从系统缓冲区中读取内容，而不清除系统缓冲区的内容。这样下次读的时候,仍然是相同的内容。一般在有多个进程读写数据时能够使用这个标志
    • MSG_WAITALL ：等待任何数据

    返回值介绍

    1. 成功执行时，返回接收到的字节数。
    2. 对端已关闭，返回0，此时可关闭本地连接。
    3. 失败返回-1，errno被设为以下的某个值 ，注意errno是一个宏，声明如下：
    1. /* The error code set by various library functions.  */
    2. extern int *__errno_location (void) __THROW __attribute_const__;
    3. # define errno (*__errno_location ())

     errno返回的错误及含义如下所示：

    • EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时 。从字面上来看，是提示再试一次。这个错误经常出现在当应用程序进行一些非阻塞(non-blocking)操作(对文件或socket)的时候。例如，以O_NONBLOCK的标志打开file/socket/FIFO，如果你连续做read操作而没有数据可读。此时程序不会阻塞起来等待数据准备就绪返回，read或者recv函数会返回一个错误EAGAIN，提示你的应用程序现在没有数据可读请稍后再试。在VxWorks和Windows上，EAGAIN的名字叫做EWOULDBLOCK。该错误码使我们经常使用的错误码。
    • EBADF：sock不是有效的描述词 
    • ECONNREFUSE：远程主机阻绝网络连接 
    • EFAULT：内存空间访问出错 
    • EINTR：操作被信号中断，当出现该信号时并不是表示有问题，一般情况下我们会选择重新做报错的操作，例如read或者recv，该错误码是我们经常使用到的一个错误码。
    • EINVAL：参数无效 
    • ENOMEM：内存不足 
    • ENOTCONN：与面向连接关联的套接字尚未被连接上 
    • ENOTSOCK：sock索引的不是套接字 当返回值是0时，为正常关闭连接；

    注意：返回值<0并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续接收。EWOULDBLOCK与EAGAIN是一回事，只是不同系统的宏名称不同而已。

    流程介绍

    当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回SOCKET_ERROR；
    如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

    注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

    tcp协议本身是可靠的,并不等于应用程序用tcp发送数据就一定是可靠的.不管是否阻塞,send发送的大小,并不代表对端recv到多少的数据.

    在阻塞模式下, send函数的过程是将应用程序请求发送的数据拷贝到发送缓存中发送并得到确认后再返回.但由于发送缓存的存在,表现为:如果发送缓存大小比请求发送的大小要大,那么send函数立即返回,同时向网络中发送数据;否则,send向网络发送缓存中不能容纳的那部分数据,并等待对端确认后再返回(接收端只要将数据收到接收缓存中,就会确认,并不一定要等待应用程序调用recv);

    在非阻塞模式下,send函数的过程仅仅是将数据拷贝到协议栈的缓存区而已,如果缓存区可用空间不够,则尽能力的拷贝,返回成功拷贝的大小;如缓存区可用空间为0,则返回-1,同时设置errno为EAGAIN.

    send

    函数原型

    1. /* Send N bytes of BUF to socket FD.  Returns the number sent or -1.
    3.    This function is a cancellation point and therefore not marked with
    4.    __THROW.  */
    5. extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);

    所属文件

    sys/socket.h

    参数介绍

    1. 第一个参数指定发送端套接字描述符；
    2. 第二个参数指明一个存放应用程序要发送数据的缓冲区；
    3. 第三个参数指明实际要发送的数据的字节数；
    4. 第四个参数一般置0或者其它组合。
    flag参数介绍
    标志位解释
    MSG_CONFIRM只在SOCK_DGRAM和SOCK_RAW类型的socket有效，该标志位用于通知链路层收到了成功回复，以避免链路层定期发送ARP协议，减少流量。
    MSG_DONTROUTE不使用网关发送数据包，只能发送到直接连接的网络上的主机，通常用于网络诊断的路由系列协议。
    MSG_DONTWAIT设置本次调用为非阻塞，与O_NONBLOCK flag类似，但是该标志为作用域仅限于本次send调用，而后者则是对文件描述符操作。
    MSG_MORE此标志指定会有更多的数据发送，与 TCP_CORK 套接字设置效果相同，此时内核将保留这些数据，仅在下一次调用未指定该标志时进行传输。
    MSG_NOSIGNAL此标志指定调用send()，当对端的socket已经关闭时，不会产生SIGPIPE信号，但仍会返回EPIPE错误，作用范围为本次调用。这与sigaction忽略 SIGPIPE信号效果相同，但是后者会影响整个线程。
    MSG_OOB此标志指定在正常数据流的接受中不会接收带外数据。某些协议将加急数据放在正常数据队列的头部，因此此标志不能与此类协议一起使用。

    流程介绍

    当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲的长度， 如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。

    如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。

    要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回SOCKET_ERROR）。

    注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

    read

    函数原型

    1. /* Read NBYTES into BUF from FD.  Return the
    2.    number read, -1 for errors or 0 for EOF.
    4.    This function is a cancellation point and therefore not marked with
    5.    __THROW.  */
    6. extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __wur;

    所属文件

    unistd.h

    参数介绍

    read函数与recv函数功能类似，不同点是read函数相对于recv函数缺少了一个参数，至于这个参数的含义，可以参考recv的参数介绍章节。

    返回值介绍

    与recv函数类似，不再赘述。

    write

    函数原型

    1. /* Write N bytes of BUF to FD.  Return the number written, or -1.
    3.    This function is a cancellation point and therefore not marked with
    4.    __THROW.  */
    5. extern ssize_t write (int __fd, const void *__buf, size_t __n) __wur;

    所属文件

    unistd.h

    参数介绍

    write与send函数类似，不同的同样是缺少一个参数。对比他们的声明即可。若send函数最后一个参数为0，则他们是一致的。

    sendmsg/recvmsg

    函数原型

    1. /* Send a message described MESSAGE on socket FD.
    2.    Returns the number of bytes sent, or -1 for errors.
    4.    This function is a cancellation point and therefore not marked with
    5.    __THROW.  */
    6. extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
    7. 			int __flags);

    所属文件

    sys/socket.h

    参数介绍

    第二个参数介绍

    struct msghdr {
      void         *msg_name;       /* 套接字地址 */
      socklen_t     msg_namelen;    /* 地址长度 */
      struct iovec *msg_iov;        /* 散布/聚焦数组 */
      size_t        msg_iovlen;     /* msg_iov 的元素个数 */
      void         *msg_control;    /* 辅助数据 */
      size_t        msg_controllen; /* 辅助数据大小 */
      int           msg_flags;      /* 接收数据的标志，仅用于 recvmsg */
    }

     数据缓冲数据结构：

    #include
    struct iovec {
        void    *iov_base;      /* starting address of buffer */
        size_t  iov_len;        /* size of buffer */
    } 

    控制数据数据结构

    #include
    struct cmsghdr {
        socklen_t   cmsg_len;   /* length in bytes, including this structure */
        int         cmsg_level; /* originating protocol */
        int         cmsg_type;  /* protocol-specific type */
        /* followed by unsigned char cmsg_data[] */
    }

    msg_name 和 msg_namelen

    这两个成员用于套接字未连接的场合（如未连接 UDP 套接字）。它们类似 recvfrom 和 sendto 的第五个和第六个参数：

    • msg_name 指向一个套接字地址结构，调用者在其中存放接收者（对于 sendmsg 调用）或发送者（对于recvmsg调用）的协议地址。如果无需指明协议地址（如对于 TCP 套接字或已连接 UDP 套接字），msg_name 应置为空指针。
    • msg_namelen 对于 sendmsg 是一个值参数，对于 recvmsg 却是一个值-结果参数。

    msg_iov 和 msg_iovlen

    这两个成员指定输入或输出缓冲区数组（即iovec结构数组），类似 readv 或 writev 的第二个和第三个参数。

    msg_control 和 msg_controllen

    这两个成员指定可选的辅助数据的位置和大小。msg_controllen 对于 recvmsg 是一个值-结果参数。

    flags

    对于 recvmsg 和 sendmsg，必须区别它们的两个标志变量：

    • 一个是传递值的 flags 参数；
    • 另一个是所传递 msghdr 结构的 msg_flags 成员，它传递的是引用，因为传递给函数的是该结构的地址。

    只有 recvmsg 使用 msg_flags 成员。recvmsg 被调用时，flags 参数被复制到 msg_flags 成员，并由内核使用其值驱动接收处理过程。内核还依据 recvmsg 的结果更新 msg_flags 成员的值。

    sendmsg 则忽略 msg_flags 成员，因为它直接使用 flags 参数驱动发送处理过程。这一点意味着如果想在某个 sendmsg 调用中设置 MSG_DONTWAIT 标志，那就把 flags 参数设置为该值，把 msg_flags 成员设置为该值不起作用。

    recvmsg 返回的 7 个标志如下：

    • MSG_BCAST：本标志随 BSD/OS 引入，相对较新。它的返回条件是本数据包作为链路层广播收取或者其目的 IP 地址是一个广播地址。与 IP_RECVD-STADDR 套接字选项相比，本标志是用于判定一个 UPD 数据包是否发往某个广播地址的更好方法。
    • MSG_MCAST：本标志随 BSD/OS 引入，相对较新。它的返回条件是本数据报作为链路层多播收取。
    • MSG_TRUNC：本标志的返回条件是本数据报被截断，也就是说，内核预备返回的数据超过进程事先分配的空间（所有 iov_len 成员之和）。
    • MSG_CTRUNC：本标志的返回条件是本数据报的辅助数据被截断，也就是说，内核预备返回的辅助数据超过进程事先分配的空间（msg_controllen）。
    • MSG_EOR：本标志的返回条件是返回数据结束一个逻辑记录。TCP 不使用本标志，因为它是一个字节流协议。
    • MSG_OOB：本标志绝不为 TCP 带外数据返回。它用于其他协议族（如 OSI 协议族）。
    • MSG_NOTIFICATION：本标志由 SCTP 接收者返回，指示读入的消息是一个事先通知，而不是数据消息。

    rcvmsg服务端用例

    1. #include "stdio.h"
    2. #include "stdlib.h"
    3. #include "string.h"
    4. #include "unistd.h"
    5. #include "sys/wait.h"
    6. #include "sys/select.h"
    7. #include "sys/poll.h"
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. using namespace std;
    15.  
    16. #define MAXSIZE 100
    17.  
    18. int main(int argc, char ** argv)
    19. {
    20.     int		sockfd;
    21.     struct	sockaddr_in serv_socket;
    22.     struct	msghdr msg;
    23.     struct	iovec io[2];
    24.     struct	sockaddr_in  * client_socket = (struct sockaddr_in *) malloc (sizeof(struct sockaddr_in));
    25.     char	buf[MAXSIZE + 1]={0};
    26.     char	ip[16];
    27.     char	buf1[MAXSIZE + 1]={0};
    28.     //char	ip1[16];
    29.  
    30.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);//UDP
    31.     bzero(&serv_socket, sizeof(serv_socket));
    32.     serv_socket.sin_family		= AF_INET; //IPV4
    33.     serv_socket.sin_addr.s_addr = htonl(INADDR_ANY);//本地任意ip
    34.     serv_socket.sin_port		= htons(9888);
    35.  
    36.     bind(sockfd, (struct sockaddr *)&serv_socket, sizeof(serv_socket));
    37.  
    38.     msg.msg_name	= client_socket;
    39.     msg.msg_namelen = sizeof(struct sockaddr_in);
    40.     io[0].iov_base		= buf;
    41.     io[0].iov_len		= MAXSIZE;
    42.     io[1].iov_base		= buf1;
    43.     io[1].iov_len		= MAXSIZE;
    44.     msg.msg_iov		= io;
    45.     msg.msg_iovlen	= 2;
    46.  
    47.     ssize_t len = recvmsg(sockfd, &msg, 0);//server 在recvmsg阻塞等待客户端数据
    48.     cout<<"recvmsg len= "<
    49.     //解析数据
    50.     client_socket = (struct sockaddr_in *)msg.msg_name;
    51.     inet_ntop(AF_INET, &(client_socket->sin_addr), ip, sizeof(ip));
    52.     int port = ntohs(client_socket->sin_port);
    53.     char * temp = (char*)(msg.msg_iov[0].iov_base);
    54.     //temp[len] = '\0';
    55.     char * temp1 = (char*)(msg.msg_iov[1].iov_base);
    56.     //temp1[len] = '\0';
    57. //    cout<<"iov_base1 len = "<
          printf("get message from %s[%d]: %s,%s，%d\n", ip, port,temp,temp+12, msg.msg_iov[0].iov_len);
    58.  
    59.     close(sockfd);
    60.  
    61.     return 0;
    62. }

    sendmsg客户端用例

    1. #include "stdio.h"
    2. #include "stdlib.h"
    3. #include "string.h"
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. using namespace std;
    11. #define MAXSIZE 100
    12.  
    13. int main(int argc, char ** argv)
    14. {
    15.     int		sockfd;
    16.     struct	sockaddr_in serv_socket;
    17.     struct	msghdr msg;
    18.     struct	iovec io[2];
    19.     char	send[] = "hello world";
    20.     char send1[] = "nihaod  dlsdjfsddjsjdfjsdjfjsjdfjsjddfjsjdjfsdjkfkdks";
    21.     cout<<"bufsize = "<< strlen(send)+strlen(send1)<
    22.  
    23.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);//UDP
    24.     bzero(&serv_socket, sizeof(serv_socket));
    25.     serv_socket.sin_family	= AF_INET;//ipv4
    26.     serv_socket.sin_port	= htons(9888);
    27.     inet_pton(AF_INET, "192.168.0.149", &serv_socket.sin_addr);//服务器IP
    28.  
    29.     msg.msg_name	= &serv_socket;
    30.     msg.msg_namelen = sizeof(struct sockaddr_in);
    31.     io[0].iov_base		= send;//"hello world"
    32.     io[0].iov_len		= sizeof(send);
    33.     io[1].iov_base		= send1;
    34.     io[1].iov_len		= sizeof(send1);
    35.     msg.msg_iov		= io;
    36.     msg.msg_iovlen	= 2;
    37.     msg.msg_control = NULL;
    38.     msg.msg_controllen = 0;
    39.     msg.msg_flags = 0;
    40.  
    41.     ssize_t send_size = sendmsg(sockfd, &msg, 0);//发送数据到服务器
    42.     cout<<"send_size = "<"  "<< sockfd << "  errno = "<
    43.     close(sockfd);
    44.  
    45.     return 0;
    46. }

    send客户端用例

    1. #include "stdio.h"
    2. #include "stdlib.h"
    3. #include "string.h"
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. using namespace std;
    11. int main(int argc, char *argv[])
    12. {
    13.     int		sockfd;
    14.     struct	sockaddr_in serv_socket;
    15.     char	send1[] = "djsdjjsdfjsldjfjsdjfjsdjfjccjkjdsiejiocuaishfsaudfashdfhahsddifskdhvakjshdfhskdjfhkshdjfhkjasdhfhkjhakjhkfjhdfjhashdf";
    16.  
    17.     cout<<"send1 size = "<<sizeof(send1)<
    18.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);//UDP
    19.     bzero(&serv_socket, sizeof(serv_socket));
    20.     serv_socket.sin_family	= AF_INET;//ipv4
    21.     serv_socket.sin_port	= htons(9888);
    22.     inet_pton(AF_INET, "192.168.0.149", &serv_socket.sin_addr);//服务器IP
    23.  
    24.     connect(sockfd, (struct sockaddr*)&serv_socket, sizeof(serv_socket));
    25.     ssize_t send_size = send(sockfd, send1, sizeof(send1),0);//发送数据到服务器
    26.     cout<<"send_size = "<"  "<< sockfd << "  errno = "<
    27.  
    28.     close(sockfd);
    29.  
    30.     return 0;
    31. }

    通过上面的三个用例进行测试得到如下结论：

    • 发送方调用send接口发送一个缓冲区的数据，接收方调用recvmsg接口也可以接收，并不是recvmsg只能对应sendmsg接口。但是需要注意的是假设recvmsg接口设置了三个缓冲区接收，第一个缓冲区长度为40，第二个缓冲区长度为40，第三个缓冲区的长度为40，那么发送方调用send接口发送长度为100字节的数据，接收方通过调用recvmsg接收到数据后首先将第一个缓冲区的40字节缓冲区占满，第一个缓冲区被占满后，继续填写第二个缓冲区，第二个缓冲区也占满后，总共收到80个字节，所以剩余的20个字节会填写到第三个缓冲区，故第三个缓冲区剩余20个字节；如果发送方调用send接口进行传输，传输的数据长度小于接收方第一个缓冲区的长度，则只占用第一个缓冲区；如果send发送的数据长度，并且是采用udp协议无连接的方式发送超过接收方的三个缓冲区的长度，该会如何呢？
    • 如果发送方调用sendmsg发送数据，假设发送方有两个缓冲区，第一个缓冲区的长度为12，第二个缓冲区的长度为54，而接收到调用recvmsg接口接收数据，同样设置两个缓冲区，假设两个缓冲区的长度都是100，那么这里思考是发送方的两个缓冲区的数据是否会填写到接收方对应的缓冲区呢？答案是否定的，接收规则是这样的，发送方发送的第一个缓冲区的12字节的数据收到存放到接收方第一个缓冲区的前12个字节，然后接收方第一个缓冲区的长度剩余88字节，发送方第二个缓冲区的长度为54个字节，则会继续在一个缓冲区的第13个字节开始填写发送发送第二个缓冲区的数据。

    sendmsg的优势

    可以一次性发送多个缓冲区数据，减少系统调用，提供发送效率，如果使用send接口发送数据，一次只能发送一个缓冲区的数据，而系统调用会触发用户态到内核态的切换，这个是耗时的，因为要从用户内存拷贝到对应的内核缓冲区，从这个角度看可以减少系统调用，从而减少用户态和内核态的切换，达到提供效率的目的。

    readv/sendv

    待补充

  • 相关阅读:
    前端面试题大汇总
    RT-Thread 内核移植（学习）
    mysql8其它新特性
    考研数据结构大题整合_组一（ZYL组）
    RedisObject
    专用短程通讯（DSRC）技术介绍
    【MPU6050_DMP】dmp初始化校准设置，取消上电零度
    module.exports和exports，应该用哪个
    提分必练！中创教育PMP全真模拟题分享来喽
    uniapp通过url或base64打开pdf文件
  • 原文地址：https://blog.csdn.net/iqanchao/article/details/133683615