【Linux】Linux 上socket 编程

2012-09-24

【Linux】Linux 下socket 编程TCP/IP协议叫做传输控制/网际协议，又叫网络通信协议TCP/IP虽然叫传输控制协议（

【Linux】Linux 下socket 编程

TCP/IP协议叫做传输控制/网际协议，又叫网络通信协议

TCP/IP虽然叫传输控制协议（TCP）和网际协议（IP），但是实际上是一组协议，包含ICMP， RIP， TELENET， FTP， SMTP， ARP， TFTP等。

从协议分层模型方面来讲，TCP/IP由四个层次组成：网络接口层、网络层、传输层、应用层。

关于更多TCP/IP协议，请参考下面的百度链接：http://baike.baidu.com/view/7649.htm

TCP与UDP区别

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快

TCP和UDP都是在传输层上的。简单来说，UDP发送数据的时候是不管数据有没有真正达到目的地的，所以传输起来速度就比较快了。但是同时也容易造成数据丢失。而TCP我们知道有三次握手建立，四次握手释放，所以传输更准确，但是速度可能会相对慢一些。

为确保正确地接收数据，TCP要求在目标计算机成功收到数据时发回一个确认（即ACK）。如果在某个时限内未收到相应的ACK，将重新传送数据包。如果网络拥塞，这种重新传送将导致发送的数据包重复。但是，接收计算机可使用数据包的序号来确定它是否为重复数据包，并在必要时丢弃它。

socket套接字

SOCKET中首先我们要理解如下几个定义概念:

一是IP地址:IP Address我想很容易理解,就是依照TCP/IP协议分配给本地主机的网络地址,就向两个进程要通讯,任一进程要知道通讯对方的位置,位置如何来确定,就用对方的IP

二是端口号:用来标识本地通讯进程,方便OS提交数据.就是说进程指定了对方进程的网络IP,但这个IP只是用来标识进程所在的主机,如何来找到运行在这个主机的这个进程呢,就用端口号.

三是连接:指两个进程间的通讯链路.

四是半相关:网络中用一个三元组可以在全局唯一标志一个进程：

（协议，本地地址，本地端口号）

这样一个三元组，叫做一个半相关,它指定连接的每半部分。

五是全相关

一个完整的网间进程通信需要由两个进程组成，并且只能使用同一种高层协议。也就是说，不可能通信的一端用TCP协议，而另一端用UDP协议。因此一个完整的网间通信需要一个五元组来标识：

（协议，本地地址，本地端口号，远地地址，远地端口号）

这样一个五元组，叫做一个相关（association），即两个协议相同的半相关才能组合成一个合适的相关，或完全指定组成一连接。

客户/服务器模式
在TCP/IP网络应用中，通信的两个进程间相互作用的主要模式是客户/服务器模式（Client/Server model），即客户向服务器发出服务请求，服务器接收到请求后，提供相应的服务。客户/服务器模式的建立基于以下两点：首先，建立网络的起因是网络中软硬件资源、运算能力和信息不均等，需要共享，从而造就拥有众多资源的主机提供服务，资源较少的客户请求服务这一非对等作用。其次，网间进程通信完全是异步的，相互通信的进程间既不存在父子关系，又不共享内存缓冲区，因此需要一种机制为希望通信的进程间建立联系，为二者的数据交换提供同步，这就是基涌纪纪户/服务器模式的TCP/IP。

套接口可以说是网络编程中一个非常重要的概念，linux以文件的形式实现套接口，与套接口相应的文件属于要sockfs特殊文件系统，创建一个套接口就是在sockfs中创建一个特殊文件，并建立起为实现套接口功能的相关数据结构。换句话说，对每一个新创建的BSD套接口，linux内核都将在sockfs特殊文件系统中创建一个新的inode。描述套接口的数据结构是socket，将在后面给出。

(一)重要数据结构

下面是在网络编程中比较重要的几个数据结构，读者可以在后面介绍编程API部分再回过头来了解它们。

（1）表示套接口的数据结构structsocket

套接口是由socket数据结构代表的，形式如下：

struct socket

