Linux网络编程之循环服务器
1.介绍
Linux网络循环服务器是指逐个处理客户端的连接，处理完一个连接后再处理下一个连接，是一个串行处理的方式，比较适合时间服务器，DHCP服务器.对于TCP服务器来说，主要阻塞在accept函数，等待客户端的连接。而对于UDP服务器来说，主要阻塞在recv函数.
2.循环服务器模型
TCP循环服务器:
算法如下:socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
read(...);
process(...);
write(...);
close(...);//关闭客户端连接
}
close(....);//关闭服务器连接
UDP循环服务器:
算法如下:
socket(...)
bind(....);
while(1){
recvfrom(....);
process(...);
sendto(....);
close(....);//关闭客户端连接
}
close(....);//关闭服务器连接
从上面的流程可以看出，TCP循环服务器在accept处阻塞一直等待客户端的到来，而UDP循环服务器在recv处阻塞，等待客户端发送数据.
3. 循环服务器的例子
下面的程序是一个时间服务器，客户端发出TIME时间请求，服务器将本地时间返回给客户端.
(1)TCP循环服务器
服务器:
#include
#include
#include
#include
#include
#include
#include
/**
TCP循环服务器
在accept处阻塞等待客户端的连接，并处理请求
**/
#define PORT 8888
#define BUFFERSIZE 1024
#define LISTEN 10
int main(int argc,char*argv[]){
int s;
int ret;
int len;
int size;
int sc;
time_t now;
char buffer[BUFFERSIZE];
struct sockaddr_in server_addr,client_addr;
//建立流式套接字
s=socket(AF_INET,SOCK_STREAM,0);
if(s<0){
perror("socket error");
return -1;
}
//将地址绑定到套接字上
memset(&server_addr,0,sizeof(server_addr));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(PORT);
ret=bind(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
if(ret<0){
perror("bind error");
return -1;
}
//监听队列的长度
listen(s,LISTEN);
len=sizeof(client_addr);
//接受客户端的请求
while(1){
sc=accept(s,(struct sockaddr*)&client_addr,&len);//等待客户端的连接，client_addr存放的是客户端的信息
memset(buffer,0,BUFFERSIZE);
size=recv(sc,buffer,BUFFERSIZE,0);//利用套接字描述符sc进行通信
if(size<0){
perror("recv error");
break;
}
else if(!strncmp(buffer,"TIME",4)){
now=time(NULL);
sprintf(buffer,"%24s",ctime(&now));
send(sc,buffer,strlen(buffer),0);
}
close(sc);//关闭本次通信的客户端连接
}
close(s);
return 0;
}
客户端:
#include
#include
#include
#include
#include
#include
#include
/**
循环服务器客户端程序
**/
#define PORT 8888
#define BUFFERSIZE 1024
int main(int argc,char*argv[]){
int s;
int ret;
int size;
struct sockaddr_in server_addr;
char buffer[BUFFERSIZE];
s=socket(AF_INET,SOCK_STREAM,0);
if(s<0){
perror("socket error");
return -1;
}
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);
//连接服务器
ret=connect(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
if(ret==-1){
perror("connect error");
return -1;
}
memset(buffer,0,BUFFERSIZE);
strcpy(buffer,"TIME");
size=send(s,buffer,strlen(buffer),0);
if(size<0){
perror("send error");
return -1;
}
memset(buffer,0,BUFFERSIZE);
size=recv(s,buffer,BUFFERSIZE,0);
if(size<0){
perror("recv error");
return;
}
printf("%s",buffer);
close(s);
return 0;
}
运行结果:
[root@localhost 14章服务器模式]# ./circle-tcpc14Sat Feb 18 09:44:31 2012
(2)UDP循环服务器
服务器:
#include
#include
#include
#include
#include
#include
#include
/**
UDP循环服务器
原理:服务器在recv函数与处理业务之间轮循处理
**/
#define PORT 8888
#define BUFFERSIZE 1024
int main(int argc,char*argv[]){
int s;
struct sockaddr_in server_addr,client_addr;//分别表示客户端地址与服务器端地址
time_t now;
int ret;
int size;
char buffer[BUFFERSIZE];
//建立数报套接字
s=socket(AF_INET,SOCK_DGRAM,0);//数据报
if(s<0){
perror("socket error");
return -1;
}
//地址绑定
bzero(&server_addr,sizeof(server_addr));//地址结构清0
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(PORT);
ret=bind(s,(struct sockaddr*)&server_addr,sizeof(server_addr));
if(ret==-1){
perror("bind error");
return -1;
}
//数据报套接字没有流量控制所以没有监听listen，也没有三次握手，所以没有接受连接accept
while(1){
memset(buffer,0,BUFFERSIZE);//清0
int len=sizeof(client_addr);
size=recvfrom(s,buffer,BUFFERSIZE,0,(struct sockaddr*)&client_addr,&len);
if(size<=0){
perror("recvfrom");
}else{
if(!strncmp(buffer,"TIME",4)){//判断是否是合法数据
memset(buffer,0,BUFFERSIZE);
now=time(NULL);//获得当前时间
sprintf(buffer,"%24s",ctime(&now));//ctime所指向的最后一个字符是\n
sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&client_addr,len);//发送数据，第3项表示发送数据的长度
}
}
}
close(s);
return 0;
}
客户端:
#include
#include
#include
#include
#include
#include
#include
/**
UDP客店端，客户端向服务器发送时间请求，服务器返回相应的时间
**/
#define PORT 8888
#define BUFFERSIZE 1024
int main(int argc,char*argv[]){
int s;//套接字描述符
int ret;//建立套接字的返回值
int size;
struct sockaddr_in server_addr;//地址结构
int len;
char buffer[BUFFERSIZE];
s=socket(AF_INET,SOCK_DGRAM,0);//建立流式套接字
if(s<0){
perror("socket error");
return -1;
}
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(PORT);
memset(buffer,0,BUFFERSIZE);
strcpy(buffer,"TIME");
//向服务器发送数据
size=sendto(s,buffer,strlen(buffer),0,(struct sockaddr*)&server_addr,sizeof(server_addr));
if(size<0){
perror("sendto error");
return -1;
}
//从服务器接收数据
len=sizeof(server_addr);
size=recvfrom(s,buffer,BUFFERSIZE,0,(struct sockaddr*)&server_addr,&len);
if(size<0){
perror("recvfrom error");
return -1;
}
//write(1,buffer,size);
printf("%s\n",buffer);
close(s);
return 0;
}
运行结果:
[root@localhost 14章服务器模式]# ./circle-udpc14
Sat Feb 18 09:59:22 2012
总结:本文主要介绍了循环服务器的算法流程，并且给出了TCP与UDP循环服务器实例.