大数运算+web服务器

//http.h
#pragma?once???????????????????????????????????????????????????????????????????
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/sendfile.h>
#include<sys/stat.h>
#include<sys/epoll.h>
#include<unistd.h>
#include<fcntl.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<pthread.h>
#include<errno.h>
#define?_DEF_PAGE_?"index.html"
#define?_SIZE_?1024
typedef?struct?bf
{
????char?_buf[_SIZE_];
????int?_fd;
????int?_cgi;
????char?_method[_SIZE_/2];
????char?_path[_SIZE_];
????union
????{
????????char*?_query_string;
????????int?_st_size;
????};
????int?_err;

}bf_t,*bf_p;
void?printLog(const?char*?const?str,const?char*?const?fun,int?line);
void?usage(const?char*??const??proc);
int?startup(char*?ip,int?port);
void?response_err(bf_p?bf,int?eno);
void?echo_error(bf_p?bf,int?eno);
int?get_line(int?sock,char*?buf,int?size);
void?clear_head(int?sock);
void?execute_cgi(bf_p?bf);
void?echo_html(bf_p?bf);
void?accept_request(void*?ptr);???????
//http.c
#include"http.h"????????????????????????????????????????????????????????????????
void?printLog(const?char*?const?str,int?line)
{
????printf("%s:%s:%dn",str,fun,line);
}
void?usage(const?char*??const??proc)
{?
????assert(proc);?
????printLog(proc,__FUNCTION__,__LINE__);
}?
int?startup(char*?ip,int?port)?
{?????
????assert(ip);
????int?sock=socket(AF_INET,SOCK_STREAM,0);
????if(sock<0)
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}?
????int?opt=1;
????setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
????struct?sockaddr_in?local;?
????local.sin_family=AF_INET;
????local.sin_port=htons(port);
????if(strncmp(ip,"any",3)==0)?
????{?
????????local.sin_addr.s_addr=?INADDR_ANY;
????}
????else
????{
????????local.sin_addr.s_addr=inet_addr(ip);
????}
????if(bind(sock,(struct?sockaddr*)&local,sizeof(local))<0)
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}
????if(listen(sock,5)<0)
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}
????return?sock;
}
void?response_err(bf_p?bf,int?eno)
{
????char?state_line[_SIZE_];
????char?err_des[30];//error?description
????memset(state_line,'',sizeof(state_line));
????memset(err_des,sizeof(err_des));
????switch(eno)
????{??????????
????????case?301:
????????????strcpy(err_des,"Removed");
????????????break;
????????case?404:
????????????strcpy(err_des,"Not?Found");
????????????break;
????????case?403:
????????????strcpy(err_des,"Forbid");
????????????break;
????????case?500:
????????????strcpy(err_des,"Inner?Error");
????????????break;
????????case?501:
????????????strcpy(err_des,"Not?execute");
????????????break;
????????default:
????????????break;
????}
????sprintf(state_line,"HTTP/1.0?%d?%srnrn",eno,err_des);
????//printf("state_line:%sn",state_line);
????strcpy(bf->_buf,state_line);
}
void?echo_error(bf_p?bf,int?eno)
{
????switch(eno)
????{??????????????????????????????????????
????????case?301:
????????????response_err(bf,eno);
????????????break;
????????case?404:
????????????response_err(bf,eno);
????????????break;
????????case?403:
????????????response_err(bf,eno);
????????????break;
????????case?500:
????????????response_err(bf,eno);
????????????break;
????????case?501:
????????????response_err(bf,eno);
????????????break;
????????default:
????????????break;
????}
????return;
}
int?get_line(int?sock,int?size)
{
????assert(buf);
????int?i=0;
????ssize_t?_s=-1;
????char?ch='';???????????
//??printf("getLine");
????while(i<size-1&&ch!='n')
????{
????????_s=recv(sock,&ch,1,0);
????????if(_s)
????????{
????????????if(ch=='r')
????????????{
????????????????if((_s=recv(sock,MSG_PEEK)))
????????????????{
????????????????????if(_s>0&&ch=='n')
????????????????????????recv(sock,0);
????????????????}
????????????}
????????????buf[i++]=ch;
????????}
????????else
????????{
????????????buf[i++]='n';
????????????break;
????????}
????}
//??printf("endddddddddddd");
????buf[i]='';
????return?i;
}????????????????????????
void?clear_head(int?sock)
{
????char?buf[_SIZE_];
????buf[0]='';
????ssize_t?_s=1;
????while(_s>0&&strcmp(buf,"n")!=0)
????{
????????_s=get_line(sock,buf,sizeof(buf));
????}
}

