web服务器

程序员文章站 2022-05-08 23:52:19

...

// myserver_threadpool.h
#ifndef MYSERVER_THREADPOOL_H
#define MYSERVER_THREADPOOL_H

#include<list>
#include<cstdio>
#include<exception>
#include<pthread.h>
#include"locker.h"

template<typename T>
class myserver_threadpool
{
	public:
	myserver_threadpool(int thread_number=0,int max_requests=10000);
	~myserver_threadpool();
	bool append(T* request);
	private:
	static void* worker(void* arg);
	void run();
	private:
	int m_thread_number;
	int m_max_requests;
	pthread_t* m_threads;
	std::list<T* > m_workqueue;
	locker m_queuelocker;
	sem m_queuestat;
	bool m_stop;
};

template<typename T>
myserver_threadpool<T>::myserver_threadpool(int thread_number,int max_requests):m_thread_number(thread_number),m_max_requests(max_requests),m_stop(false),m_threads(NULL)
{
	if((thread_number<=0)||(max_requests<=0))
	{
		printf("error1\n");
		throw std::exception();
	}
	m_threads=new pthread_t[m_thread_number];
	if(!m_threads)
	{
		printf("error2\n");
		throw std::exception();
	}
	for(int i=0;i<thread_number;i++)
	{
		printf("create the %dth thread\n",i);
		if(pthread_create(m_threads+i,NULL,worker,this)!=0)
		{
			delete  [] m_threads;
			throw std::exception();
		}
		if(pthread_detach(m_threads[i]))
		{
			delete[] m_threads;
			throw std::exception();
		}
	}
}
template<typename T>
myserver_threadpool<T>::~myserver_threadpool()
{
	delete[] m_threads;
	m_stop=true;
}

template<typename T>
bool myserver_threadpool<T>::append(T* request)
{
	m_queuelocker.lock();
	if(m_workqueue.size() > m_max_requests)
	{
		m_queuelocker.unlock();
		return false;
	}
	m_workqueue.push_back(request);
	m_queuelocker.unlock();
	m_queuestat.post();
	printf("running append() successfully\n");
	return true;
}

template<typename T>
void* myserver_threadpool<T>::worker(void* arg)
{
	myserver_threadpool* pool=(myserver_threadpool*)arg;
	printf("exec pool->run()\n");
	pool->run();
	printf("finish run()\n");
	return pool;
}

template<typename T>
void myserver_threadpool<T>::run()
{
	while(!m_stop)
	{
		printf("the next running is wait()\n");
		m_queuestat.wait();
		printf("finish wait()\n");
		m_queuelocker.lock();
		if(m_workqueue.empty())
		{
			m_queuelocker.unlock();
			continue;
		}
		T* request = m_workqueue.front();
		m_workqueue.pop_front();
		m_queuelocker.unlock();
		if(!request)
		{
			continue;
		}
		printf("the next running is process()\n");
		request->process();
		printf("finish process()\n");
	}
}
#endif




// my_server.cpp

#define MAX_FD 1024
extern void addfd(int epollfd,int fd,bool one_shot);
extern void modfd(int epollfd,int fd,int ev);
void addsig(int sig,void(handler)(int),bool restart=true)
{
struct sigaction sa;
memset(&sa,'\0',sizeof(sa));
sa.sa_handler=handler;
if(restart)
{
sa.sa_flags|=SA_RESTART;
}
sigfillset(&sa.sa_mask);
assert(sigaction(sig,&sa,NULL)!=-1);
}

void show_error(int connfd,const char* info)
{
printf("%s",info);
send(connfd,info,strlen(info),0);
close(connfd);
}

void close_conn(int epollfd,int fd)
{
epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,0);
close(fd);
}

int main(int argc,char* argv[])
{
if(argc<=2)
{
printf("usage %s ip_address port_number\n",basename(argv[0]));
return 1;
}
const char* ip=argv[1];
int port=atoi(argv[2]);
addsig(SIGPIPE,SIG_IGN);

myserver_threadpool<service>* pool=NULL;
pool=new myserver_threadpool<service>(3);

service* users=new service[MAX_FD];
assert(users);
int user_count=0;

int listenfd=socket(PF_INET,SOCK_STREAM,0);
assert(listenfd>=0);
struct linger tmp={1,0};
setsockopt(listenfd,SOL_SOCKET,SO_LINGER,&tmp,sizeof(tmp));

int ret=0;
struct sockaddr_in address;
bzero(&address,sizeof(address));
address.sin_family=AF_INET;
inet_pton(AF_INET,ip,&address.sin_addr);
address.sin_port=htons(port);

ret=bind(listenfd,(struct sockaddr*)&address,sizeof(address));
assert(ret>=0);

ret=listen(listenfd,5);
assert(ret>=0);

epoll_event events[5];
int epollfd=epoll_create(5);
assert(epollfd!=-1);
addfd(epollfd,listenfd,false);
service::m_epollfd=epollfd;
while(1)
{
int number=epoll_wait(epollfd,events,5,-1);

for(int i=0;i<number;i++)
{
int sockfd=events[i].data.fd;
if(sockfd==listenfd)
{
struct sockaddr_in client_address;
socklen_t client_addrlength=sizeof(client_address);
int connfd=accept(listenfd,(struct sockaddr*)&client_address,&client_addrlength);
if(connfd<0)
{
printf("errno is: %d\n",errno);
continue;
}
printf("There is a new connection\n");
users[connfd].init(connfd,client_address);

}
else if(events[i].events&(EPOLLRDHUP|EPOLLHUP|EPOLLERR))
{
printf("events is EPOLLRDHUP|EPOLLHUP|EPOLLERR\n");
users[sockfd].close_conn();
}
else if(events[i].events&EPOLLIN)
{
printf("events is EPOLLIN\n");
sockfd=events[i].data.fd;
if(sockfd<0)
continue;
if(users[sockfd].sread())
{
pool->append(users+sockfd);
}
else
{
users[sockfd].close_conn();
}
}
else if(events[i].events&EPOLLOUT)
{
printf("events is EPOLLOUT\n");
sockfd=events[i].data.fd;
if(users[sockfd].swrite())
{
//users[sockfd].close_conn();
}
}
}
}
close(epollfd);
close(listenfd);
delete [] users;
delete pool;
return 0;
}

