Linux 高性能服务器编程——Linux网络编程基础API

问题聚焦：

    这节介绍的不仅是网络编程的几个API

    更重要的是，探讨了Linux网络编程基础API与内核中TCP/IP协议族之间的关系。

    这节主要介绍三个方面的内容：套接字（socket地址）API，socket基础API，和网络信息API。

---

套接字API

套接字socket：(ip, port)，即IP地址和端口对，唯一地表示了使用该TCP通信的一端。

需要了解：主机字节序和网络字节序。

原因：考虑32位的机器，CPU的累加器一次装载4字节的内容。那么这4字节在内存中的顺序将影响它被累加器装载后的所代表的含义。

分类：

• 大端字节序：“高低，低高”，即，一个整数的高位字节(23~31位)存储在内存的低地址处，低位字节存储在内存的高地址处。
• 小端字节序：“高高，低低”。

主机字节序：小端字节序。

网络字节序：大端字节序。

存在的问题：并不是所有的机器都采用主机字节序。一旦收发双方的字节序不同，必然导致错误的接收。

解决方法：发送端总是把要发送的数据转化成大端字节序，再发送。

注意：即使同一台机器上的两个进程，也要考虑字节序的问题，如一个客户端使用C语言编写，而另一个采用java编写（java虚拟机使用大端字节序）。

Linux提供的转换函数：

[cpp]  view plain  copy

1. #inlcude<netinet/in.h>  
2. unsigned long int htonl( unsigned long int hostlong );  
3. unsigned short int htons( unsigned short int hostshort );  
4. unsigned long int ntohl( unsigned long int netlong );  
5. unsigned short int ntohs( unsigned short int netshort );  

通用socket地址（结构体）

[cpp]  view plain  copy

1. #include <bits/socket.h>  
2. struct sockaddr  
3. {  
4.     sa_family_t sa_family;  
5.     char sa_data[14];  
6. }  

sa_family_da：地址族类型，与协议族类型对应。取值和对应关系如下图所示：

sa_data(char)：存放socket地址。

协议族及其地址值：

数组长度有限，所以Linux提供了下面的新的 通用socket地址结构体。

[cpp]  view plain  copy

1. #include <bits/socket.h>  
2. struct sockaddr_storage  
3. {  
4.     sa_family_t sa_family;  
5.     unsigned long int __ssalign;  
6.     char __ss_padding[128-sizeof(__ss__align)];  
7. }  

__ss__align成员的作用：内存对齐。

专用socket地址

既然有通用socket地址，那么自然就有专用的socket地址。

专用：针对各个协议族的。

分类：

• UNIX本地域协议族专用socket地址

[cpp]  view plain  copy

1. #inlcude<sys/un.h>  
2. struct sockaddr_un  
3. {  
4.     sa_family_t sin_family;            /* 地址族：AF_UNIX  */  
5.     char sun_path[108];               /* 文件路径名 */  
6. };  

• IPv4专用socket地址

[cpp]  view plain  copy

1. #inlcude<sys/un.h>  
2. struct sockaddr_in  
3. {  
4.     sa_family_t sin_family;            /* 地址族：AF_INET  */  
5.     u_int16_t sin_port;  
6.     struct int_addr sin_addr;               /* 文件路径名 */  
7. };  
8. struct in_addr  
9. {  
10.     u_int32_t s_addr;  
11. };  

• IPv6专用socket地址

[cpp]  view plain  copy

1. #inlcude<sys/un.h>  
2. struct sockaddr_in6  
3. {  
4.     sa_family_t sin6_family;                /* 地址族：AF_INET6*/  
5.     u_int16_t sin_port;                        /* 端口号，要用网络字节序表示 */  
6.     u_int32_t sin6_flowinfo;                /* 流信息，应设置为0  */  
7.     struct int6_addr sin6_addr;           /* IPv6地址结构体 */  
8.     u_int32_t sin6_scope_id;               / * scope Id.，尚处于试验阶段  */  
9. };  
10. struct in_addr  
11. {  
12.     unsigned char sa_addr[16];     /* IPv6地址，要用网络字节序表示  */  
13. };  

       虽然Linux给我们提供了专用的socket地址。 但是，在实际使用时，都要强制转换为通用socket地址类型， 因为所有socket编程接口使用的地址参数的类型都是sockaddr。

IP地址转换函数

[cpp]  view plain  copy