void?execute_cgi(bf_p?bf)
{
????int?content_len=0;//post?method?content-length
????ssize_t?_s=-1;
????char?buf[_SIZE_];
????char?method_env[30];
????char?query_env[_SIZE_];
????char?content_len_env[30];
????memset(buf,sizeof(buf));
????memset(method_env,sizeof(method_env));
????memset(query_env,sizeof(query_env));
????memset(content_len_env,sizeof(content_len_env));
????//if?method=get,query_string?not?null,if?method=post,query_string?is?null
????sprintf(method_env,"REQUEST_METHOD=%s",bf->_method);
????putenv(method_env);
????//printf("method:%s,path:%s,query_string:%sn",method,path,query_string);
????if(strcasecmp(bf->_method,"GET")==0)
????{
????????sprintf(query_env,"QUERY_STRING=%s",bf->_query_string);
????????putenv(query_env);
????}
????else
????{
????????while((_s=get_line(bf->_fd,sizeof(buf)))>1)
????????{
????????????if(strncasecmp(buf,"Content-Length:",15)==0)
????????????{
????????????????//printf("length::::::::::%sn",buf);
????????????????content_len=atoi(buf+15);
????????????//??break;//not?break!!!!!!!!!!!!!!!
????????????}
????????}
????????//printf("Content-Length:%dn",content_len);
????????sprintf(content_len_env,"CONTENT_LENGTH=%d",content_len);
????????putenv(content_len_env);
????}
????//printf("ready?envn");
????//ready
????pid_t?id;
????int?in_fds[2];
????int?out_fds[2];?????????????
???if(pipe(in_fds)<0)
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}
????if(pipe(out_fds)<0)?
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}
//??printf("exxxxxxxxxxxxxxx");
????if((id=fork())<0)
????{
????????printLog(strerror(errno),__LINE__);
????????exit(1);
????}
????else?if(id==0)//child
????{
????????close(in_fds[1]);
????????close(out_fds[0]);
????????dup2(in_fds[0],0);
????????dup2(out_fds[1],1);
????????execl(bf->_path,bf->_path,NULL);
????????????
????????close(in_fds[0]);
????????close(out_fds[1]);??????????????????
????}
????else//father
????{
????????close(in_fds[0]);
????????close(out_fds[1]);
????????char?vals[1024];
????????memset(vals,sizeof(vals));
????????ssize_t?_s=-1;
????????int?index=0;
????????char?ch='0';
????????if(strcasecmp(bf->_method,"POST")==0)
????????{
????????????while(index<content_len&&read(bf->_fd,1)>0)
????????????{???
????????????????vals[index++]=ch;
????????????}
????????}
????//??printf("%sn",vals);
????????write(in_fds[1],vals,strlen(vals));
????//??printf("ffffffffffff");
????????memset(bf->_buf,sizeof(bf->_buf));
????????char*?status_line="HTTP/1.0?200?okrnrn";
????????sprintf(bf->_buf,status_line,strlen(status_line));
//??????printf("responsen");
????????int?i=strlen(bf->_buf);
????????while(read(out_fds[0],1)>0)???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
????????{
????????????bf->_buf[i++]=ch;
????????}
????????bf->_buf[i]='';
????????close(in_fds[1]);
????????close(out_fds[0]);
????????waitpid(id);
????}
}
void?echo_html(bf_p?bf)
{
????char*?status_line="HTTP/1.0??200?okrnrn";
????sprintf(bf->_buf,strlen(status_line));
????//printf("%s!!!!!!!!!!!!!!!!n",bf->_buf);
}

