simple_http_serv.hpp

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <vector>
#include <cctype>
#include <thread>
#include <unordered_map>
#include <time.h>
#include <fstream>
#include <sstream>
#include <set>

#define MAX_EVENTS 64
#define buff_size 512
#define timeout 5.0
#define max_clients 10

std::string ipp;
std::string mount_point;

struct resource{
	std::string file_path;
	std::string content_type;
};

struct http_request{
    std::string method;
    std::string target;
    std::string http_version;
    std::unordered_map<std::string, std::string> headers;
    std::string buff;

    void reset(){
        method.clear();
        target.clear();
        http_version.clear();
        headers.clear();
    }
};

struct client_rr{
    http_request request;
	std::string response;
    time_t start = time(0);
    bool close_after_send = false;
    bool send = false;
	bool bad_request = false;
	bool timed_out = false;
	bool unsupported_version = false;
	bool no_resource = false;
	bool keep_alive = true;
	bool unsupported_method = false;
};

bool is_ws(char c){
	return c == ' ' || c == '\t';
}

bool is_token(char c){
	if(std::isalnum(static_cast<unsigned char>(c)))
		return true;

    if(c == '!' || c == '#' || c == '$' || c == '%' || c == '&' ||
        c == '\'' || c == '*' || c == '+' || c == '-' || c == '.' ||
        c == '^' || c == '_' || c == '`' || c == '|' || c == '~')
        return true;

	return false;
}

bool is_pchar(char c){
	if(std::isalnum(static_cast<unsigned char>(c)))
		return true;

	if(c == '-' || c == '.' || c == '_' || c == '~' || c == '!' || c == '$' ||
        c == '&' || c == '\'' || c == '(' || c == ')' || c == '*' || c == '+' ||
        c == ',' || c == ';' || c == '=' || c == ':' || c == '@')
        return true;

	return false;
}

bool is_vchar(char c){
    return c >= '!' && c <= '~';
}

bool get_method(std::string& s, const std::string& buff, size_t& index, const size_t end){
	if(index >= end || !is_token(buff[index]))
		return false;

	int start = index;
	while(index < end && is_token(buff[index])){
		++index;
	}

	if(index >= end || buff[index] != ' ')
		return false;

	s.append(buff, start, index - start);

	++index;

	return true;
}

bool get_target(std::string& s, const std::string& buff, size_t& index, const size_t end){
	if(index >= end || buff[index] != '/')
		return false;

	int start = index;

	while(index < end && (is_pchar(buff[index]) || buff[index] == '/' || buff[index] == '%')){
		if(buff[index] == '%'){
			if(index + 2 >= end)
				return false;

			if(!std::isxdigit(static_cast<unsigned char>(buff[index + 1])) || !std::isxdigit(static_cast<unsigned char>(buff[index + 2])))
				return false;

			index += 3;
			continue;
		}

		++index;
	}

	if(index < end && buff[index] == '?'){
		++index;
		while(index < end && (is_pchar(buff[index]) || buff[index] == '?' || buff[index] == '/' || buff[index] == '%')){
			if(buff[index] == '%'){
				if(index + 2 >= end)
					return false;

				if(!std::isxdigit(static_cast<unsigned char>(buff[index + 1])) || !std::isxdigit(static_cast<unsigned char>(buff[index + 2])))
					return false;

				index += 3;
				continue;
			}
			++index;
		}
	}

	if(index >= end || buff[index] != ' ')
		return false;

	s.append(buff, start, index - start);

	++index;

	return true;
}

bool get_version(std::string& s, const std::string& buff, size_t& index, const size_t end){
	int start = index;

	while(index < end && buff[index] != '\r')
		++index;

	if(index + 1 >= end)
		return false;

	if(buff[index] != '\r' || buff[index + 1] != '\n')
		return false;

	s.append(buff, start, index - start);
	index+=2;

	if(s == "HTTP/1.0")
		return true;

	if(s == "HTTP/1.1")
		return true;

	return false;
}