1. #include<arpa/inet.h>  
2. in_addr_t inet_addr( const char* strptr );        /* 点分十进制字符串表示的IPv4地址转化为用网络字节序整数表示的IPv4地址。失败时返回INADDR_NONE */  
3. int inet_aton( const char* cp, struct in_addr* inp );        /* 完成和in_addr_t同样的功能，但是将转化结果存储于参数inp指向的地址结构中。 成功时返回1， 失败时返回0 */  
4. char* inet_ntoa( struct in_addr in );        /* inet_ntoa函数将网络字节序整数表示的IPv4地址转化为用点分十进制字符串表示的IPv4地址 */  

有一点需要注意，看下面的代码

[cpp]  view plain  copy

1. char* szValue1 = inet_ntoa( "1.2.3.4" );  
2. char* szValue2 = inet_ntoa( "10.194.71.60" );  
3. printf( "address 1: %s\n", szValue1 );  
4. printf( "address 2: %s\n", szValue2 );  
5.   
6. //打印结果  
7. address1: 10.194.71.60  
8. address2: 10.194.71.60  

原因： inet_ntoa是不可重入的。因为该函数内部用一个固定的静态变量存储结果，函数的返回值指向该内存。每次调用，都是写入相同的静态内存区，所以不可以多次计算。

同时适用于IPv4和IPv6地址的转换函数

[cpp]  view plain  copy

1. #include <arpa/inet.h>  
2. int inet_pton(int af, const char* src, void* dst);  
3. const char* inet_ntop( int af, const void* src, char* dst, socklen, cnt);  

函数说明：

inet_pton函数将用字符串表示的IP地址stc（用点分十进制表示的IPv4地址或用十六进制字符串表示的IPv6地址）转换成用网络字节序整数表示的IP地址，并把转换结果可存储与dst指向的内存中。

af: 指定地址族，可以是AF_INET或AF_INET6

inet_pton成功返回1，失败返回0并设置errno

inet_ntop函数进行相反的转换，前三个参数含义与inet_pton的参数相同，最后一个参数cnt指定目标存储单元的大小。

下面的两个宏能帮助我们指定这个大小

[cpp]  view plain  copy

1. #include <netinet/in.h>  
2. #define INET_ADDRSTRLEN 16  
3. #define INET6_ADDRSTRLEN 46  

inet_ntop成功时返回目标存储单元的地址，失败则返回NULL并设置errno。 

---

创建socket

UNIX/Linux的一个哲学是：所有东西都是文件。socket也不例外，它就是可读、可写、可控制、可关闭的文件描述符。

创建一个socket

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. int scoket( int domain, int type, int protocol );  

函数说明：

domain: 告诉系统使用哪个底层协议。对TCP/IP 协议族而言，该参数应该设置为PF_INET（用于IPv4）或PF_INET6（用于IPv6）; 对于UNIX本地域协议族而言，该参数应该设置为PF_UNIX 。 

type: 指定服务类型。服务类型主要有SOCK_STREAM服务（流服务，使用TCP协议）和SOCK_UGRAM（数据报，使用UDP协议）服务。对于TCP/IP协议族而言，其值取SOCK_STREAM（TCP协议）、SOCK_DGRAM（UDP协议）。

         还可以接受两个标志：SOCK_NONBLOCK（将新创建的socket设为非阻塞）和SOCK_CLOEXEC（用fork调用创建子进程时在子进程中关闭该socket）

protocol：在前两个参数构成的协议集合下，再选择一个具体的协议。几乎所有情况，把它设置为0.

成功时返回socket文件描述符，失败则返回-1并设置errno。

---

绑定socket

绑定：将一个上面创建的socket与一个具体的socket地址绑定

只有绑定了socket之后，客户端才能知道该如何连接它。

调用：bind

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. int bind( int sockfd, const struct sockaddr* my_addr, socklen_t addrlen );  

函数说明：

将my_addr所指的socket地址分配给未命名的sockfd文件描述符

addrlen：指出该socket地址的长度

成功时返回0，失败时返回-1并设置errno

其中两种常见的errno是EACCES 和 EADDRINUSE，它们的含义分别是：

• EACCES ： 被绑定的地址是受保护的地址，仅超级用户能够访问。比如普通用户将socket绑定到知名服务器端口（端口号为 0~1023）上时，bind将返回EACCES 错误。
• EADDRINUSE：被绑定的地址正在使用中。比如讲socket绑定到一个处于TIME_WAIT状态的socket地址。

---

监听socket