{

socket_state state; /*指明套接口的连接状态，一个套接口的连接状态可以有以下几种:套接口是空闲的，还没有进行相应的端口及地址的绑定；还没有连接；正在连接中；已经连接；正在解除连接。*/

unsignedlong flags;

structproto_ops ops; /*指明可对套接口进行的各种操作*/

structinode inode; /*指向sockfs文件系统中的相应inode*/

structfasync_struct *fasync_list; /* Asynchronous wake up list */

structfile *file; /*指向sockfs文件系统中的相应文件 */

structsock sk; /*任何协议族都有其特定的套接口特性，该域就指向特定协议族的套接口对象。*/

wait_queue_head_t wait;

short type;

unsignedchar passcred;

};

（2）描述套接口通用地址的数据结构struct sockaddr

由于历史的缘故，在bind、connect等系统调用中，特定于协议的套接口地址结构指针都要强制转换成该通用的套接口地址结构指针。结构形式如下：

struct sockaddr {

sa_family_t sa_family; /*address family, AF_xxx */

char sa_data[14]; /*14 bytes of protocol address */

};

（3）描述因特网地址结构的数据结构struct sockaddr_in（这里局限于IP4）：

struct sockaddr_in

{

__SOCKADDR_COMMON(sin_); /*描述协议族*/

in_port_tsin_port; /*端口号*/

structin_addr sin_addr; /*因特网地址*/

/*Pad to size of `struct sockaddr'. */

unsignedchar sin_zero[sizeof (struct sockaddr)-__SOCKADDR_COMMON_SIZE -sizeof (in_port_t) -sizeof (struct in_addr)];

};

（二）基本的socket接口函数。

3.1、socket()函数int socket(int domain, int type, int protocol);

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。
注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。
当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。
3.2、bind()函数
正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
函数的三个参数分别为：
- sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
- addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是：
  struct sockaddr_in { sa_family_t sin_family; /* address family: AF_INET */ in_port_t sin_port; /* port in network byte order */ struct in_addr sin_addr; /* internet address */ }; /* Internet address. */ struct in_addr { uint32_t s_addr; /* address in network byte order */ };ipv6对应的是：
  struct sockaddr_in6 { sa_family_t sin6_family; /* AF_INET6 */ in_port_t sin6_port; /* port number */uint32_t sin6_flowinfo; /* IPv6 flow information */ struct in6_addr sin6_addr; /* IPv6 address */ uint32_tsin6_scope_id; /* Scope ID (new in 2.4) */ }; struct in6_addr { unsigned char s6_addr[16]; /* IPv6 address */};Unix域对应的是：
  #define UNIX_PATH_MAX 108 struct sockaddr_un { sa_family_t sun_family; /* AF_UNIX */ charsun_path[UNIX_PATH_MAX]; /* pathname */ };