void?accept_request(void*?ptr)
{
????bf_p?bf=(bf_p)ptr;
????bf->_err=0;
????int?ret=-1;
????int?i=0,j=0;
????char?url[_SIZE_];
????memset(bf->_method,sizeof(bf->_method));
????memset(bf->_buf,sizeof(bf->_buf));
????memset(bf->_path,sizeof(bf->_path));??????????
????memset(url,sizeof(url));

????if(get_line(bf->_fd,bf->_buf,sizeof(bf->_buf))==0)
????{
????????printLog("errno",__LINE__);
????????return;
????}
????i=j=0;
????while(''!=bf->_buf[i]&&!isspace(bf->_buf[i])&&i<strlen(bf->_buf)&&j<sizeof(bf->_method)-1)
????{
????????bf->_method[j]=bf->_buf[i];//get?method
????????++i;
????????++j;
????}
????bf->_method[j]='';
????//printf("method:%sn",bf->_method);????
????j=0;
????while(''!=bf->_buf[i]&&isspace(bf->_buf[i]))
????{
????????++i;
????}
????while(''!=bf->_buf[i]&&!isspace(bf->_buf[i])&&i<strlen(bf->_buf)&&j<sizeof(url)-1)
????{
????????url[j]=bf->_buf[i];
????????++j;
????????++i;
????}
????url[j]='';
????//printf("url:%sn",url);
????bf->_cgi=0;
????if(strcasecmp(bf->_method,"POST")!=0&&strcasecmp(bf->_method,"GET")!=0)
????{
????????echo_error(bf,500);
????????bf->_err=1;
????????//return;
????}
????bf->_query_string=NULL;
????if(strcasecmp(bf->_method,"POST")==0)
????{
????????bf->_cgi=1;
????????bf->_query_string=NULL;
????}
????if(strcasecmp(bf->_method,"GET")==0)
????{
????????bf->_query_string=url;
????????while(*bf->_query_string!=''&&*bf->_query_string!='?')
????????{
????????????++bf->_query_string;??????????????????
????????}
????????????
????????//printf("query_string::::::::::::::::n");?????
????????if(*bf->_query_string=='?')
????????{
???????????*bf->_query_string='';
???????????bf->_cgi=1;
???????????++bf->_query_string;
????????}
????}
????
????sprintf(bf->_path,"htdocs%s",url);
????struct?stat?st;
????if(stat(bf->_path,&st)<0)//not?exist
????{
????????echo_error(bf,404);
????????bf->_err=1;
????????//return;
????
????}
????else?if(S_IFDIR&st.st_mode)//dir
????{
????????if(strcmp(bf->_path,"htdocs/")!=0)
????????????strcpy(bf->_path,"htdocs/");
????????strcat(bf->_path,_DEF_PAGE_);
????}???????????????????????????????????
???else?if((st.st_mode&S_IXUSR)||(st.st_mode&S_IXGRP)||(st.st_mode&S_IXOTH))
????{
????????bf->_cgi=1;
????}
//??printf("%d:%sn",bf->_cgi,bf->_path);
????if(bf->_err==0)
????{
????????if(bf->_cgi)
????????{
????????????execute_cgi(bf);
????????}
????????else
????????{
????????????clear_head(bf->_fd);
????????????bf->_st_size=st.st_size;
????????????echo_html(bf);
????????}
????}
}??????????????????????????????????????
//cgi_math.h
#include<iostream>
#include<string>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
#include<vector>
#include<assert.h>
using?namespace?std;
#define?INT_64?long?long
#define?UN_INIT??0xcccccccccccccccc//不能分开
#define?MIN_INT?(unsigned)0xffffffff
#define?MAX_INT?(unsigned)0x7fffffff
class?BigData
{
public:
	BigData()
	:_data(0),_pdata("")
	{}
	BigData(INT_64?data)
	:_data(data)
	{
		int?tmp=_data;
		char?symbol='+';
		if(tmp<0)
		{
			symbol='-';
			tmp=0-tmp;
		}
		_pdata.append(1,symbol);
		while(tmp)
		{
			_pdata.append(1,tmp%10+'0');
			tmp/=10;
		}
		char*?str=(char*)_pdata.c_str()+1;
		while(*str=='0')
		{
			++str;
		}
		char*?left=str;
		char*?right=(char*)(_pdata.c_str()+_pdata.size()-1);
		char?temp;
		while(left<right)
		{
			temp=*left;
			*left=*right;
			*right=temp;
			++left;
			--right;
		}
	}
	BigData(const?char*?str)
	{
		assert(str);
		//cout<<str<<endl;
		char*?src=const_cast<char*>(str);
		INT_64?ret=0;
		char?symbol='+';
		if(*src=='+'||*src=='-')
			symbol=*src++;
		_pdata.append(1,symbol);
		while('0'==*src)
			++src;
		while(*src>='0'&&*src<='9')
		{
			if?(ret?<=?MAX_INT)
				ret?=?ret?*?10?+?*src-'0';
			_pdata.append(1,*src);
			++src;
		}
	//	cout<<_pdata<<endl;
		if(symbol=='-')
			ret=0-ret;
		_data=ret;
	}
	BigData?operator+(BigData?db)
	{
		if(!IsINT64OverFlow()&&!db.IsINT64OverFlow())
		{
			if(_pdata[0]!=db._pdata[0])
				return?BigData(_data+db._data);
			else
			{
				if(_pdata[0]=='+'&&MAX_INT-_data>=db._data||_pdata[0]=='-'&&_data>=MIN_INT-db._data)
					return?BigData(_data+db._data);
			}
		}
		BigData?tmp(*this);
		return?BigData(Add(tmp._pdata,db._pdata).c_str());
	}
	BigData?operator-(BigData?db)
	{
		if(!IsINT64OverFlow()&&!db.IsINT64OverFlow())
		{
			if(_pdata[0]==db._pdata[0])
				return?BigData(_data-db._data);
			else
			{
				if(_pdata[0]=='+'&&MAX_INT+db._data>=_data||_pdata[0]=='-'&&_data>=MIN_INT+db._data)
					return?BigData(_data-db._data);
			}
		}
		string?ret;
		BigData?tmp(*this);
		//cout<<tmp;
		if(_pdata[0]==db._pdata[0])
			ret=Sub(tmp._pdata,db._pdata);
		else
		{
			ret=Add(tmp._pdata,db._pdata);
			ret[0]=_pdata[0];
		}
		return?BigData(ret.c_str());
	}
	BigData?operator*(BigData?db)
	{
		if(!IsINT64OverFlow()&&!db.IsINT64OverFlow())
		{
			if(_pdata[0]==db._pdata[0])
			{
				if(_pdata[0]=='+'&&_data<=MAX_INT/db._data||_pdata[0]=='-'&&_data>=MAX_INT/db._data)
					return?BigData(_data*db._data);
			}
			else
			{
				if(_pdata[0]=='+'&&MIN_INT/_data<=db._data||_pdata[0]=='-'&&_data>=MIN_INT/db._data)
						return?BigData(_data*db._data);
			}
		}
		BigData?tmp(*this);
		return?BigData(Mul(tmp._pdata,db._pdata).c_str());
	}
	BigData?operator/(BigData?db)
	{
		if(_data==0||db._data==0)
			return?BigData((INT_64)0);
		if(!IsINT64OverFlow()&&!db.IsINT64OverFlow())
		{
			return?BigData(_data/db._data);
		}
		BigData?tmp(*this);
		return?BigData(Div(tmp._pdata,db._pdata).c_str());
	}
	friend?ostream&?operator<<(ostream&?out,BigData&?db)
	{
		if(!db.IsINT64OverFlow())
		{
				out<<db._data;
				return?out;
		}
		if(db._pdata[0]=='-')
			out<<&db._pdata[0];
		char*?str=(char*)db._pdata.c_str()+1;
		while(*str=='0')
			++str;
		out<<str;
		return?out;
	}
protected:
	bool?IsINT64OverFlow()
	{
		if(_data<=MAX_INT&&_data>=MIN_INT)
			return?false;
		return?true;
	}
	string?Add(string&?s1,string&?s2)
	{
		int?leftSize=s1.size();
		int?rightSize=s2.size();
		char?symbol='+';
		string?ret;
		if(s1[0]==s2[0])
		{
			if(s1[0]=='-')
				symbol='-';
		}
		else
		{
			if(s1[0]=='+'&&strcmp(s1.c_str()+1,s2.c_str()+1)<0||s1[0]=='-'&&strcmp(s1.c_str()+1,s2.c_str()+1)>0)
			{
				symbol='-';
			}
		}
		if(leftSize<rightSize)
		{
			swap(s1,s2);
			swap(leftSize,rightSize);
		}
		ret.resize(leftSize+1);
		memset((void*)ret.c_str(),'0',ret.size()*sizeof(char));
		ret[0]=symbol;
		char?cret,cstep=0;
		for(int?dx=1;dx<leftSize;++dx)
		{
			cret=s1[leftSize-dx]-'0'+cstep;
			if(dx<rightSize)
				cret+=(s2[rightSize-dx]-'0');
			cstep=cret/10;
			ret[leftSize-dx+1]=cret%10+'0';
		}
		ret[1]=cstep+'0';
		return?ret;
	}
	string?Sub(string&?s1,string&?s2)
	{
		int?leftSize=s1.size();
		int?rightSize=s2.size();
		char?symbol=s1[0];
		if(leftSize<rightSize||leftSize==rightSize&&strcmp(s1.c_str()+1,s2.c_str()+1)<0)
		{
			swap(leftSize,rightSize);
			swap(s1,s2);
			if(symbol='+')
				symbol='-';
			else
				symbol='+';
		}
		//cout<<s1<<s2<<endl;
		string?ret;
		ret.resize(leftSize);
		memset((void*)ret.c_str(),ret.size()*sizeof(char));
		ret[0]=symbol;
		char?cret;
		//cout<<ret<<endl;
		//cout<<s1<<s2<<endl;
		for(int?dx=1;dx<leftSize;++dx)
		{
			cret=s1[leftSize-dx]-'0';
			if(dx<rightSize)
			{
				cret-=(s2[rightSize-dx]-'0');
			}
			if(cret<0)
			{
				s1[leftSize-dx-1]-=1;
				cret+=10;
			}
		//	cout<<cret+'0';
			ret[leftSize-dx]=cret+'0';
		}
		return?ret;
	}
	string?Mul(string&?s1,string&?s2)
	{
		int?leftSize=s1.size();
		int?rightSize=s2.size();
		if(leftSize<rightSize)
		{
			swap(leftSize,s2);
		}
		string?ret;
		ret.resize(leftSize+rightSize-1);
		memset((void*)ret.c_str(),ret.size()*sizeof(char));
		char?symbol='+';
		if(s1[0]!=s2[0])
			symbol='-';
		ret[0]=symbol;
		int?dataLen=ret.size();
		int?offSet=0;
		for(int?dx=1;dx<rightSize;++dx)
		{
			char?c1=s2[rightSize-dx]-'0';
			char?cstep=0;
			if(c1==0)
			{
				++offSet;
				continue;
			}
			for(int?ldx=1;ldx<leftSize;++ldx)
			{
				char?cret=c1*(s1[leftSize-ldx]-'0');
				cret+=(cstep+ret[dataLen-ldx-offSet]-'0');
				ret[dataLen-ldx-offSet]=cret%10+'0';
				cstep=cret/10;
			}
			ret[dataLen-offSet-leftSize]=cstep+'0';
			++offSet;
		}
	//	cout<<ret.c_str();
		return?ret;
	}
	string?Div(string&?s1,string&?s2)
	{
		int?leftSize=s1.size();
		int?rightSize=s2.size();
		char?symbol='+';
		if(s1[0]!=s2[0])
			symbol='-';
		if(leftSize<rightSize||leftSize==rightSize&&strcmp(s1.c_str()+1,s2.c_str()+1)<0)
		{
			return?"0";
		}
		else?if(s2=="1"||s2=="-1")
		{
			s1[0]=symbol;
			return?s1;
		}
		char*?left=(char*)s1.c_str()+1;
		char*?right=(char*)s2.c_str()+1;
		int?dataLen=rightSize-1;
		string?ret;
		ret[0]=symbol;
	//	cout<<left<<right<<endl;
		for(int?dx=0;dx<leftSize-rightSize+1;++dx)
		{
			if(!leftStrRight(left,dataLen,right,rightSize-1))
			{
				++dataLen;
				ret.append(1,'0');
				continue;
			}
			else
			{
				ret.append(1,subLoop(left,rightSize-1));
				dataLen+=1;
			}
		}
		//cout<<ret.c_str()<<"RRRR";
		return?ret;
	}
	char?subLoop(char*&?left,int&?leftSize,char*?right,int?rightSize)
	{
		assert(left&&right);
		char?cret='0';
		while(1)
		{
			if?(!leftStrRight(left,?leftSize,?right,?rightSize))
				break;
			int?lLen=leftSize-1;
			int?rLen=rightSize-1;
			while(lLen>=0&&rLen>=0)
			{
				if(left[lLen]<right[rLen])
				{
					if(lLen<1)
						break;
					left[lLen-1]-=1;
					left[lLen]+=10;
				}
				left[lLen]-=right[rLen];
				left[lLen]+='0';
				--lLen;
				--rLen;
			}
			while(*left=='0')
			{
				++left;
				--leftSize;
			}
			cret++;
		}
		return?cret;
	}
	bool?leftStrRight(char*?left,int?leftLen,int?rightLen)
	{
		assert(left&&right);
		if(leftLen>rightLen||leftLen==rightLen&&strcmp(left,right)>0)
			return?true;
		return?false;
	}
private:
	INT_64?_data;
	string?_pdata;		
};
void?analy_query(char?*?query_string,vector<string>&?v);
void?obtain_query_string(string&?query_string);
//cgi_math.cpp
#include"cgi_math.h"
void?analy_query(char?*?query_string,vector<string>&?v)
{
	int?i=strlen(query_string);
	for(;i>0;--i)//obtain
	{
		if(query_string[i-1]=='=')
		{
			v.push_back(&query_string[i]);//i-1+1
		}
		else?if(query_string[i-1]=='&')
		{
			query_string[i-1]='';
		}
	}
}
void?obtain_query_string(string&?query_string)
{
	char?method[1024];
	char?buf[1024];
	memset(buf,sizeof(buf));
	int?content_length=0;
	if(getenv("REQUEST_METHOD"))
	{
		strcpy(method,getenv("REQUEST_METHOD"));
	}
	else
	{
		cout<<strerror(errno)<<endl;
		return;
	}
	if(strcasecmp(method,"GET")==0)
	{
		query_string+=getenv("QUERY_STRING");
	}
	else//POST
	{
		ssize_t?_s=-1;
		if((_s=read(0,sizeof(buf)))>0)
		{
			buf[_s]='';
			query_string+=buf;
		}
	}
	//cout<<query_string;
	//num1=100&num2=200
}
//add.cpp
#include"cgi_math.h"
int?main()
{
	string?query_string;
	obtain_query_string(query_string);
	vector<string>?v;

	analy_query((char*)(query_string.c_str()),v);
	BigData?b1(v[1].c_str());
	BigData?b2(v[0].c_str());
	BigData?ret=b1+b2;
	cout<<b1<<"+"<<b2<<"="<<ret<<endl;
}
//sub.cpp
#include"cgi_math.h"
int?main()
{
	string?query_string;
	obtain_query_string(query_string);
	vector<string>?v;
	analy_query((char*)query_string.c_str(),v);
	BigData?b1(v[1].c_str());
	BigData?b2(v[0].c_str());
	BigData?ret=b1-b2;
	cout<<b1<<"-"<<b2<<"="<<ret<<endl;
}
//mul.cpp
#include"cgi_math.h"
int?main()
{
	string?query_string;
	obtain_query_string(query_string);
	vector<string>?v;
	analy_query((char*)query_string.c_str(),v);
	BigData?b1(v[1].c_str());
	BigData?b2(v[0].c_str());
	//BigData?b1("1234");
	//BigData?b2("2344");
	BigData?ret=b1*b2;
	cout<<b1<<"*"<<b2<<"="<<ret<<endl;
}
//div.cpp
#include"cgi_math.h"
int?main()
{
	string?query_string;
	obtain_query_string(query_string);
	vector<string>?v;
	analy_query((char*)query_string.c_str(),v);
	BigData?b1(v[1].c_str());
	BigData?b2(v[0].c_str());
	//BigData?b1("1234");
	//BigData?b2("12");
	BigData?ret=b1/b2;
	cout<<b1<<"/"<<b2<<"="<<ret<<endl;
}
//remain.cpp
#include"cgi_math.h"
int?main()
{
	string?query_string;
	obtain_query_string(query_string);
	vector<string>?v;
	analy_query((char*)query_string.c_str(),v);
	BigData?num1(v[1].c_str());
	BigData?num2(v[0].c_str());
	//BigData?num1(1234);
	//BigData?num2(12);
	BigData?num4=num1/num2;
	//cout<<num4<<endl;
	BigData?num5=num4*num2;
	//cout<<num5<<endl;
	BigData?num6=num1-num5;
	//cout<<num3<<num5;
		
	cout<<num1<<"%"<<num2<<"="<<num6<<endl;
}
//Makefile
.PHONY:all?
all:cgi_add?cgi_sub?cgi_mul?cgi_div?cgi_remain