监听：socket绑定后依然不能马上接受客户连接，我们需要创建一个监听队列以存放待处理的客户连接。

调用：listen

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. int listen( int sockfd, int backlog );  

函数说明：

sockfd：被监听的socket

backlog：提示内核监听队列的最大长度。监听队列的长度如果超过backlog，服务器将不受理新的客户连接，客户端也将收到ECONNREFUSED 错误信息。在内核版本2.2之前的linux中，backlog参数是指所有处于半连接状态（SYN_RCVD）和完全连接状态（ESTABLISHED）的socket的上限，在内核版本2.2之后，它表示处于完全连接状态的socket的上限，处于半连接状态的socket的上限则由/proc/sys/net/ipv4/tcp_max_syn_backlog 内核参数定义。backlog典型值是5，通常监听队列中完整连接的上限通常币backlog值略大。

成功时返回0，失败时返回-1并设置errno。

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. #include <netinet/in.h>  
3. #include <arpa/inet.h>  
4. #include <signal.h>  
5. #include <unistd.h>  
6. #include <stdlib.h>  
7. #include <assert.h>  
8. #include <stdio.h>  
9. #include <string.h>  
10.   
11. static int stop = 0;  
12. static void handle_term( int sig )  
13. {  
14.     stop = 1;  
15. }  
16.   
17. int main( int argc, char* argv[] )  
18. {  
19.     signal( SIGTERM, handle_term );  
20.   
21.     if( argc <= 3 )  
22.     {  
23.         printf( "usage: %s ip_address port_number backlog\n", basename( argv[0] ) );  
24.         return 1;  
25.     }  
26.     const char* ip = argv[1];  
27.     int port = atoi( argv[2] );  
28.     int backlog = atoi( argv[3] );  
29.   
30.     int sock = socket( PF_INET, SOCK_STREAM, 0 );  
31.     assert( sock >= 0 );  
32.   
33.     struct sockaddr_in address;  
34.     bzero( &address, sizeof( address ) );  
35.     address.sin_family = AF_INET;  
36.     inet_pton( AF_INET, ip, &address.sin_addr );  
37.     address.sin_port = htons( port );  
38.   
39.     int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );  
40.     assert( ret != -1 );  
41.   
42.     ret = listen( sock, backlog );  
43.     assert( ret != -1 );  
44.   
45.     while ( ! stop )  
46.     {  
47.         sleep( 1 );  
48.     }  
49.   
50.     close( sock );  
51.     return 0;  
52. }  

运行：

[cpp]  view plain  copy

1. #./telnetlisten 10.8.56.206 12345 5  //监听12345端口 backlog取值为5  
2. #telnet 10.8.56.206 12345 //运行10次  
3. #netstat -nt | grep 12345  

          

发现处于ESTABLISHED 状态的连接有6个（backlog加1 ），其它的4个连接处于SYN_RCVD 状态。  最终发现完全连接最多有（backlog +1 ）个，在不同的系统下，运行结果可能有区别，不过监听队列中完全连接的上限通常比backlog值略大。

---

接受连接

调用：accept

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. int accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen );  

作用：从listen监听队列中取出一个连接。服务器可以通过读写该socket来与被接受连接对应的客户端通信。

函数说明：

sockfd：处于监听状态的socket。

addr：用来获取被接受连接的远端socket地址。

addrlen：该socket地址的长度由addrlen指定。

成功返回0，失败返回-1并设置errno。

现在考虑如下情况：如果监听队列中处于ESTABLISHED 状态的连接对应的客户端出现网络异常（比如掉线），或者提前退出，那么服务器对这个连接执行的accept调用是否成功？

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. #include <netinet/in.h>  
3. #include <arpa/inet.h>  
4. #include <assert.h>  
5. #include <stdio.h>  
6. #include <unistd.h>  
7. #include <stdlib.h>  
8. #include <errno.h>  
9. #include <string.h>  
10.   
11. int main( int argc, char* argv[] )  
12. {  
13.     if( argc <= 2 )  
14.     {  
15.         printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );  
16.         return 1;  
17.     }  
18.     const char* ip = argv[1];  
19.     int port = atoi( argv[2] );  
20.   
21.     struct sockaddr_in address;  
22.     bzero( &address, sizeof( address ) );  
23.     address.sin_family = AF_INET;  
24.     inet_pton( AF_INET, ip, &address.sin_addr );  
25.     address.sin_port = htons( port );  
26.   
27.     int sock = socket( PF_INET, SOCK_STREAM, 0 );  
28.     assert( sock >= 0 );  
29.   
30.     int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );  
31.     assert( ret != -1 );  
32.   
33.     ret = listen( sock, 5 );  
34.     assert( ret != -1 );  
35.     // 暂停20s 以等待客户端连接和相关操作（掉线或者退出）完成  
36.     sleep(20);  
37.     struct sockaddr_in client;  
38.     socklen_t client_addrlength = sizeof( client );  
39.     int connfd = accept( sock, ( struct sockaddr* )&client, &client_addrlength );  
40.     if ( connfd < 0 )  
41.     {  
42.         printf( "errno is: %d\n", errno );  
43.     }  
44.     else  
45.     {  
46.         char remote[INET_ADDRSTRLEN ];  
47.         printf( "connected with ip: %s and port: %d\n",   
48.             inet_ntop( AF_INET, &client.sin_addr, remote, INET_ADDRSTRLEN ), ntohs( client.sin_port ) );  
49.         close( connfd );  
50.     }  
51.   
52.     close( sock );  
53.     return 0;  
54. }  