// service.h

#ifndef SERVICE_H
#define SERVICE_H

#include<unistd.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/epoll.h>
#include<fcntl.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#include<string.h>
#include<sys/stat.h>
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
#include<errno.h>
#include<time.h>
#include"locker.h"
class service
{
public:
static const int READ_BUFFER_SIZE=2048;
static const int WRITE_BUFFER_SIZE=1024;
static const int FILE_BUFFER_SIZE=2048;
enum METHOD {GET=0,POST,HEAD,PUT,DELETE,TRACE,OPTIONS,CONNECT,PATCH};
enum CHECK_STATE {CHECK_STATE_REQUESTLINE=0,CHECK_STATE_HEADER,CHECK_STATE_CONTENT};
enum HTTP_CODE {NO_REQUEST,GET_REQUEST,BAD_REQUEST,NO_RESOURCE,FORBIDDEN_REQUEST,FILE_REQUEST,INTERNAL_ERROR,CLOSED_CONNECTION};
enum LINE_STATUS{LINE_OK=0,LINE_BAD,LINE_OPEN};
public:
service(){};
~service(){};

public:
void init(int sockfd,const sockaddr_in& addr);
void close_conn(bool real_close=true);
void process();
bool sread();
bool swrite();

private:
void init();
bool send_http_head(int conn_socket, int status, char *s_status, char *filetype);
HTTP_CODE process_read();
int send_html();
void add_page_error(int status,char* s_status,char* msg);
void add_http_head(int status, char *s_status, char *filetype);
bool process_write(HTTP_CODE ret);
bool add_response(const char* format,...);
void do_url();

bool add_content(const char* content);
bool add_status_line(int status,const char* title);
bool add_headers(int content_length);
bool add_content_length(int content_length);
bool add_blank_line();
bool add_date();

char* get_line(){return read_buf+m_start_line;}
LINE_STATUS parse_line();

HTTP_CODE parse_request_line(char* text);

public:
static int m_epollfd;
static int m_user_count;

private:
int m_sockfd;
sockaddr_in m_address;
int m_read_idx;
int m_checked_idx;
int m_start_line;
int m_write_idx;

CHECK_STATE m_check_state;
char* m_method=new char[100];

char* m_url=new char[100];
char* m_version=new char[100];
char* m_host;
int m_content_length;

char read_buf[READ_BUFFER_SIZE];
char write_buf[WRITE_BUFFER_SIZE];
char file_buf[FILE_BUFFER_SIZE];

char* m_file_address;
struct stat m_file_stat;
};
#endif

// locker.h

#ifndef LOCKER_H
#define LOCKER_H

#include<exception>
#include<pthread.h>
#include<semaphore.h>
class sem
{
public:
sem()
{
if(sem_init(&m_sem,0,0)!=0)
{
throw std::exception();
}
}
~sem()
{
sem_destroy(&m_sem);
}
bool wait()
{
return sem_wait(&m_sem)==0;
}
bool post()
{
return sem_post(&m_sem)==0;
}
private:
sem_t m_sem;
};
class locker
{
public:
locker()
{
if(pthread_mutex_init(&m_mutex,NULL)!=0)
{
throw std::exception();
}
}
~locker()
{
pthread_mutex_destroy(&m_mutex);
}
bool lock()
{
return pthread_mutex_lock(&m_mutex)==0;
}
bool unlock()
{
return pthread_mutex_unlock(&m_mutex)==0;
}
private:
pthread_mutex_t m_mutex;
};
class cond
{
public:
cond()
{
if(pthread_mutex_init(&m_mutex,NULL)!=0)
{
throw std::exception();
}
if(pthread_cond_init(&m_cond,NULL)!=0)
{
pthread_mutex_destroy(&m_mutex);
throw std::exception();
}
}
~cond()
{
pthread_mutex_destroy(&m_mutex);
pthread_cond_destroy(&m_cond);
}
bool wait()
{
int ret=0;
pthread_mutex_lock(&m_mutex);
ret=pthread_cond_wait(&m_cond,&m_mutex);
pthread_mutex_unlock(&m_mutex);
return ret==0;
}

bool signal()
{
return pthread_cond_signal(&m_cond)==0;
}
private:
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;
};
#endif

// my_server.cpp