cgi_add:cgi_add.cpp?cgi_math.cpp
	g++?-o?$@?$^
cgi_sub:cgi_sub.cpp?cgi_math.cpp
	g++?-o?$@?$^
cgi_mul:cgi_mul.cpp?cgi_math.cpp
	g++?-o?$@?$^
cgi_div:cgi_div.cpp?cgi_math.cpp
	g++?-o?$@?$^
cgi_remain:cgi_remain.cpp?cgi_math.cpp
	g++?-o?$@?$^
.PHONY:clean
clean:
	rm?-f?cgi_add?cgi_sub?cgi_mul?cgi_div?cgi_remain
//总的Makefile
ROOT_PATH=$(shell?pwd)
LDFLAGS=-lpthread
FLAGS=#_DEBUG1_
CC=gcc
BIN=httpd

CGI_BIN=htdocs/cgi_bin
SRC=$(shell?ls?*.c)
OBJ=$(SRC:.c=.o)

$(BIN):$(OBJ)
	@echo?"Linking?[$^]?to?[$@]"
	@$(CC)?-o?$@?$^?$(LDFLAGS)
	@echo?"Linking?done..."
%.o:%.c
	@echo?"Compling?[$<]?to?[$@]"
	@$(CC)?-c?$<
	@echo?"Compling?done..."