具体操作如下：

[cpp]  view plain  copy

1. #./accept 10.8.56.206 12345  
2. #telnet 10.8.56.206 12345  

在启动telnet客户端程序后，在20s内关闭telnet 客户端。结果发现accept调用能够正常返回，服务器输出如下：

[cpp]  view plain  copy

1. [root@vm MOTO]# ./accept 10.8.56.206 12345  
2. connected with ip: 10.8.56.201 and port: 1313  

由此可见，accept 只是从监听队列中取出连接，而不论连接处于何种状态（如上图CLOSE_WAIT状态或者或者ESTABLISHED状态（断开telent客户端与服务器的网络，服务器该连接的状态）），更不关心任何网络状态的变化。

---

发起连接

调用：connect

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. int connect( int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen );  

函数说明：

sockfd：由socket调用返回一个socket

serv_addr：服务器监听的socket地址

addrlen：指定这个地址的长度

成功时返回0，失败则返回-并设置errno

其中两种常见的errno是ECONNREFUSED和ETIMEDOUT，它们的含义如下：

• ECONNREFUSED：目标端口不存在，连接被拒绝。
• ETIMEDOUT：连接超时。

---

关闭连接

关闭：close

[cpp]  view plain  copy

1. #include <unist.h>  
2. int close ( int fd );  

函数说明：

fd：待关闭的socket。

注意：

close系统调用并非立即关闭一个连接，而是将fd的引用计数减1，只有当fd的引用计数为0时，才真正关闭连接。

多进程程序中，一次fork调用默认使父进程中打开的socket的引用计数加1，因此我们必须在父进程和子进程两种都对该socket执行close调用才能将该连接关闭。

为了避免上面的麻烦，对于无论如何都要 立即关闭连接，可以使用下面的调用：、

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. int shutdown ( int sockfd, int howto );  

函数说明

sockfd：等待关闭的socket

howto：决定了shutdown的行为。可选值如下表：

    

---

数据读写

用于TCP流数据读写的调用：

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. ssize_t recv ( int sockfd, void *buf, size_t len, int flags );  
4. ssize_t send ( int sockfd, const void *buf, size_t len, int flags );  

函数说明：

recv读取sockfd上的数据，buf和len参数分别指定读缓冲区的位置和大小，flags一般设置为0。返回0说明连接关闭，返回-1出错并设置errno。 recv可能返回0，这意味着通信对方已经关闭连接了。

send往sockfd上写入数据，buf和len参数分别指定写缓冲区的位置和大小。成功时返回实际写入的数据的长度，失败则返回-1并设置errno。

           

MSG_OOB选项给应用程序提供了发送和接收带外数据的方法：

