Connection.cpp

#include "includes/Connection.hpp"

Connection::Connection(ServerConfig &serv, int epoll_fd): _server(serv)
{
	sent = -2;
	bytes_sent = 0;
	_sendStatus = START;
	_request = Request(serv.getClientBodySize());
	_last_active = time(NULL);

	struct sockaddr client_addr;
	socklen_t client_addrlen = sizeof(client_addr);

	_client = accept(_server.getFd(),&client_addr, &client_addrlen);
	if (_client == -1)
		closeClient(epoll_fd,"Accept failed");
	else
	{
		//setting socket options to make addr and ports shareable and reusable without time wait
		int enable = 1;
		if (setsockopt(_client, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)))
			std::cerr <<"SetSockOpt SO_REUSEADDR failed" << std::endl;
		set_nonBlock(_client);
		addToEpoll(epoll_fd, EPOLLIN | EPOLLRDHUP, 0);
		std::cout << "======== CONNECTION ON "<< _client << " ========\n" << std::endl;
	}
};

Connection::Connection(Connection const &copy): _server(copy.getServer())
{
	_client = -2;
	*this = copy;
}

Connection::~Connection()
{
}

Connection & Connection::operator=(Connection const &rhs)
{
	if (this != &rhs)
	{
		upload_name = rhs.getUploadName();
		_sendStatus = rhs.getSendStatus();
		_server = rhs.getServer();
		_client = rhs.getClient();
		_request = rhs.getRequest();
		_response = rhs.getResponse();
		_last_active = rhs.getLastActive();
		sent = rhs.getSent();
		bytes_sent = rhs.getBytes_sent();
	}
	return (*this);
}

bool  Connection::operator==(Connection const &rhs) const
{
	if (_client == rhs.getClient())
		return true;
	return false;
}

ServerConfig 	&Connection::getServer(void) const
{
	return (_server);
};

int 	Connection::getClient(void) const
{
	return (_client);
};

Request 	Connection::getRequest(void) const
{
	return (_request);
};


Request 	&Connection::getRequest(void)
{
	return (_request);
};

Connection::t_status 	Connection::getSendStatus(void) const
{
	return (_sendStatus);
}

std::string 	Connection::getResponse(void) const
{
	return (_response);
};

std::string 	Connection::getUploadName(void) const
{
	return (upload_name);
};

std::time_t 	Connection::getLastActive(void) const
{
	return (_last_active);
}

int 	Connection::getSent(void) const
{
	return (sent);
};



ssize_t	Connection::getBytes_sent(void)const{
	return this->bytes_sent;
}

std::string	Connection::get_route(void)const{
	return this->route;
}

void	Connection::set_route(std::string rou){
	this->route = rou;
}


void	Connection::setBytes_sent(ssize_t size){
	this->bytes_sent = size;
}

void 	Connection::updateLastActive(void)
{
	_last_active = time(NULL);
}
	
void	Connection::set_request(Request rc)
{
	this->_request = rc;
}

void 	Connection::addToEpoll(int epoll_fd, int flags, int status)
{
	struct epoll_event events;
	events.events = flags;
	events.data.fd = _client;
	int r;

	if (!status)
		r = epoll_ctl(epoll_fd, EPOLL_CTL_ADD,_client, &events);
	else 
		r = epoll_ctl(epoll_fd, EPOLL_CTL_MOD,_client, &events);
	if (r == -1)
		closeClient(epoll_fd,"Epoll_ctl failed"); 
}

void 	Connection::parseRequest(int epoll_fd)
{
	char buf[400000] = {0};
	ssize_t bytes;

	bytes = recv(_client, buf, sizeof(buf), 0);
	if (!bytes)
		closeClient(epoll_fd,"Client Disconnected"); 
	else if (bytes < 0)
		return;
	else
	{
		if (_request.getStatus() == Request::START)
		{
			addToEpoll(epoll_fd, EPOLLIN | EPOLLOUT | EPOLLRDHUP, 1);
			_request.setStatus(Request::METHOD);
		}
		
		std::string str(buf, bytes);

		if (_request.getStatus() == Request::METHOD)
			_request.setMethod(str);
		else if (_request.getStatus() == Request::PATH)
			_request.setPath(str);
		else if (_request.getStatus() == Request::VERSION)
			_request.setVersion(str);
		else if (_request.getStatus() == Request::HEADERS)
			_request.setHeaders(str);
		else if (_request.getStatus() == Request::BODY)
			_request.setBody(str);
		if (_request.getStatus() == Request::COMPLETE)
			_request.print(_client);
	}
}

void 	Connection::sendResponse(int epoll_fd)
{
	ssize_t bytes;

	if (bytes_sent)
	{
		_response = _response.substr(bytes_sent);
		bytes_sent = 0;
	}
	else if (_request.getStatus() == Request::ERROR)
	{
		get_err(_request.getError());
		if (!_request.getBody().empty())
		{
			std::string tmp;
			std::remove(_request.getBody().c_str());
			_request.setBody(tmp);
		}
	}	
	else if (_request.getStatus() == Request::COMPLETE)
		method();
	else
		parseRequest(epoll_fd);
	bytes = send(_client, _response.c_str(), _response.size(), MSG_NOSIGNAL);
	if (bytes < 0)
		return;
	if(_response.size() - bytes != 0)
		bytes_sent =  bytes;
	if (_sendStatus == FINISHED)
	{
			std::cout<<"******************RESPONSE SENT TO "<<_client<<"*******************"<<std::endl;
	}
	(void)epoll_fd;
}

void 	Connection::closeClient(int epoll_fd, std::string str)
{
	_sendStatus = FINISHED;
	if (!str.empty())
		std::cerr << str << std::endl;
	if (_client > 0)
	{
		epoll_ctl(epoll_fd, EPOLL_CTL_DEL,_client, NULL);
		close(_client);
	}
	_client = -2;
	if(sent != -2){
		close(sent);
		sent = -2;
	}
}