bool get_field_name(std::string& s, const std::string& buff, size_t& index, const size_t end){
	if(index >= end || !is_token(buff[index]))
		return false;

	size_t start = index;
	while(index < end && is_token(buff[index]))
		++index;

	if(index >= end || buff[index] != ':')
		return false;

	s.append(buff, start, index - start);

	++index;

	return true;
}

bool get_field_value(std::string& s, const std::string& buff, size_t& index, const size_t end){
	while(index < end && is_ws(buff[index]))
		++index;

	if(index >= end)
		return false;

	size_t start = index;
	while(index < end && (is_ws(buff[index]) || is_vchar(buff[index])))
		++index;

	if(index >= end || buff[index] != '\r')
		return false;

	if(index + 1 >= end || buff[index + 1] != '\n')
		return false;

	size_t back = index;

	while(back > start && is_ws(buff[back - 1]))
		--back;

	s.append(buff, start, back - start);

	index += 2;

	return true;
}

bool get_headers(std::unordered_map<std::string, std::string>& headers, const std::string& buff, size_t& index, const size_t end){
	while(index < end){
		std::string hf, fv;

		if(!get_field_name(hf, buff, index, end))
			return false;

		if(headers.count(hf) > 0)
			return false;

		if(!get_field_value(fv, buff, index, end))
			return false;

		headers[hf] = fv;
	}

	return true;
}

bool handle_request(http_request& request, const size_t end){
    size_t index = 0;

    if(!get_method(request.method, request.buff, index, end + 2))
		return false;

	if(!get_target(request.target, request.buff, index, end + 2))
		return false;

	if(!get_version(request.http_version, request.buff, index, end + 2))
		return false;

	if(!get_headers(request.headers, request.buff, index, end + 2))
		return false;

	return true;
}

std::unordered_map<std::string, resource> resources; 

bool check_method(const std::string& method){
	return method == "GET" || method == "HEAD";
}

bool check_target(const std::string& target){
	return resources.find(target) != resources.end();
}

bool check_version(const std::string& version){
	return version == "HTTP/1.0" || version == "HTTP/1.1";
}

bool check_headers(std::unordered_map<std::string, std::string>& headers){
	if(headers.find("Host") == headers.end())
		return false;

	if(headers["Host"] != ipp)
		return false;

	if(headers.find("Content-Length") != headers.end() && stoi(headers["Content-Length"]) > 0)
		return false;

	if(headers.find("Transfer-Encoding") != headers.end())
		return false;

	return true;
}

void interperet_request(client_rr& client){
	http_request& request = client.request;
    if(!check_method(request.method))
		client.unsupported_method = true;

	if(!check_target(request.target))
		client.no_resource = true;

	if(!check_version(request.http_version))
		client.unsupported_version = true;

	if(!check_headers(request.headers))
		client.bad_request = true;

	if(request.headers.find("Connection") != request.headers.end()){
        const std::string& s = request.headers.at("Connection");
		if(s == "close" || s == "Close" || s == "CLOSE")
			client.keep_alive = false;
	}
}

