本文深入探讨了套接字编程的基础知识，包括TCP和UDP的套接字编程流程，网络函数介绍，字节序转换，IP和域名转换，以及服务器模型分析。提供了丰富的实例代码，帮助读者理解并掌握网络编程的核心概念。
目录
1.int socket(int domain, int type,int protocol)
2. int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
3.int listen(int sockfd,int backlog)
4.int accept(int sockfd, struct sockaddr *addr,int *addrlen)
5.int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)
1.ssize_t write(int fd,const void *buf,size_t nbytes)
2.ssize_t read(int fd,void *buf,size_t nbyte)
套接字概述
所谓套接字，实际上是一个指向传输提供者的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。
TCP 的套接字编程
基于 TCP 面向连接的 socket 编程的服务器端程序流程如下：
- 创建套接字
- 将创建的套接字绑定（bind）到本地地址和端口上
- 设置套接字的状态为监听状态( listen )，准备接受客户端的连接请求
- 接受请求( accept )，同时返回一个用于连接的新套接字
- 使用这个新套接字进行通信（通信函数使用 send/recv）
- 通信完毕，释放套接字资源（closesocket）
当accept函数接受一个连接时，会返回一个新的socket标识符，以后的数据传输和读取就要通过这个新的socket编号来处理，原来参数中的socket也可以继续使用，继续监听其它客户机的连接请求。（也就是说，客户请求连接服务器，服务器先做了一些绑定和监听等等操作之后，如果允许连接，则调用accept函数产生一个新的套接字，然后用这个新的套接字跟我们的客户进行收发数据。所以，服务器跟一个客户端连接成功，会有两个套接字。）
基于 TCP 面向连接的 socket 编程的客户端程序流程如下：
- 创建套接字 socket
- 向服务器发出连接请求（connect）
- 请求连接后与服务器进行通信操作（send/recv）
- 释放套接字资源（closesocket）
初等网络函数介绍
1.int socket(int domain, int type,int protocol)
domain：说明我们网络程序所在的主机采用的通讯协族(AF_UNIX和AF_INET等). AF_UNIX只能够用于单一的Unix系统进程间通信,而 AF_INET 是针对 Internet 的,因而可以允许在远程 主机之间通信(当我们 man socket 时发现 domain 可选项是 PF_*而不是AF_*,因为 glibc 是 posix 的实现 所以用 PF 代替了 AF，不过我们都可以使用的)。
type：我们网络程序所采用的通讯协议(SOCK_STREAM, SOCK_DGRAM等) SOCK_STREAM表明我们用的是TCP协议,这样会提供按顺序的,可靠,双向,面向连接的比特流. SOCK_DGRAM 表明我们用的是UDP协议,这样只会提供定长的,不可靠,无连接的通信.
protocol：由于我们指定了type,所以这个地方我们一般只要用0来代替就可以了
socket为网络通讯做基本的准备，成功时返回文件描述符,失败时返回-1,看errno可知道出错的详细情况。
2. int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
sockfd：是由socket调用返回的文件描述符.
addrlen：是sockaddr结构的长度.
my_addr：是一个指向sockaddr的指针. 在中有 sockaddr的定义
struct sockaddr{
unisgned short as_family;
char sa_data[14];
};不过由于系统的兼容性,我们一般不用这个头文件,而使用另外一个结构(struct sockaddr_in) 来代替.在中有sockaddr_in的定义
struct sockaddr_in{
unsigned short sin_family; 使用 Internet 所以 sin_family 一般为 AF_INET
unsigned short int sin_port; sin_port 是我们要监听的端口号
struct in_addr sin_addr; sin_addr 设置为 INADDR_ANY 表示可以和任何的主机通信
unsigned char sin_zero[8];} sin_zero[8]是用来填充的bind将本地的端口同socket返回的文件描述符捆绑在一起，成功是返回0,失败的情况和socket一样。
网络字节序与主机字节序
主机字节序就是我们平常说的大端和小端模式：不同的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.int listen(int sockfd,int backlog)
sockfd：是bind后的文件描述符
backlog：设置请求排队的最大长度。当有多个客户端程序和服务端相连时, 使用这个表示可以介绍的排队长度.
listen 函数将 bind 的文件描述符变为监听套接字。返回的情况和bind一样。
4.int accept(int sockfd, struct sockaddr *addr,int *addrlen)
sockfd：是listen后的文件描述符
addr, addrlen 是用来给客户端的程序填写的，服务器端只要传递指针就可以了.。
bind，listen 和 accept 是服务器端用的函数，accept调用时，服务器端的程序会一直阻塞到有一个客户程序发出了连接。accept成功时返回最后的服务器端的文件描述符，这个时候服务器端可以向该描述符写信息了。失败时返回-1。
5.int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)
sockfd：socket返回的文件描述符.
serv_addr：储存了服务器端的连接信息（由服务器端填写），其中sin_add是服务端的地址
addrlen：serv_addr的长度
connect函数是客户端用来同服务端连接的。成功时返回0，sockfd是同服务端通讯的文件描述符 失败时返回-1。
实例
/******* 服务器程序 (server.c) ************/
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<netdb.h>
#include<errno.h>
#define PORT 2345
#define MAXSIZE 1024
int main(int argc, char *argv[])
{
int sockfd, newsockfd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int portnumber;
int addr_len = sizeof(struct sockaddr_in);
/* 服务器端开始建立socket描述符 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
fprintf(stderr, "create socket failed\n");
exit(EXIT_FAILURE);
}
puts("create socket success");
printf("sockfd is %d\n", sockfd);
/* 服务器端填充 sockaddr结构 */
bzero(&server_addr, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
/* 捆绑sockfd描述符 */
if (bind(sockfd, (struct sockaddr*)(&server_addr), sizeof(struct sockaddr)) < 0)
{
fprintf(stderr, "bind failed \n");
exit(EXIT_FAILURE);
}
puts("bind success\n");
/* 监听sockfd描述符 */
if (listen(sockfd, 10) < 0)
{
perror("listen fail\n");
exit(EXIT_FAILURE);
}
puts("listen success\n");
socklen_t sin_size = sizeof(struct sockaddr_in);
printf("sin_size is %d\n", sin_size);
/* 服务器阻塞,直到客户程序建立连接 */
if ((newsockfd = accept(sockfd, (struct sockaddr *)(&client_addr), &sin_size)) < 0)
{
perror("accept error");
exit(EXIT_FAILURE);
}
printf("accepted a new connetction\n");
printf("new socket id is %d\n", newsockfd);
printf("Accept clent ip is %s\n", inet_ntoa(client_addr.sin_addr));
printf("Connect successful please input message\n");
char sendbuf[MAXSIZE];
char recvbuf[MAXSIZE];
while (1)
{
int len = recv(newsockfd, recvbuf, sizeof(recvbuf), 0);
if (strcmp(recvbuf, "exit\n") == 0)
break;
fputs(recvbuf, stdout);
strcpy(sendbuf,recvbuf);
send(newsockfd, sendbuf, len, 0);
memset(recvbuf, 0, sizeof(recvbuf));
memset(sendbuf, 0, sizeof(sendbuf));
}
close(newsockfd);
close(sockfd);
puts("exit success");
exit(EXIT_SUCCESS);
return 0;
}
/******* 客户端程序 client.c ************/
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
#include<string.h>
#include<errno.h>
#define PORT 2345
#define MAXSIZE 1024
int count = 1;
int main()
{
int sockfd;
struct sockaddr_in server_addr;
/* 客户程序开始建立 sockfd描述符 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
fprintf(stderr, "Socket Error is %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
/* 客户程序填充服务端的资料 */
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
/*客户端程序发出连接请求 */
if (connect(sockfd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr)) == -1)
{
fprintf(stderr, "Connect failed\n");
exit(EXIT_FAILURE);
}
char sendbuf[1024];
char recvbuf[2014];
while (1)
{
fgets(sendbuf, sizeof(sendbuf), stdin);
send(sockfd, sendbuf, strlen(sendbuf), 0);
if (strcmp(sendbuf, "exit\n") == 0)
break;
recv(sockfd, recvbuf, sizeof(recvbuf), 0);
fputs(recvbuf, stdout);
memset(sendbuf, 0, sizeof(sendbuf));
memset(recvbuf, 0, sizeof(recvbuf));
}
close(sockfd);
exit(EXIT_SUCCESS);
return 0;
}
服务器和客户机的信息函数
1.字节转换函数
在网络上面有着许多类型的机器,这些机器在表示数据的字节顺序是不同的, 比如i386芯片是低字节在内存地址的低端,
高字节在高端,而alpha芯片却相反. 为了统一起来,在Linux下面,有专门的字节转换函数。
unsigned long int htonl(unsigned long int hostlong)
unsigned short int htons(unisgned short int hostshort)
unsigned long int ntohl(unsigned long int netlong)
unsigned short int ntohs(unsigned short int netshort)在这四个转换函数中,h 代表host, n 代表 network.s 代表short l 代表long
第一个函数的意义是将本机器上的long数据转化为网络上的long。其他几个函数的意义也差不多。
2.IP 和域名的转换
在网络上标志一台机器可以用 IP 或者是用域名。那么我们怎么去进行转换呢?
struct hostent *gethostbyname(const char *hostname)
struct hostent *gethostbyaddr(const char *addr,int len,int type)
在中有struct hostent的定义
struct hostent{
char *h_name; /* 主机的正式名称 */
char *h_aliases; /* 主机的别名 */
int h_addrtype; /* 主机的地址类型 AF_INET*/
int h_length; /* 主机的地址长度 对于IP4 是4字节32位*/
char **h_addr_list; /* 主机的IP地址列表 */
}
#define h_addr h_addr_list[0] /* 主机的第一个IP地址*/gethostbyname 可以将机器名 (如 linux.yessun.com) 转换为一个结构指针，在这个结构里面储存了域名的信息 。
gethostbyaddr 可以将一个32位的IP地址 (C0A80001) 转换为结构指针。这两个函数失败时返回 NULL 且设置 h_errno 错误变量,调用 h_strerror() 可以得到详细的出错信息
3.字符串的 IP 和32位的 IP 转换
在网络上面我们用的IP都是数字加点(192.168.0.1)构成的, 而在struct in_addr结构中用的是32位的IP,
我们上面那个32位 IP (C0A80001) 是 192.168.0.1 为了转换我们可以使用下面两个函数int inet_aton(const char *cp,struct in_addr *inp)
char *inet_ntoa(struct in_addr in)函数里面 a 代表 ascii n 代表 network。第一个函数表示将 a.b.c.d 的 IP 转换为32位的 IP，存储在 inp指针里面。第二个是将32位 IP 转换为 a.b.c.d 的格式。
4.服务信息函数
在网络程序里面我们有时候需要知道端口，IP和服务信息，这个时候我们可以使用以下几个函数
int getsockname(int sockfd,struct sockaddr *localaddr,int *addrlen)
int getpeername(int sockfd,struct sockaddr *peeraddr, int *addrlen)
struct servent *getservbyname(const char *servname,const char *protoname) //得到指定的端口号
struct servent *getservbyport(int port,const char *protoname) //得到指定端口号的服务
struct servent
{
char *s_name; /* 正式服务名 */
char **s_aliases; /* 别名列表 */
int s_port; /* 端口号 */
char *s_proto; /* 使用的协议 */
}一般我们很少用这几个函数，对应客户端，当我们要得到连接的端口号时在 connect 调用成功后使用可得到系统分配的端口号。对于服务端，我们用 INADDR_ANY 填充后，为了得到连接的 IP 我们可以在 accept 调用成功后使用而得到IP地址。在网络上有许多的默认端口和服务，比如端口 21 对 ftp， 80 对应 WWW。为了得到指定的端口号的服务我们可以调用第四个函数，相反为了得到端口号可以调用第三个函数。
实例
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>
int main(int argc ,char **argv)
{
struct sockaddr_in addr;
struct hostent *host;
char **alias;
if(argc<2)
{
fprintf(stderr,"Usage:%s hostname|ip..\n\a",argv[0]);
exit(1);
}
argv++;
for(;*argv!=NULL;argv++)
{
/* 这里我们假设是IP*/
if(inet_aton(*argv,&addr.sin_addr)!=0)
{
host=gethostbyaddr((char *)&addr.sin_addr,4,AF_INET);
printf("Address information of Ip %s\n",*argv);
}
else
{
/* 失败,难道是域名?*/
host=gethostbyname(*argv); printf("Address information of host %s\n",*argv);
}
if(host==NULL)
{
/* 都不是 ,算了不找了*/
fprintf(stderr,"No address information of %s\n",*argv);
continue;
}
printf("Official host name %s\n",host->h_name);
printf("Name aliases:");
for(alias=host->h_aliases;*alias!=NULL;alias++)
printf("%s ,",*alias);
printf("\nIp address:");
for(alias=host->h_addr_list;*alias!=NULL;alias++)
printf("%s ,",inet_ntoa(*(struct in_addr *)(*alias)));
}
}
在这个例子里面，为了判断用户输入的是IP还是域名我们调用了两个函数，第一次我们假设输入的是IP所以调用inet_aton，失败的时候，再调用gethostbyname而得到信息。
完整的读写函数
一旦我们建立了连接,我们的下一步就是进行通信了。在Linux下面把我们前面建立的通道看成是文件描述符，这样服务器端和客户端进行通信时候，只要往文件描述符里面读写东西了。就象我们往文件读写一样。
1.ssize_t write(int fd,const void *buf,size_t nbytes)
write 函数将 buf 中的 nbytes 字节内容写入文件描述符fd。成功时返回写的字节数，失败时返回 -1 并设置 errno 变量。
在网络程序中,当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于等于0,表示写了部分或者是全部的数据.
2)返回的值小于0,此时出现了错误.我们要根据错误类型来处理.
如果错误为EINTR表示在写的时候出现了中断错误，如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接).
为了处理以上的情况,我们自己编写一个写函数来处理这几种情况。int my_write(int fd,void *buffer,int length)
{
int bytes_left; //剩余写入字节数
int written_bytes; //已写入长度
char *ptr; //待写入字符串ptr=buffer;
bytes_left=length;
while(bytes_left>0)
{
/* 开始写*/
written_bytes=write(fd,ptr,bytes_left);
if(written_bytes<=0) /* 出错了*/
{
if(errno==EINTR) /* 中断错误 我们继续写*/
written_bytes=0;
else /* 其他错误 没有办法,只好撤退了*/
return(-1);
}
bytes_left - = written_bytes;
ptr + = written_bytes; /* 从剩下的地方继续写 */
}
return(0);
}
2.ssize_t read(int fd,void *buf,size_t nbyte)
read函数是负责从fd中读取内容到 buffer。当读成功时，read 返回实际所读的字节数，如果返回的值是0 表示已经读到文件的结束，小于0表示出现了错误。
如果错误为EINTR说明读是由中断引起的。
如果是ECONNREST表示网络连接出了问题。和上面一样，我们也写一个自己的读函数。int my_read(int fd,void *buffer,int length)
{
int bytes_left;
int bytes_read;
char *ptr;ptr=buffer;
bytes_left=length;
while(bytes_left>0)
{
bytes_read=read(fd,ptr,bytes_read);
if(bytes_read<0)
{
if(errno==EINTR)
bytes_read=0;
else
return(-1);
}
else if(bytes_read==0)
break;
bytes_left - = bytes_read;
ptr + = bytes_read;
}
return(length-bytes_left);
}
3.数据的传递
有了上面的两个函数，我们就可以向客户端或者是服务端传递数据了。比如我们要传递一个结构，可以使用如下方式：
/* 客户端向服务端写 */
struct my_struct my_struct_client;
write(fd,(void *)&my_struct_client,sizeof(struct my_struct);
/* 服务端的读*/
char buffer[sizeof(struct my_struct)];
struct *my_struct_server;
read(fd,(void *)buffer,sizeof(struct my_struct));
my_struct_server=(struct my_struct *)buffer; //获得读取的内容
在网络上传递数据时我们一般都是把数据转化为char类型的数据传递。接收的时候也是一样的 注意的是我们没有必要在网络上传
递指针(因为传递指针是没有任何意义的,我们必须传递指针所指向的内容~包含于 fd 中)。
套接字选项*
有时候我们要控制套接字的行为(如修改缓冲区的大小)，这个时候我们就要控制套接字的选项了。
int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t *optlen)
int setsockopt(int sockfd,int level,int optname,const void *optval,socklen_t *optlen)
level指定控制套接字的层次，可以取三种值：
1)SOL_SOCKET：通用套接字选项
2)IPPROTO_IP：IP选项
3)IPPROTO_TCP：TCP选项
optname 指定控制的方式(选项的名称)，我们下面详细解释
optval 获得或者是设置套接字选项，根据选项名称的数据类型进行转换
选项名称 说明 数据类型
========================================================================
SOL_SOCKET
------------------------------------------------------------------------
SO_BROADCAST 允许发送广播数据 int
SO_DEBUG 允许调试 int
SO_DONTROUTE 不查找路由 int
SO_ERROR 获得套接字错误 int
SO_KEEPALIVE 保持连接 int
SO_LINGER 延迟关闭连接 struct linger
SO_OOBINLINE 带外数据放入正常数据流 int
SO_RCVBUF 接收缓冲区大小 int
SO_SNDBUF 发送缓冲区大小 int
SO_RCVLOWAT 接收缓冲区下限 int
SO_SNDLOWAT 发送缓冲区下限 int
SO_RCVTIMEO 接收超时 struct timeval
SO_SNDTIMEO 发送超时 struct timeval
SO_REUSERADDR 允许重用本地地址和端口 int
SO_TYPE 获得套接字类型 int
SO_BSDCOMPAT 与BSD系统兼容 int
==========================================================================
IPPROTO_IP
--------------------------------------------------------------------------
IP_HDRINCL 在数据包中包含IP首部 int
IP_OPTINOS IP首部选项 int
IP_TOS 服务类型
IP_TTL 生存时间 int
==========================================================================
IPPRO_TCP
--------------------------------------------------------------------------
TCP_MAXSEG TCP最大数据段的大小 int
TCP_NODELAY 不使用Nagle算法 int
=========================================================================
关于这些选项的详细情况请查看 Linux Programmer's Manual
ioctl
ioctl可以控制所有的文件描述符的情况,这里介绍一下控制套接字的选项.
int ioctl(int fd,int req,...)
==========================================================================
ioctl的控制选项
--------------------------------------------------------------------------
SIOCATMARK 是否到达带外标记 int
FIOASYNC 异步输入/输出标志 int
FIONREAD 缓冲区可读的字节数 int
==========================================================================
详细的选项请用 man ioctl_list 查看。
服务器模型^
在网络程序里面，一般来说都是许多客户机对应一个服务器。为了处理客户机的请求，对服务端的程序就提出了特殊的要求。
下面我们先学习一下目前最常用的服务器模型：
<一>循环服务器：循环服务器在同一个时刻只可以响应一个客户端的请求
<二>并发服务器：并发服务器在同一个时刻可以响应多个客户端的请求
1.循环服务器:UDP服务器
UDP循环服务器的实现非常简单：UDP服务器每次从套接字上读取一个客户端的请求处理，然后将结果返回给客户机。可以用下面的算法来实现。
socket(...);
bind(...);
while(1)
{
recvfrom(...); //从套接字上读取一个客户端的请求处理
process(...); //处理过程
sendto(...); //结果返回客户机
}
因为UDP是非面向连接的，没有一个客户端可以老是占住服务端。只要处理过程不是死循环，服务器对于每一个客户机的请求总是能够满足。
2.循环服务器:TCP服务器
TCP 循环服务器的实现也不难：TCP服务器接受一个客户端的连接，然后处理，完成了这个客户的所有请求后，断开连接。
算法如下:
socket(...);
bind(...);
listen(...);
while(1)
{
accept(...); //接收一个客户端的连接
while(1)
{
read(...);
process(...); //处理过程
write(...);
}
close(...); //断开连接
}TCP循环服务器一次只能处理一个客户端的请求。只有在这个客户的所有请求都满足后, 服务器才可以继续后面的请求。
这样如果有一个客户端占住服务器不放时，其它的客户机都不能工作了。因此，TCP服务器一般很少用循环服务器模型的。
3.并发服务器:TCP服务器
为了弥补循环TCP服务器的缺陷，人们又想出了并发服务器的模型。并发服务器的思想是每一个客户机的请求并不由服务器直接处理，而是服务器创建一个子进程来处理。
算法如下:
socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
if(fork(..)==0)
{
while(1)
{
read(...);
process(...);
write(...);
}
close(...);
exit(...);
}
close(...);
}TCP并发服务器可以解决TCP循环服务器客户机独占服务器的情况。不过也同时带来了一个不小的问题。为了响应客户机的请求，服务器要创建子进程来处理。而创建子进程是一种非常消耗资源的操作。
4.并发服务器:多路复用I/O
为了解决创建子进程带来的系统资源消耗，人们又想出了多路复用I/O模型。
首先介绍一个函数 select：
int select(int nfds,fd_set *readfds,fd_set *writefds,
fd_set *except fds,struct timeval *timeout)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
void FD_ZERO(fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)一般的来说当我们在向文件读写时，进程有可能在读写出阻塞，直到一定的条件满足。比如我们从一个套接字读数据时，可能缓冲区里面没有数据可读 (通信的对方还没有 发送数据过来)，这个时候我们的读调用就会等待(阻塞)直到有数据可读。如果我们不希望阻塞，我们的一个选择是用 select 系统调用。 只要我们设置好 select 的各个参数,那么当文件可以读写的时候 select会"通知"我们说可以读写了。
- readfds 表示所有要读的文件文件描述符的集合
- writefds 表示所有要的写文件文件描述符的集合
- exceptfds 监视的异常 socket 文件句柄集合
- timeout 本次select()的超时结束时间
- nfds 所有我们监控的文件描述符中最大的那一个加1
在我们调用select时进程会一直阻塞直到以下的一种情况发生：
1)有文件可以读.
2)有文件可以写.
3)超时所设置的时间到.
为了设置文件描述符我们要使用几个宏：
FD_SET 将 fd 加入到 fdset
FD_CLR 将 fd 从 fdset 里面清除
FD_ZERO 从 fdset 中清除所有的文件描述符
FD_ISSET 判断 fd 是否在 fdset 集合中
使用select的一个例子
int use_select(int *readfd,int n)
{
fd_set my_readfd;
int maxfd;
int i;
maxfd=readfd[0];
for(auto x : readfd)
if(readfd[i]>maxfd) maxfd=readfd[i];
while(1)
{
/* 将所有的文件描述符加入 */
FD_ZERO(&my_readfd);
for(auto x : readfd)
FD_SET(readfd[i],*my_readfd);
/* 进程阻塞 */
select(maxfd+1,& my_readfd,NULL,NULL,NULL); //select 初始化完成
/* 有东西可以读了 */
for(auto x : readfd)
if(FD_ISSET(readfd[i],&my_readfd))
{
/* 原来是我可以读了 */
we_read(readfd[i]);
}
}
}使用select后我们的服务器程序就变成了.
初始化(socket,bind,listen);
while(1)
{
设置监听读写文件描述符(FD_*);
调用select; //（use select()）
如果是倾听套接字就绪,说明一个新的连接请求建立
{
建立连接(accept);
加入到监听文件描述符中去;
}
否则说明是一个已经连接过的描述符
{
进行操作(read或者write);
}
}多路复用I/O可以解决资源限制的问题。这个模型实际上是将UDP循环模型用在了TCP上面。这也就带来了一些问题，如由于服务器依次处理客户的请求,所以可能会导致有的客户会等待很久。
5.并发服务器:UDP服务器
人们把并发的概念用于UDP就得到了并发UDP服务器模型。并发UDP服务器模型其实是简单的，和并发的TCP服务器模型一样是创建一个子进程来处理的。算法和并发的TCP模型相同。
除非服务器在处理客户端的请求所用的时间比较长以外,人们实际上很少用这种模型。
6.一个并发TCP服务器实例
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>#define MY_PORT 8888 //使用的端口号
int main(int argc, char **argv)
{
int listen_fd, accept_fd;
struct sockaddr_in client_addr;
int n;if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0))<0)
{
printf("Socket Error:%s\n\a", strerror(errno));
exit(1);
}bzero(&client_addr, sizeof(struct sockaddr_in));
client_addr.sin_family = AF_INET;
client_addr.sin_port = htons(MY_PORT);
client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
n = 1;
/* 如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间 */
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(int));
if (bind(listen_fd, (struct sockaddr *)&client_addr, sizeof(client_addr))<0)
{
printf("Bind Error:%s\n\a", strerror(errno));
exit(1);
}
listen(listen_fd, 5);
while (1)
{
accept_fd = accept(listen_fd, NULL, NULL);
if ((accept_fd<0) && (errno == EINTR))
continue;
else if (accept_fd<0)
{
printf("Accept Error:%s\n\a", strerror(errno));
continue;
}
if ((n = fork()) == 0)
{
/* 子进程处理客户端的连接 */
char buffer[1024];close(listen_fd);
n = read(accept_fd, buffer, 1024);
write(accept_fd, buffer, n);
close(accept_fd);
exit(0);
}
else if (n<0)
printf("Fork Error:%s\n\a", strerror(errno));
close(accept_fd);
}
}你可以用我们前面写客户端程序来调试着程序，或者是用来telnet调试。
实际的 one loop per thread + thread pool 模式，就是在每个 fork 出来的进程中创建 event loop 使用 select 进行多个 socket 监听。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jenshy/archive/2006/04/18/667944.aspx
扫一扫
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
