提示：改編自tinyproxy，向原作者致敬！
在程序的開頭，可以定義以下几個常量：
#defineMAXSERVICES 128 /*每一個進程最大服務用戶數，防止錯誤積累*/
#defineSTARTSERVERS 32 /*初始啟動服務進程數*/
#defineMAXSPARESERVERS 32 /*最大空閒服務進程數*/
#defineMINSPARESERVERS 8 /*最小空閒服務進程數*/
使用者只需要在程序最下面修改handle_connection函數，在裡面實現對客戶請求的處理邏輯即可，信號處理及進程組控制都由框架完成。在RHES32.4kernel和DebianEtch2.6kernel下測試通過。
歡迎指正。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<unistd.h>
#include<errno.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/mman.h>
#include<sys/file.h>
#include<sys/wait.h>
#include<sys/socket.h>
#include<arpa/inet.h>
/*
*福瑞哈哥改編自tinyproxy
*/
#defineMAXLISTEN 1024 /*最大監聽數，listen函數用*/
#defineMAXCLIENTS 64 /*最大服務進程數*/
#defineMAXSERVICES 128 /*每一個進程最大服務用戶數，定期更新進程組，防止錯誤積累*/
#defineSTARTSERVERS 32 /*初始啟動服務進程數*/
#defineMAXSPARESERVERS 32 /*最大空閒服務進程數*/
#defineMINSPARESERVERS 8 /*最小空閒服務進程數*/
#definePORT 8000 /*監聽端口號*/
/*全局變量區*/
intlistenfd; /*服務socket*/
intreceived_sighup=0; /*收到hup信號標誌*/
intquit=0; /*退出標誌*/
#defineSERVER_COUNT_LOCK()_child_lock_wait()
#defineSERVER_COUNT_UNLOCK()_child_lock_release()
/*共享變量鎖*/
staticstructflocklock_it,unlock_it;
staticintlock_fd=-1;
enumchild_status_t{T_EMPTY,T_WAITING,T_CONNECTED};
structchild_s{
pid_ttid;
unsignedintconnects;
enumchild_status_tstatus;
};
/*
*子進程數組－位於共享內存區
*/
staticstructchild_s*child_ptr;
/*
*正等待用戶連接的服務進程數
*/
staticunsignedint*servers_waiting;
/*
*分配一塊共享內存。
*/
staticvoid*
malloc_shared_memory(size_tsize)
{
intfd;
void*ptr;
charbuffer[32];
staticchar*shared_file="/tmp/mps.shared.XXXXXX";
assert(size>0);
strncpy(buffer,shared_file,sizeof(buffer));
if((fd=mkstemp(buffer))==-1)
return(void*)MAP_FAILED;
unlink(buffer);
if(ftruncate(fd,size)==-1)
return(void*)MAP_FAILED;
ptr=mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
returnptr;
}
/*
*分配一塊共享內存，並清0。
*/
staticvoid*
calloc_shared_memory(size_tnmemb,size_tsize)
{
void*ptr;
longlength;
assert(nmemb>0);
assert(size>0);
length=nmemb*size;
ptr=malloc_shared_memory(length);
if(ptr==MAP_FAILED)
returnptr;
memset(ptr,0,length);
returnptr;
}
staticvoid
_child_lock_init(void)
{
charlock_file[]="/tmp/mps.servers.lock.XXXXXX";
lock_fd=mkstemp(lock_file);
unlink(lock_file);
lock_it.l_type=F_WRLCK;
lock_it.l_whence=SEEK_SET;
lock_it.l_start=0;
lock_it.l_len=0;
unlock_it.l_type=F_UNLCK;
unlock_it.l_whence=SEEK_SET;
unlock_it.l_start=0;
unlock_it.l_len=0;
}
staticvoid
_child_lock_wait(void)
{
intrc;
while((rc=fcntl(lock_fd,F_SETLKW,&lock_it))<0){
if(errno==EINTR)
continue;
else
return;
}
}
staticvoid
_child_lock_release(void)
{
if(fcntl(lock_fd,F_SETLKW,&unlock_it)<0)
return;
}
#defineSERVER_INC()do{/
SERVER_COUNT_LOCK();/
++(*servers_waiting);/
SERVER_COUNT_UNLOCK();/
}while(0)
#defineSERVER_DEC()do{/
SERVER_COUNT_LOCK();/
assert(*servers_waiting>0);/
--(*servers_waiting);/
SERVER_COUNT_UNLOCK();/
}while(0)
/*
*創建監聽socket
*/
staticvoid
start_listen_socket(unsignedshortport)
{
intsockfd;
inton=1;
structsockaddr_inaddr;
sockfd=socket(AF_INET,SOCK_STREAM,0);
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
memset(&addr,0,sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_port=htons(port);
/*
*需要指定到實際的地址上
*/
addr.sin_addr.s_addr=inet_addr("0.0.0.0");
if(bind(sockfd,(structsockaddr*)&addr,sizeof(addr))<0){
fprintf(stderr,"Unabletobindlisteningsocketbecauseof%s/n",
strerror(errno));
exit(-1);
}
if(listen(sockfd,MAXLISTEN)<0){
fprintf(stderr,"Unabletostartlisteningsocketbecauseof%s/n",
strerror(errno));
exit(-1);
}
listenfd=sockfd;
}
void
close_listen_socket(void)
{
close(listenfd);
}
/*
*在這個函數中，寫下對客戶請求的處理邏輯。
*處理完成後在退出這個函數時，關閉connfd。
*/
void
handle_connection(intconnfd);
/*
*子進程主循環
*/
staticvoid
child_main(structchild_s*ptr)
{
intconnfd;
structsockaddr*cliaddr;
socklen_tclilen;
clilen=sizeof(structsockaddr);
cliaddr=(structsockaddr*)malloc(clilen);
if(!cliaddr){
fprintf(stderr,
"Couldnotallocatememoryforchildaddress.");
exit(0);
}
ptr->connects=0;
while(!quit){
ptr->status=T_WAITING;
connfd=accept(listenfd,cliaddr,&clilen);
/*
*保證沒有錯誤發生
*/
if(connfd<0){
fprintf(stderr,
"Acceptreturnedanerror(%s)...retrying.",
strerror(errno));
continue;
}
ptr->status=T_CONNECTED;
SERVER_DEC();
handle_connection(connfd);
ptr->connects++;
if(ptr->connects==MAXSERVICES){
fprintf(stderr,
"ChildhasreachedMaxRequestsPerChild(%u).Killingchild./n",
ptr->connects);
break;
}
SERVER_COUNT_LOCK();
if(*servers_waiting>MAXSPARESERVERS){
/*
*有太多空閒服務進程，退出自己
*/
fprintf(stderr,
"Waitingservers(%d)exceedsMaxSpareServers(%d).Killingchild./n",
*servers_waiting,MAXSPARESERVERS);
SERVER_COUNT_UNLOCK();
break;
}else{
SERVER_COUNT_UNLOCK();
}
SERVER_INC();
}
ptr->status=T_EMPTY;
free(cliaddr);
exit(0);
}
/*
*Fork一個子進程並啟動child_main()函數（子進程主循環）
*/
staticint
child_make(structchild_s*ptr)
{
pid_tpid;
if((pid=fork())!=0)
returnpid; /*父進程*/
/*
*重設子進程的信號處理函數
*/
signal(SIGCHLD,SIG_DFL);
signal(SIGTERM,SIG_DFL);
signal(SIGHUP,SIG_DFL);
child_main(ptr);/*不會返回*/
return-1;
}
int
child_pool_create(void)
{
/*sleep(10);*/
child_ptr=(structchild_s*)
calloc_shared_memory(MAXCLIENTS,
sizeof(structchild_s));
if(child_ptr==MAP_FAILED){
fprintf(stderr,"Couldnotallocatesharedmemoryforchildren./n");
return-1;
}
servers_waiting=(unsignedint*)
malloc_shared_memory(sizeof(unsignedint));
if(servers_waiting==MAP_FAILED){
fprintf(stderr,"Couldnotallocatesharedmemoryforchildcounting./n");
return-1;
}
*servers_waiting=0;
/*在操作servers_waiting變量之前，創建加鎖文件*/
_child_lock_init();
inti;
/*初始化子進程共享數組*/
for(i=0;i<MAXCLIENTS;i++){
child_ptr.status=T_EMPTY;
child_ptr.connects=0;
}
/*fork子進程*/
for(i=0;i<STARTSERVERS;i++){
child_ptr.status=T_WAITING;
child_ptr.tid=child_make(&child_ptr);
if(child_ptr.tid<0){
fprintf(stderr,
"Couldnotcreatechildnumber%dof%d/n",
i,STARTSERVERS);
return-1;
}else{
fprintf(stderr,
"Creatingchildnumber%dof%d.../n",
i+1,STARTSERVERS);
SERVER_INC();
}
}
return0;
}
/*
*刪除所有服務進程
*/
void
kill_children(void)
{
unsignedinti;
for(i=0;i<MAXCLIENTS;i++){
if(child_ptr.status!=T_EMPTY)
kill(child_ptr.tid,SIGTERM);
}
}
/*
*監控進程主循環，它負責把服務進程的數量維持在一個合適的數量上。
*/
void
child_main_loop(void)
{
unsignedinti;
while(1){
if(quit)
return;
/*如果空閒服務進程數不足，則創建一些*/
SERVER_COUNT_LOCK();
if(*servers_waiting<MINSPARESERVERS){
fprintf(stderr,
"Waitingservers(%d)islessthanMinSpareServers(%d).Creatingnewchild.",
*servers_waiting,MINSPARESERVERS);
SERVER_COUNT_UNLOCK();
for(i=0;i<MAXCLIENTS;i++){
if(child_ptr.status==T_EMPTY){
child_ptr.status=T_WAITING;
child_ptr.tid=child_make(&child_ptr);
if(child_ptr.tid<0){
fprintf(stderr,"Couldnotcreatechild");
child_ptr.status=T_EMPTY;
break;
}
SERVER_INC();
break;
}
}
}else{
SERVER_COUNT_UNLOCK();
}
sleep(5);
if(received_sighup){
/*在收到hup信號後，可作一些維護工作，比如更新備份日志文件等*/
received_sighup=0;
}
}
}
/*
*處理信號
*/
void
takesig(intsig)
{
pid_tpid;
intstatus;
switch(sig){
caseSIGHUP:
received_sighup=1;
break;
caseSIGTERM:
quit=1;
break;
caseSIGCHLD:
while((pid=waitpid(-1,&status,WNOHANG))>0)
;
break;
}
return;
}
int
main(intargc,char**argv)
{
intgodaemon=1; /*是否轉為deamon模式*/
unsignedshortport=PORT; /*服務端口號*/
assert(MINSPARESERVERS<=MAXSPARESERVERS);
assert(STARTSERVERS<=MAXCLIENTS);
assert(MAXCLIENTS<=MAXLISTEN);
if(godaemon==1){
daemon(1,1);
}
/*啟動服務socket*/
start_listen_socket(port);
signal(SIGPIPE,SIG_IGN);
/*創建服務進程組*/
child_pool_create();
/*
*下面這些信號處理函數只有監控進程才有用
*/
signal(SIGCHLD,takesig);
signal(SIGTERM,takesig);
signal(SIGHUP,takesig);
/*開始監控工作*/
child_main_loop();
/*退出前，殺掉服務進程組*/
kill_children();
/*關閉服務socket*/
close_listen_socket();
exit(0);
return0;
}
/*
*在這個函數中，寫下對客戶請求的處理邏輯。
*處理完成後在退出這個函數時，關閉connfd。
*這只是一個示例！
*/
void
handle_connection(intconnfd)
{
charbuf[128]={};
sprintf(buf,"%u:",(unsignedint)getpid());
intlen=strlen(buf);
read(connfd,buf+len,sizeof(buf)-len-1);
len=strlen(buf);
write(connfd,buf,len);
close(connfd);
}
相关推荐
在IT领域，多进程服务框架是一种常见的设计模式，它允许应用程序同时运行多个独立的进程来执行不同的任务，提高系统的并行处理能力和效率。本资源提供的"多进程服务的框架源代码"是一个很好的学习和实践平台，尤其...
人工智能-项目实践-嵌入式-基于Linux系统的应用程序,旨在搭建一套完整的多进程多线程通讯的消息框架. 支持多SOC的嵌入 架构设计核心思想: 统一、抽象、下沉、上升、量化、闭环。 统一：做到通用，标准化，如posix...
Linux服务器框架是构建在Linux操作系统上的用于处理网络服务的软件架构。它通常涉及到网络通信、多线程编程、进程管理、内存管理和系统调用等多个核心领域。Linux因其开源、稳定和高效的特点，成为了开发服务器软件...
"Linux下的多线程服务器程序设计" Linux操作系统是当前最流行的开源操作系统之一，它广泛应用于服务器领域。设计一个高性能的服务器程序是非常重要的，然而传统的服务器工作方式存在三个显著的缺点：fork开销大、...
该项目支持多进程和多线程模式，推荐安装pthreads扩展以获得更佳性能，同时兼容Linux和Windows操作系统。项目包含39个文件，其中30个PHP源文件、6个Markdown文档、1个JSON配置文件、1个CMD脚本文件、1个TPL模板文件...
Linux内核是操作系统的核心部分，负责管理系统的硬件资源，提供基础服务给上层的应用程序，以及维护系统的稳定性与安全性。其代码框架复杂而有序，理解这一框架对于深入学习Linux系统至关重要。以下是对“Linux内核...
传统多线程方案中，每当接收请求即创建新线程进行处理，任务完成后线程随即销毁，这种“即时创建，即时销毁”的模式虽高效于进程创建，但对于执行时间极短且频率极高的任务而言，线程的创建与销毁开销变得显著。...
本文将详细讨论如何在Unix/Linux下构建一个多线程和信号管理的框架，并基于提供的`zThreadMgr`文件进行分析。 1. **多线程概念**：多线程是现代操作系统中并发执行任务的一种机制。在Unix/Linux中，线程共享同一...
《Linux高性能服务器编程》这本书是针对那些希望深入理解并掌握Linux环境下服务器开发技术的专业人士而编写的。书中详细探讨了如何利用C和C++这两种语言，实现高效且可靠的服务器应用程序。以下是该书可能涵盖的一些...
3. **多线程/多进程模型**：为了处理多个客户端的并发连接，服务器通常采用多线程或多进程模型。每个连接到服务器的客户端都会分配一个线程或进程来处理其请求，这样可以避免阻塞其他客户端的处理。C++中，可以使用`...
1、linux进程管理的模块组织框架 2、相关数据结构。 3、进程调度原则，调度算法,。 4、进程的创建和运行管理。 5、进程间通讯。 6、更多的技术 进程调度和中断处理交接 进程管理涉及的内核机制：bottom-half处理...
第二部分对高性能服务器编程的核心要素进行了全面深入的剖析，包含Linux网络编程API、高级I/O函数、Linux服务器程序规范、高性能服务器程序框架、I/O复用、信号、定时器、高性能I/O框架库Libevent、多进程编程、多...
【Linux进程实验】是深入理解Linux操作系统核心概念的重要实践，其中包含了进程控制块（PCB）、进程调度算法等关键知识点。 在实验中，你需要编写一个模拟的进程调度程序，使用"简单时间片轮转法"对五个进程进行...
- **多进程**：每个进程负责一部分请求，通过IPC（Inter-Process Communication）进行通信。 - **异步非阻塞I/O**：如epoll模型，通过事件驱动减少线程数量，提高系统效率。 - **负载均衡**：通过负载均衡器将...
本篇文章主要探讨了如何在Linux环境下设计一个能同时处理多种协议和服务的服务器程序，以减少代码冗余和资源浪费。 1. 服务器程序设计的通用方法缺点分析 传统的服务器程序设计通常针对特定协议和服务创建独立的...
该框架利用PHP的多进程和内存共享特性，实现了任务的高效分配与执行，并支持跨平台运行于Linux和Windows系统。以其良好的伸缩性、扩展性和稳定性，被多家公司采用，并鼓励开源爱好者共同参与贡献。
3. **事件选择机制**：如epoll（Linux下的高效I/O复用），用于监控多个SOCKET状态，当有事件发生时通知服务器进行处理。 4. **并发处理**：当事件发生时，线程池会分配一个线程处理该事件。可能包括读取客户端数据...
在Linux操作系统中，服务器与客户端之间的通信是网络编程的基础，主要依赖于TCP/IP协议栈...在实际应用中，这只是一个基本框架，根据具体需求，还需要考虑更多的细节，例如数据的序列化和反序列化、安全性、可靠性等。