发送方：

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. #include <netinet/in.h>  
3. #include <arpa/inet.h>  
4. #include <assert.h>  
5. #include <stdio.h>  
6. #include <unistd.h>  
7. #include <string.h>  
8. #include <stdlib.h>  
9.   
10. int main( int argc, char* argv[] )  
11. {  
12.     if( argc <= 2 )  
13.     {  
14.         printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );  
15.         return 1;  
16.     }  
17.     const char* ip = argv[1];  
18.     int port = atoi( argv[2] );  
19.   
20.     struct sockaddr_in server_address;  
21.     bzero( &server_address, sizeof( server_address ) );  
22.     server_address.sin_family = AF_INET;  
23.     inet_pton( AF_INET, ip, &server_address.sin_addr );  
24.     server_address.sin_port = htons( port );  
25.   
26.     int sockfd = socket( PF_INET, SOCK_STREAM, 0 );  
27.     assert( sockfd >= 0 );  
28.     if ( connect( sockfd, ( struct sockaddr* )&server_address, sizeof( server_address ) ) < 0 )  
29.     {  
30.         printf( "connection failed\n" );  
31.     }  
32.     else  
33.     {  
34.         printf( "send oob data out\n" );  
35.         const char* oob_data = "abc";  
36.         const char* normal_data = "123";  
37.         send( sockfd, normal_data, strlen( normal_data ), 0 );  
38.         send( sockfd, oob_data, strlen( oob_data ), MSG_OOB );  
39.         send( sockfd, normal_data, strlen( normal_data ), 0 );  
40.     }  
41.   
42.     close( sockfd );  
43.     return 0;  
44. }  

接收方：

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. #include <netinet/in.h>  
3. #include <arpa/inet.h>  
4. #include <assert.h>  
5. #include <stdio.h>  
6. #include <unistd.h>  
7. #include <stdlib.h>  
8. #include <errno.h>  
9. #include <string.h>  
10.   
11. #define BUF_SIZE 1024  
12.   
13. int main( int argc, char* argv[] )  
14. {  
15.     if( argc <= 2 )  
16.     {  
17.         printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );  
18.         return 1;  
19.     }  
20.     const char* ip = argv[1];  
21.     int port = atoi( argv[2] );  
22.   
23.     struct sockaddr_in address;  
24.     bzero( &address, sizeof( address ) );  
25.     address.sin_family = AF_INET;  
26.     inet_pton( AF_INET, ip, &address.sin_addr );  
27.     address.sin_port = htons( port );  
28.   
29.     int sock = socket( PF_INET, SOCK_STREAM, 0 );  
30.     assert( sock >= 0 );  
31.   
32.     int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );  
33.     assert( ret != -1 );  
34.   
35.     ret = listen( sock, 5 );  
36.     assert( ret != -1 );  
37.   
38.     struct sockaddr_in client;  
39.     socklen_t client_addrlength = sizeof( client );  
40.     int connfd = accept( sock, ( struct sockaddr* )&client, &client_addrlength );  
41.     if ( connfd < 0 )  
42.     {  
43.         printf( "errno is: %d\n", errno );  
44.     }  
45.     else  
46.     {  
47.         char buffer[ BUF_SIZE ];  
48.   
49.         memset( buffer, '\0', BUF_SIZE );  
50.         ret = recv( connfd, buffer, BUF_SIZE-1, 0 );  
51.         printf( "got %d bytes of normal data '%s'\n", ret, buffer );  
52.   
53.         memset( buffer, '\0', BUF_SIZE );  
54.         ret = recv( connfd, buffer, BUF_SIZE-1, MSG_OOB );  
55.         printf( "got %d bytes of oob data '%s'\n", ret, buffer );  
56.   
57.         memset( buffer, '\0', BUF_SIZE );  
58.         ret = recv( connfd, buffer, BUF_SIZE-1, 0 );  
59.         printf( "got %d bytes of normal data '%s'\n", ret, buffer );  
60.   
61.         close( connfd );  
62.     }  
63.   
64.     close( sock );  
65.     return 0;  
66. }  

接收方两种结果：

[cpp]  view plain  copy

1. [root@vm MOTO]# ./recv 10.8.56.206 12345  
2. got 5 bytes of normal data '123ab'  
3. got 1 bytes of oob data 'c'  
4. got 3 bytes of normal data '123'  

由此可见客户端给服务器的3字节的带外数据“abc"中，仅有最后一个字符"c"被服务器当成了真正的带外数据接收，并且，服务器对正常数据的接收将被带外数据截断，即前一部分正常数据"123ab"和后续的正常数据"123"是不能被一个recv调用全部读取的。

或者：

[cpp]  view plain  copy

1. [root@vm MOTO]# ./recv 10.8.56.206 12345  
2. got 3 bytes of normal data '123'  
3. got -1 bytes of oob data ''  
4. got 2 bytes of normal data 'ab'  