- addrlen：对应的是地址的长度。
  通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。
  网络字节序与主机字节序
  主机字节序就是我们平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序，这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下：
  　　a) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
  　　b) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
  网络字节序：4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序，一个字节的数据没有顺序的问题了。
  所以：在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案！公司项目代码中由于存在这个问题，导致了很多莫名其妙的问题，所以请谨记对主机字节序不要做任何假定，务必将其转化为网络字节序再赋给socket。
  3.3、listen()、connect()函数
  如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。
  int listen(int sockfd, int backlog); int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
  listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。
  connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。
  3.4、accept()函数
  TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。
  int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。
  注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。
  3.5、read()、write()等函数
  万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：
  - read()/write()
  - recv()/send()
  - readv()/writev()
  - recvmsg()/sendmsg()
  - recvfrom()/sendto()
    我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：
    1. #include <unistd.h>
    3. ssize_t read(int fd, void *buf, size_t count);
    4. ssize_t write(int fd, const void *buf, size_t count);
    6. #include <sys/types.h>
    7. #include <sys/socket.h>
    9. ssize_t send(int sockfd, const void *buf, size_t len, int flags);
    10. ssize_t recv(int sockfd, void *buf, size_t len, int flags);
    12. ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
    13. const struct sockaddr *dest_addr, socklen_t addrlen);
    14. ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
    15. struct sockaddr *src_addr, socklen_t *addrlen);
    17. ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
    18. ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
    read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。
    write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。
    其它的我就不一一介绍这几对I/O函数了，具体参见man文档或者baidu、Google，下面的例子中将使用到send/recv。
    3.6、close()函数
    在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。
    #include <unistd.h> int close(int fd);
    close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。
    注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。
    下面是TCP的一个例子，分别是服务器端（server.c）和客户端（client.c）
    1. //TCP:server.c
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4. #include<string.h>
    5. #include<errno.h>
    6. #include<sys/types.h>
    7. #include<sys/socket.h>
    8. #include<netinet/in.h>
    10. #define MAXLINE 4096
    12. int main(int argc, char** argv)
    13. {
    14. int listenfd, connfd;
    15. struct sockaddr_in servaddr;
    16. char buff[4096];
    17. int n;
    19. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
    20. printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
    21. exit(0);
    22. }
    24. memset(&servaddr, 0, sizeof(servaddr));
    25. //协议地址
    26. servaddr.sin_family = AF_INET;//IPV4
    27. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//change to network byte oder
    28. servaddr.sin_port = htons(6666);//port no.
    29. //bind把一个地址族中的特定地址赋给socket
    30. if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
    31. printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
    32. exit(0);
    33. }
    35. if( listen(listenfd, 10) == -1){
    36. //listen 监听
    37. printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
    38. exit(0);
    39. }
    41. printf("======waiting for client's request======\n");
    42. while(1){
    43. if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
    44. printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
    45. continue;
    46. }
    47. n = recv(connfd, buff, MAXLINE, 0);
    48. buff[n] = '\0';
    49. printf("recv msg from client: %s\n", buff);
    50. close(connfd);
    51. }
    53. close(listenfd);
    54. }
    1. //TCP:client.c
    2. #include<stdio.h>
    3. #include<stdlib.h>
    4. #include<string.h>
    5. #include<errno.h>
    6. #include<sys/types.h>
    7. #include<sys/socket.h>
    8. #include<netinet/in.h>
    10. #define MAXLINE 4096
    12. int main(int argc, char** argv)
    13. {
    14. int sockfd, n;
    15. char recvline[4096], sendline[4096];
    16. struct sockaddr_in servaddr;
    18. if( argc != 2){
    19. printf("usage: ./client <ipaddress>\n");
    20. exit(0);
    21. }
    23. if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
    24. // 创建套接字描述符给sockfd
    25. printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);
    26. exit(0);
    27. }
    29. memset(&servaddr, 0, sizeof(servaddr));
    30. //结构体清零
    31. servaddr.sin_family = AF_INET;
    32. servaddr.sin_port = htons(6666);//端口号
    33. if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
    34. //Linux下IP地址转换函数，可以在将IP地址在“点分十进制”和“整数”之间转换
    35. printf("inet_pton error for %s\n",argv[1]);
    36. exit(0);
    37. }
    39. if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
    40. //连接请求
    41. printf("connect error: %s(errno: %d)\n",strerror(errno),errno);
    42. }
    44. printf("send msg to server: \n");
    45. fgets(sendline, 4096, stdin);
    46. if( send(sockfd, sendline, strlen(sendline), 0) < 0)
    47. {
    48. printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
    49. exit(0);
    50. }
    52. close(sockfd);
    53. exit(0);
    54. }
    我们可以用ifconfig命令来查看我们本机的ip地址
    接下来看UDP的一个例子，分别是服务器端（server.c）和客户端（client.c）
    1. //UDP:server.c
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <string.h>
    5. #include <sys/socket.h>
    6. #include <netinet/in.h>
    7. #include <arpa/inet.h>
    8. #include <netdb.h>
    9. #include <errno.h>
    10. #include <sys/types.h>
    12. int port = 8888;
    14. int main()
    15. {
    16. int sockfd;
    17. int len;
    18. int z;
    19. char buf[255];
    20. struct sockaddr_in adr_inet;
    21. struct sockaddr_in adr_clnt;
    22. printf("等待客户端...\n");
    23. //建立IP地址
    25. adr_inet.sin_family = AF_INET;
    26. adr_inet.sin_port = htons(port);
    27. adr_inet.sin_addr.s_addr = htonl(INADDR_ANY);
    28. bzero(&(adr_inet.sin_zero),8);
    29. len = sizeof(adr_clnt);
    30. //建立socket
    31. sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    32. if (sockfd == -1)
    33. {
    34. perror("socket 出错");
    35. exit(1);
    36. }
    38. //bind socket
    39. z = bind (sockfd, (struct sockaddr *) &adr_inet, sizeof (adr_inet));
    40. if (z == -1)
    41. {
    42. perror("bind出错");
    43. exit(1);
    44. }
    45. while(1)
    46. {
    47. z = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_clnt, &len);
    48. if (z < 0)
    49. {
    50. perror("recvfrom 出错");
    51. exit(1);
    52. }
    53. buf[z] = 0;
    54. printf("接收:%s",buf);
    56. if (strncmp(buf, "stop", 4) == 0)
    57. {
    58. printf("结束..\n");
    59. break;
    60. }
    61. }
    62. close(sockfd);
    63. exit(0);
    64. }
    1. //UDP:client.c
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #include <string.h>
    5. #include <sys/socket.h>
    6. #include <netinet/in.h>
    7. #include <arpa/inet.h>
    8. #include <netdb.h>
    9. #include <errno.h>
    10. #include <sys/types.h>
    12. int port = 8888;
    13. int main()
    14. {
    15. int sockfd;
    16. int i = 0;
    17. int z;
    18. char buf[80], str1[80];
    19. struct sockaddr_in adr_srvr;
    20. FILE *fp;
    21. printf("打开文件...\n");
    23. fp = fopen ("liu", "r");
    24. if (fp == NULL)
    25. {
    26. perror("打开文件失败\n");
    27. exit(1);
    28. }
    29. printf("连接服务端...\n");
    30. adr_srvr.sin_family = AF_INET;
    31. adr_srvr.sin_port = htons(port);
    32. adr_srvr.sin_addr.s_addr = htonl(INADDR_ANY);
    33. bzero(&(adr_srvr.sin_zero), 8);
    34. sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    35. if (sockfd == -1)
    36. {
    37. perror("socket 出错");
    38. exit(1);
    39. }
    40. printf("发送文件.....\n");
    42. for (i=0; i<3; i++)
    43. {
    44. fgets(str1,80,fp);
    45. printf("%d:%s",i, str1);
    46. sprintf(buf, "%d:%s", i, str1);
    47. z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));
    48. if (z < 0)
    49. {
    50. perror("recvfrom 出错");
    51. exit(1);
    52. }
    53. }
    54. printf("发送....\n");
    55. sprintf(buf, "stop\n");
    56. z = sendto (sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&adr_srvr, sizeof(adr_srvr));
    58. if (z < 0)
    59. {
    60. perror("sendto 出错");
    61. exit(1);
    62. }
    63. fclose(fp);
    64. close(sockfd);
    65. exit(0);
    66. }
    这里简单比较一下TCP和UDP在编程实现上的一些区别：
    1、TCP套接口
    建立一个TCP连接需要三次握手，而断开一个TCP则需要四个分节。当某个应用进程调用close(主动端)后(可以是服务器端，也可以是客户端)，这一端的TCP发送一个FIN，表示数据发送完毕；另一端(被动端)发送一个确认，当被动端待处理的应用进程都处理完毕后，发送一个FIN到主动端，并关闭套接口，主动端接收到这个FIN后再发送一个确认，到此为止这个TCP连接被断开。
    
    　　２、UDP套接口
    　　UDP套接口是无连接的、不可靠的数据报协议；既然他不可靠为什么还要用呢？其一：当应用程序使用广播或多播是只能使用UDP协议；其二：由于他是无连接的，所以速度快。因为UDP套接口是无连接的，如果一方的数据报丢失，那另一方将无限等待，解决办法是设置一个超时。
    
    　　在编写UDP套接口程序时，有几点要注意：建立套接口时socket函数的第二个参数应该是SOCK_DGRAM，说明是建立一个UDP套接口；由于UDP是无连接的，所以服务器端并不需要listen或accept函数；当UDP套接口调用connect函数时，内核只记录连接放的IP地址和端口，并立即返回给调用进程，正因为这个特性，UDP服务器程序中并不使用fock函数，用单进程就能完成所有客户的请求。
    注意以上TCP例程并不能实现多个客户端同时访问，实现多个客户端访问的方法见下篇BLOG。

热点排行