void gen_response(client_rr& client){
	std::string& response = client.response;
	http_request& cur_req = client.request;
	time_t t = time(nullptr);
	tm t_m{};
	gmtime_r(&t, &t_m);
	char buff[32];
	strftime(buff, sizeof(buff), "%a, %d %b %Y %H:%M:%S GMT", &t_m);

	std::string date(buff);

	client.close_after_send = true;

	if(client.bad_request){
		response = "HTTP/1.1 400 Bad Request\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	if(client.unsupported_method){
		response = "HTTP/1.1 405 Method Not Allowed\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	if(client.timed_out){
		response = "HTTP/1.1 408 Request Timeout\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	if(client.no_resource){
		response = "HTTP/1.1 404 Not Found\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	if(client.unsupported_version){
		response = "HTTP/1.1 505 Version Not Supported\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	std::ifstream file_to_send(resources[cur_req.target].file_path, std::ios::binary);
	if(!file_to_send.is_open() ){
		file_to_send.close();
		response = "HTTP/1.1 500 Internal Server Error\r\n"
			"Date: " + date + "\r\n"
			"Connection: close\r\n\r\n";
		return;
	}

	std::ostringstream oss;
	oss << file_to_send.rdbuf();
	std::string body = oss.str();
	std::string body_len;

	std::string connection;

	if(!client.keep_alive)
		connection = "Connection: close\r\n";
	else{
		connection = "Connection: keep-alive\r\n";
		client.close_after_send = false;
	}

	response = "HTTP/1.1 200 OK\r\n"
		"Date: " + date + "\r\n"
		"Content-Type: " + resources[cur_req.target].content_type + "\r\n" + 
		connection + 
		"Content-Length: " + std::to_string(body.size()) + "\r\n\r\n" + body;
}

void set_mount_point(const std::string& mount_p){
	mount_point = mount_p;
}

void add_resource(const std::string& abs_path, const std::string& file_path, const std::string& content_type){
	resources[abs_path] = resource{mount_point + file_path, content_type};
}

void handle_client(int epollfd){
    int nfds, clientfd;
    char recv_buff[buff_size];
    epoll_event ev, events[MAX_EVENTS];
    bool alive;
    std::unordered_map<int, client_rr> clients;

	struct client_timer{
		std::unordered_map<int, client_rr>* clients;

		bool operator()(const int a, const int b) const{
			if(clients->at(a).start != clients->at(b).start)
				return clients->at(a).start < clients->at(b).start;
			return a < b;
		}
    };
    

    client_timer ct{&clients};
    std::set<int, client_timer> client_timers(ct);

    while(1){
        if(nfds == -1){
            std::cerr << "epoll wait\n";
            std::exit(EXIT_FAILURE);
        }

        nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        
        for(int n = 0; n < nfds; ++n){
            clientfd = events[n].data.fd;
            alive = true;

            if(clients.find(clientfd) == clients.end()){
                clients.emplace(clientfd, client_rr{});
                client_timers.emplace(clientfd);
            }

            http_request& cur_req = clients.at(clientfd).request;
            
            while(true){
                if(!clients.at(clientfd).send){
                    ssize_t bytes_recv = recv(clientfd, recv_buff, buff_size, 0);

                    if(bytes_recv == -1){
                        if(errno == EAGAIN || errno == EWOULDBLOCK){
                            break;
                        }

						if(errno == EPIPE || errno == ECONNRESET){
							alive = false;
                            client_timers.erase(clientfd);
							close(clientfd);
							clients.erase(clientfd); 
							break;
						}

                        std::cerr << "Error receiving on client: " << clientfd << std::endl;
                        std::exit(EXIT_FAILURE);
                    }

                    if(bytes_recv == 0){
                        alive = false;
                        client_timers.erase(clientfd);
                        close(clientfd);
                        clients.erase(clientfd);
                        break;
                    }
                    cur_req.buff.append(recv_buff, bytes_recv);

                    size_t position = cur_req.buff.find("\r\n\r\n");

                    if(position != std::string::npos){
                        clients.at(clientfd).send = true;
                        client_timers.erase(clientfd);
                        clients.at(clientfd).start = time(0);
                        client_timers.emplace(clientfd);

                        if(!handle_request(cur_req, position)){
                            std::cout << "request parsing failed\n";
                            clients.at(clientfd).close_after_send = true;
							clients.at(clientfd).bad_request = true;
                            break;
                        }

						interperet_request(clients.at(clientfd));

                        cur_req.buff.erase(0, position + 4);
                    }
                }
                else{
					gen_response(clients.at(clientfd));
                    cur_req.reset();
					std::string& response = clients.at(clientfd).response;
					ssize_t bytes_sent = send(clientfd, response.c_str(), response.size(), MSG_NOSIGNAL);

					if(bytes_sent == -1){

                        if(errno == EAGAIN || errno == EWOULDBLOCK){
                            break;
                        }

						if(errno == EPIPE || errno == ECONNRESET){
							alive = false;
                            client_timers.erase(clientfd);
							close(clientfd);
							clients.erase(clientfd); 
							break;
						}

                        std::cerr << "Error sending on client: " << clientfd << std::endl;
                        std::exit(EXIT_FAILURE);
                    }

					if(bytes_sent == response.size()){
						if(clients.at(clientfd).close_after_send){
							alive = false;
                            client_timers.erase(clientfd);
							close(clientfd);
							clients.erase(clientfd);
                            break;
						}

                        clients.at(clientfd).send = false;
                        client_timers.erase(clientfd);
                        clients.at(clientfd).start = time(0);
                        client_timers.emplace(clientfd);
						break;
					}

					response.erase(0, bytes_sent);
                }
            }

            if(!alive)
                continue;

            if(!clients.at(clientfd).send){
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = clientfd;
                if(epoll_ctl(epollfd, EPOLL_CTL_MOD, clientfd, &ev) == -1){
                    if(errno == ENOENT)
                        continue;
                    std::cerr << "epoll_ctl: " << clientfd << std::endl;
                    std::exit(EXIT_FAILURE);
                }
            }
            else{
                ev.events = EPOLLOUT | EPOLLET;
                ev.data.fd = clientfd;
                if(epoll_ctl(epollfd, EPOLL_CTL_MOD, clientfd, &ev) == -1){
                    if(errno == ENOENT)
                        continue;
                    std::cerr << "epoll_ctl: " << clientfd << std::endl;
                    std::exit(EXIT_FAILURE);
                }
            }
        }
        
        auto index = client_timers.begin();
        while(index != client_timers.end()){
            clientfd = *index;
            client_rr& cur = clients.at(clientfd);
            double time_alive = difftime(time(0), cur.start);
            if(time_alive > timeout){
                index = client_timers.erase(index);
                close(clientfd);
                clients.erase(clientfd);
                continue;
            }
            break;
        }
    }
}

void accept_loop(int servfd, int* epollfds, int thread_count){
    int clientfd;
    epoll_event ev;
    sockaddr_storage cli_addr{};
    socklen_t cli_len = sizeof(cli_addr);
    int epollfd = 0;

    while(1){
    	clientfd = accept4(servfd, (sockaddr*)&cli_addr, &cli_len, SOCK_NONBLOCK);

    	epollfd = epollfd % thread_count;

		if(clientfd == -1){
			std::cerr << "accept\n";
			std::exit(EXIT_FAILURE);
		}
		ev.events = EPOLLIN | EPOLLET;
		ev.data.fd = clientfd;
		if(epoll_ctl(epollfds[epollfd], EPOLL_CTL_ADD, clientfd, &ev) == -1){
			std::cerr << "epoll_ctl: " << clientfd << std::endl;
			std::exit(EXIT_FAILURE);
		}

		++epollfd;
		cli_len = sizeof(cli_addr);
    }
}

void start_server(std::string ip, std::string port, int thread_count){
    int serv_addr, servfd, nfds;
    int epollfds[thread_count];
    addrinfo hints{};
    addrinfo* results, *result_p;
    epoll_event ev, events[MAX_EVENTS];

    hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = 0;
	hints.ai_family = AF_UNSPEC;

	ipp = ip + ":" + port;

    serv_addr = getaddrinfo(ip.c_str(), port.c_str(), &hints, &results);
    if(serv_addr != 0){
        std::cerr << "getaddrinfo: " << gai_strerror(serv_addr) << std::endl;
        std::exit(EXIT_FAILURE);
    }

    for(result_p = results; result_p != nullptr; result_p = result_p->ai_next){
		servfd = socket(result_p->ai_family, result_p->ai_socktype, result_p->ai_protocol);

		if(servfd == -1)
			continue;
		
		if(bind(servfd, result_p->ai_addr, result_p->ai_addrlen) == 0){
			break;
		}

		close(servfd);
	}

    freeaddrinfo(results);

    if(result_p == nullptr){
		std::cerr << "Couldn't bind socket\n";
		std::exit(EXIT_FAILURE);
	}

	if(listen(servfd, SOMAXCONN) != 0){
		std::cerr << "failed listen\n";
		std::exit(EXIT_FAILURE);
	}

    for(int i = 0; i < thread_count; ++i){
        epollfds[i] = epoll_create1(0);
        std::thread(handle_client, epollfds[i]).detach();
    }

    accept_loop(servfd, epollfds, thread_count);
}