request.cpp

#include "request.hpp"
#include <poll.h>

std::map<std::string, std::string>	get_current_pair(std::map<std::string, std::string> request_info, const char *buffer, unsigned int *i, long read_ret) {
	std::string		key;
	std::string		value;
	unsigned int	j = *i;

	for (; buffer[j] != ':' && j < read_ret; j++) {
		key.push_back(buffer[j]);
	}
	j += 2;
	for (; buffer[j] != '\r' && j < read_ret; j++) {
		value.push_back(buffer[j]);
	}

	j++;
	*i = j;

	request_info.insert(std::pair<std::string, std::string>(key, value));

	key.clear();
	value.clear();
	return(request_info);
}

std::map<std::string, std::string>	get_first_line(std::map<std::string, std::string> request_info, const char *buffer, unsigned int *i, long read_ret) {
	std::string		value;
	unsigned int	j = *i;
	
	for (; buffer[j] != ' ' && j < read_ret; j++) {
		value.push_back(buffer[j]);
	}
	j++;
	request_info.insert(std::pair<std::string, std::string>("Method", value));
	value.clear();
	for (; buffer[j] != ' ' && j < read_ret; j++) {
		value.push_back(buffer[j]);
	}
	j++;
	request_info.insert(std::pair<std::string, std::string>("Request-URI", value));
	value.clear();
	for (; buffer[j] != '\r' && j < read_ret; j++) {
		value.push_back(buffer[j]);
	}
	j += 2;

	request_info.insert(std::pair<std::string, std::string>("Version", value));
	value.clear();

	*i = j;
	return (request_info);
}

#define BUFSIZE 100024


void split_up_request(t_request *request) {
	std::map<std::string, std::string>	request_info;
	unsigned int 						i = 0;

	request_info = get_first_line(request_info, request->whole_request.c_str(), &i, request->whole_request.size());
	while (request->whole_request[i] != '\r' && i < request->whole_request.size()) {
		request_info = get_current_pair(request_info, request->whole_request.c_str(), &i, request->whole_request.size());
		i++;
	}
	i++;

	request->headers = request_info;

	if (i < request->whole_request.size())
		request->body = request->whole_request.substr(i, request->whole_request.size() - i);
}

size_t get_content_length(std::string request) {
	size_t pos = request.find("Content-Length");
	if (pos == std::string::npos)
		return -1;
	size_t length = atoi(&request[pos + 16]);
	return length;
}

int done(t_request *request, int socket) {
	if (!request->header_size || request->header_size == std::string::npos) {
		request->header_size = request->whole_request.find("\r\n\r\n");
		if (request->header_size == std::string::npos)
			return 0;
	}
	if (request->content_lenght <= 0)
		request->content_lenght = get_content_length(request->whole_request);
	if (!request->request_size)
		request->request_size = request->content_lenght + request->header_size;
	if (request->request_size > 0 && request->request_size <= request->whole_request.size()) {
		char	buffer[BUFSIZE] = {0};

		request->state = RS_PROCESSING;
		read(socket, buffer, BUFSIZE);
		split_up_request(request); //after request is done
		return 1;
	}
	return 0;
}

void	get_request_info(int socket, t_request *request, std::string *resp) {
	char								buffer[BUFSIZE] = {0};
	long								read_ret;
	std::string							value;
	struct pollfd 						pfd;

	pfd.events = POLLIN | POLLOUT;
	pfd.revents = 0;
	pfd.fd = socket;
	read_ret = 1;

	poll(&pfd, 1, 0);
	if (pfd.revents & POLLHUP) {
		if (request->state == RS_WRITING && request->written) {
			request->state = RS_DONE;
			return;
		}
	}

	if (request->state == RS_READ_ONCE && done(request, socket)) {
		return;
	}

	if (request->state == RS_START) {
		if (pfd.revents & POLLIN) {
			read_ret = read(socket, buffer, BUFSIZE);
			if (read_ret < 0) {
				request->state = RS_CANCELLED;
				return;
			}
			if (!read_ret) {
				request->state = RS_CANCELLED;
				return;
			}
			request->state = RS_READ_ONCE;
			request->whole_request += std::string(buffer, buffer + read_ret);
		}
		return;
	}
	if (request->state == RS_READ_ONCE) {
		if (pfd.revents & POLLIN) {
			read_ret = read(socket, buffer, BUFSIZE);
			if (read_ret < 0) {
				//maybe this should just remove the connection?
				//we are not allowed to check errno
				request->state = RS_CANCELLED;
				return;
			}
			if (!read_ret) {
				request->state = RS_CANCELLED;
				return;
			}

			request->state = RS_READ_ONCE;
			request->whole_request += std::string(buffer, buffer + read_ret);
		}
	}
	else if (pfd.revents & POLLOUT) {
		ssize_t	write_ret = write(socket, resp->c_str() + request->written, resp->size() - request->written);
		if (write_ret <= 0) {
			request->state = RS_CANCELLED;
			return;
		}
		request->written += write_ret;
		if (request->written == (ssize_t)resp->size()) {
			request->state = RS_DONE;
		}
	}
}