客户端发送的"123"到服务器的接收缓冲区，立马被服务器读走，然后客户端发送的带外数据"abc"到服务器的接收缓冲区，当服务器调用recv( connfd, buffer, BUF_SIZE-1,  MSG_OOB );时失败，因为第一个字符不是带外数据，而是字符"a"，真正的带外数据是"c"。服务器接着读走了"ab"字符后关闭了连接，但是发送的不是结束报文段，发送的是复位报文段，即如果 recv( connfd, buffer, BUF_SIZE-1,  MSG_OOB  );失败时，最后发送的不是结束报文段，是复位报文段。

接收方结果：

[cpp]  view plain  copy

1. [root@vm MOTO]# ./send 10.8.56.206 12345  
2. send oob data out  

在实际应用中，我们通常无法预期带外数据何时到来。好在Linux内核检测到TCP紧急标志时，将通知应用程序有带外数据需要接收。内核通知应用程序带外数据到达的两种方式是：

• I/O复用产生的异常事件。
• SIGURG信号。

但是，即使应用程序得到了有带外数据需要接收的通知，还需要知道带外数据在数据流中的具体位置，才能准确接收带外数据。这点可通过如下系统调用实现：

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2.   
3. int sockatmark(int fd);  

sockatmark判断sockfd是否处于带外标记，即下一个被读到的数据是否是带外数据，如果是，sockatmark返回1，此时我们就是利用带MSG_OOB标志的recv调用来接收带外数据。如果不是，则seckatmark返回0。

用于UDP数据报的读写：

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <sys/socket.h>  
3. ssize_t recvfrom ( int sockfd, void* buf, size_t len, int flags, struct sockaddr* src_addr, socklen_t* addrlen );  
4. ssize_t sendto ( int sockfd, const void* buf, size_t len, int flags, const struct sockaddr* dest_addr, socklen_t addrlen );  

函数说明：

recvfrom读取sockfd上的数据，buf和len参数分别指定读缓冲区的位置和大小。因为UDP通信没有连接的概念，所以我们每次读取数据都需要获取发送端的socket地址，即参数src_addr所指的内容，addrlen参数则指定该地址的长度。

sendto往sockfd上写入数据，buf和len分别指定写缓冲区的位置和大小，dest_addr指定接收端的socket地址，addrlen指定该地址的长度。

通用数据读写函数：

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. ssize_t recvmsg( int sockfd, struct msghdr* msg, int flags );  
3. ssize_t sendmsg( int sockfd, struct msghdr* msg, int flags );  

函数说明：

sockfd：指定被操作的目标sockfd

msg：msghdr结构体类型的指针，定义如下：

[cpp]  view plain  copy

1.  struct msghdr  
2. {  
3.     void* msg_name;                    /* socket地址 */  
4.     socklen_t msg_namelen;        /* socktet地址的长度 */  
5.     struct iovec* msg_iov;             /* 分散的内存块 */  
6.     int msg_iovlen;                        /* 分散的内存块数量 */  
7.     void msg_control;                   /* 指向辅助数据的起始位置 */  
8.     socklen_t msg_controllen;      /* 辅助数据的大小 */  
9.     int msg_flags;                          /* 复制函数中的flags参数，并在调用过程中更新 */  
10. };  
11.   
12. struct iovec  
13. {  
14.     void *iov_base;    /* 内存起始地址 */  
15.     size_t iov_len;       /* 这块内存的长度 */  
16. };  

       由上可见，iovec结构体封装了一块内存的起始位置和长度。msg_iovlen指定这样的iovec结构对象有多少个。对于recvmsg而言，数据将被读取并存放在msg_iovlen块分散的内存中，这些内存的位置和长度则由msg_iov指向的数组指定，这称为分散读；对于sendmsg而言，msg_iovlen块分散内存中的数据将被一并发送，这称为集中写。

       recvmsg/sendmsg 的flags参数以及返回值的含义均与send/recv的flags参数及返回值相同。 

---

地址信息函数

功能：获取连接的本端socket地址，以及远端的socket地址。

函数：

[cpp]  view plain  copy

1. #include <sys/socket.h>  
2. int getsockname ( int sockfd, struct sockaddr* address, socklen_t* address_len );    /* 获取sockfd本端socket地址，并将其存储于address参数指定的内存中 */  
3. int getpeername ( int sockfd, struct sockaddr* address, socklen_t* address_len );    /* 获取sockfd对应的远端socket地址，其参数及返回值的含义与getsockname的参数及返回值相同 */  

getsockname 获取sockfd对应的本端socket地址。

getpeername 获取sockfd对应的远端socket地址。

参考资料：

《Linux高性能服务器编程》

from: http://blog.csdn.net/zs634134578/article/details/19541237