.PHONY:clean
clean:
	@rm?-rf?*.o?$(BIN)?output
	@for?name?in?`echo?$(CGI_BIN)`;
	do
		cd?$$name;
		make?clean;
		cd?-;
	done


.PHONY:cgi
cgi:
	@for?name?in?`echo?$(CGI_BIN)`;
	do
		cd?$$name;
		make;
		cd?-;
	done

.PHONY:output
output:$(BIN)?cgi
	@mkdir?-p?output/log
	@cp?-rf?htdocs?output
	@mkdir?-p?output/htdocs/cgi_bin
	@cp?-f?httpd?output/
	@cp?-f?start.sh?output/
	@cp?-rf?conf?output
	@for?name?in?`echo?$(CGI_BIN)`;
	do
		cd?$$name;
		make?output;
		cd?-;
	done
//main.c
#include"http.h"
int?main(int?argc,char*?argv[])
{
	if(argc!=3)
	{
		usage(argv[0]);
		return?1;
	}
	char*?ip=argv[1];
	int?port=atoi(argv[2]);
	int?listen_sock=startup(ip,port);
	struct?sockaddr_in?client;
	socklen_t?len=sizeof(client);
	int?epo_fd=epoll_create(256);
	if(epo_fd<0)//success:not?0?fd/error:-1
	{
		printLog(strerror(errno),__LINE__);
		return?-1;
	}
	bf_p?fd_bf=(bf_p)malloc(sizeof(bf_t));
	memset(fd_bf->_buf,sizeof(fd_bf->_buf));
	fd_bf->_fd=listen_sock;
	struct?epoll_event?ev;
	ev.events=EPOLLIN;
	ev.data.fd=listen_sock;
	if(epoll_ctl(epo_fd,EPOLL_CTL_ADD,listen_sock,&ev)<0)//success:0?fail:-1
	{
		printLog(strerror(errno),__LINE__);
		return?-1;
	}
	struct?epoll_event?evfds[_SIZE_];//_SIZE_?1024
	int?_timeout=5000;
	int?ret=-1;
	
	int?i=0;
	while(1)
	{
		switch((ret=epoll_wait(epo_fd,evfds,_SIZE_,_timeout)))
		{
			case?-1://error
				printLog(strerror(errno),__LINE__);
				break;
			case?0://time?out
				printf("time?out...n");
				break;
			default://normal
				{
					for(i=0;i<ret;++i)
					{
						if(evfds[i].data.fd==listen_sock&&evfds[i].events&EPOLLIN)
						{
							int?new_sock=accept(listen_sock,(struct?sockaddr*)&client,&len);
							if(new_sock<0)
							{
								printLog(strerror(errno),__LINE__);
								continue;
							}
							bf_p?_bf=(bf_p)malloc(sizeof(?bf_t));
							memset(_bf->_buf,sizeof(_bf->_buf));
							_bf->_fd=new_sock;

							ev.events=EPOLLIN;
							ev.data.ptr=_bf;
							epoll_ctl(epo_fd,new_sock,&ev);
						}
						else?if(((bf_p)(evfds[i].data.ptr))->_fd>0&&evfds[i].events&EPOLLIN)
						{
							accept_request(evfds[i].data.ptr);
							ev.events=EPOLLOUT;
							ev.data.ptr=evfds[i].data.ptr;
							epoll_ctl(epo_fd,EPOLL_CTL_MOD,((bf_p)(evfds[i].data.ptr))->_fd,&ev);
						}
						else?if(((bf_p)(evfds[i].data.ptr))->_fd>0&&evfds[i].events&EPOLLOUT)
						{
							bf_p?_bf=(bf_p)evfds[i].data.ptr;
							if(_bf->_err)
							{
								send(_bf->_fd,_bf->_buf,strlen(_bf->_buf),0);
							}
							else?if(_bf->_cgi)//cgi=1
							{
								send(_bf->_fd,0);
							}
							else
							{
								char*?path=_bf->_path;
								int?fd=open(path,O_RDONLY);
								if(fd<0)
								{
									printLog(strerror(errno),__LINE__);
									exit(1);
								}
								send(_bf->_fd,0);
								if(sendfile(_bf->_fd,fd,NULL,_bf->_st_size)<0)
								{
									printf("error");
								}
								close(fd);
							}
		
							epoll_ctl(epo_fd,EPOLL_CTL_DEL,_bf->_fd,NULL);
							close(_bf->_fd);
							free(_bf);
						}
					}

					break;
				}
		}
	}
	return?0;
}

（编辑：东莞站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!