main.cpp

#include <sys/socket.h>
#include <sys/wait.h>
#include <stdio.h>
#include <netdb.h>
#include <poll.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>

#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cstdio>

#include "ServerConfig.hpp"
#include "Response.hpp"
#include "ServerConfigManager.hpp"
#include "webserv.hpp"
#include "Request.hpp"
#include "SocketManager.hpp"
#include "RequestManager.hpp"
#include "ResponseException.hpp"
#include "ServerConfigManagerBuilder.hpp"
#include "ReadBuffer.hpp"

using std::string; using std::vector;
using std::ifstream;
using std::cout; using std::cerr; using std::endl;


/*	based on `request`, create `Response` object and send Response

	Will NOT free `request`, and will not close `fd` */
std::pair<Response, const ResponseGeneratorParent *> handleRequest(Request *request, const ServerConfigManager &configManager) {
	// get ServerConfig from ServerConfigManager
	const ServerConfig &config = configManager.getServerConfig(request);

	// get responseGenerator from config
	const ResponseGeneratorParent *responseGenerator = config.getResponseGenerator(request);

	// make response from responseGenerator
	Response response = responseGenerator->generate(request);

	return std::make_pair(response, responseGenerator);
}

int getSocket(int port) {
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);

	int optvalue = 1;
	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optvalue, sizeof(optvalue)) == -1) {
		cerr << "setsockopt failed" << endl;
		cerr << strerror(errno) << endl;
		return -1;
	}

	if (fcntl(sockfd, F_SETFL, O_NONBLOCK | FD_CLOEXEC) == -1) {
		cerr << "fcntl failed" << endl;
		cerr << strerror(errno) << endl;
		return -1;
	}

	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	int bind_res = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));

	if (bind_res < 0) {
		cerr << "Bind for port " << port << " failed" << endl;
		return -1;
	}

	int listen_res = listen(sockfd, 1000);
	if (listen_res < 0) {
		cerr << "listen for port " << port << " failed" << endl;
		return -1;
	}

	return sockfd;
}

void handleResponse(const Response &response, const ResponseGeneratorParent *responseGeneratorParent, RequestManager &reqManager, SocketManager &sockManager, const int &clientSocket) {
	if (response.isCgiSet()) {
		reqManager.addFdMap(response.getCgiWriteFd(), clientSocket, response.getStaticStatus(), false);
		reqManager.addFdMap(response.getCgiReadFd(), clientSocket, response.getStaticStatus(), false);
		reqManager.setCgiPid(clientSocket, response.getCgiPid());
		reqManager.setResponseGenerator(clientSocket, responseGeneratorParent);
		sockManager.addCgiReadFd(response.getCgiReadFd());
		sockManager.addCgiWriteFd(response.getCgiWriteFd());
	} else if (response.isStaticSet()) {
		reqManager.addFdMap(response.getStaticFd(), clientSocket, response.getStaticStatus(), response.isErrorPage());
		reqManager.setResponseGenerator(clientSocket, responseGeneratorParent);
		// Adding fd causes `sockManager` to reallocate memory
		// `reqManager` should be preceded
		sockManager.addStaticReadFd(response.getStaticFd());
	} else if (response.isFileUploadSet()) {
		reqManager.addFileUploadFd(response.getFileUploadFd(), clientSocket, response.getFileBuffer(), response.getFileRoute(), responseGeneratorParent);
		sockManager.addFileUploadFd(response.getFileUploadFd());
	} else {
		// set Response to write later
		reqManager.setResponseString(clientSocket, response.flushContent());
		sockManager.addWriteEvent(clientSocket);
	}
}

int main(int argc, char *argv[]) {
	if (argc != 2) {
		cerr << "Usage: ./webserv [configuration file]" << endl;
		return 1;
	}

	std::srand(std::time(NULL));
	string configFile(argv[1]);

	SocketManager sockManager;
	ServerConfigManager::ServerConfigManagerBuilder serverConfigManagerBuilder;
	try {
		serverConfigManagerBuilder.build(configFile, sockManager);
	} catch (...) {
		return 1;
	}
	const ServerConfigManager &serverConfigManager = serverConfigManagerBuilder.getServerConfig();

	RequestManager reqManager;

	cout << "Server is running!" << endl;
	while (true) {
		int p = sockManager.executePoll();

		if (p == 0) continue;
		if (p < 0) {
			cerr << "Poll error!" << endl;
			return 1;
		}

		int _size = sockManager.size();
		vector<int> removed_list;
		for (int i = 0; i < _size; i++) {
			if (sockManager[i].revents == 0) continue;

			// Socket is ready to listen
			if (sockManager.isServerSocket(sockManager[i].fd)) {
				if (!(sockManager[i].revents & POLLIN)) continue;

				// It is Server Socket, accept incoming request
				int t = accept(sockManager[i].fd, NULL, NULL);
				if (t < 0) continue;

				if (fcntl(t, F_SETFL, FD_CLOEXEC | O_NONBLOCK) == -1) {
					perror("fcntl");
					exit(1);
				}

				// Add t in poll list and Request list
				sockManager.addClientSocket(t);
				reqManager.addClientSocket(t, sockManager[i].fd);
			} else if (sockManager.isClientSocket(sockManager[i].fd)) {

				const int clientSocket = sockManager[i].fd;

				// It is Request fd, try to read
				if (sockManager[i].revents & POLLIN) {
					int r;
					ReadBuffer::bufferPair buffer = ReadBuffer::read(clientSocket, r);

					// If it is EOF or error, Connection is end
					// Remove from list
					if (r <= 0) {
						removed_list.push_back(clientSocket);
						reqManager.removeClientSocket(clientSocket);
						sockManager.removeClientSocket(clientSocket);
						continue;
					}

					// Read something, so add it to request
					// reqManager handles string
					// reqManager will NOT send Response if Request read is finished
					try {
						// if error from addstring, stop processing later
						reqManager.addString(clientSocket, buffer);

						// If Request is completed, process the request and send response
						// , and reset clientSocket's requestWrapper
						Request *req = reqManager.getRequestOrNull(clientSocket);
						if (req != NULL) {
							// MUST NOT free `req`
							std::pair<Response, const ResponseGeneratorParent *> responsepair = handleRequest(req, serverConfigManager);
							Response &response = responsepair.first;
							const ResponseGeneratorParent *responseGeneratorParent = responsepair.second;

							handleResponse(response, responseGeneratorParent, reqManager, sockManager, clientSocket);
						}
					} catch (const ResponseException &e) {
						// While processing read, error occurred!
						// Return response accordingly

						vector<unsigned char> content = Response::sendException(clientSocket, e, false);
						reqManager.raiseError(clientSocket);
						reqManager.setResponseString(clientSocket, content);
						sockManager.addWriteEvent(clientSocket);
					}
				}

				// If Write event received
				if (sockManager[i].revents & POLLOUT){
					reqManager.flushClientSocket(clientSocket);

					// If write finished, remove write event and reset request
					if (reqManager.isWriteComplete(clientSocket)) {
						if (reqManager.isErrorRaised(clientSocket)) {
							// If the request raised error, close connection
							removed_list.push_back(clientSocket);
							reqManager.removeClientSocket(clientSocket);
							sockManager.removeClientSocket(clientSocket);
						} else {
							sockManager.removeWriteEvent(clientSocket);
							reqManager.reset(clientSocket);
						}
					}
				}

			} else if (sockManager.isStaticFd(sockManager[i].fd)) {
				const int &staticFd = sockManager[i].fd;

				int clientSocket = reqManager.getClientSocketFromFd(staticFd);

				if (sockManager[i].revents & POLLIN) {
					reqManager.readStaticFd(staticFd);
					if (reqManager.isStaticReadComplete(staticFd)) {
						Response resp = reqManager.staticGetResponse(staticFd);
						handleResponse(resp, NULL, reqManager, sockManager, clientSocket);

						reqManager.removeFdMap(staticFd);
						sockManager.removeClientSocket(staticFd);
					}
				}
			} else if (sockManager.isFileUploadFd(sockManager[i].fd)) {
				const int fileUploadFd = sockManager[i].fd;
				const int clientSocket = reqManager.getClientSocketFromFd(fileUploadFd);

				if (sockManager[i].revents & POLLOUT) {
					reqManager.writeFileUploadFd(fileUploadFd);
					if (reqManager.isFileUploadComplete(fileUploadFd)) {
						Response resp = reqManager.writeFileGetResponse(fileUploadFd);
						handleResponse(resp, NULL, reqManager, sockManager, clientSocket);

						reqManager.removeFdMap(fileUploadFd);
						sockManager.removeClientSocket(fileUploadFd);
					}
				}
			} else {
				// CGI
				const int cgiFd = sockManager[i].fd;
				int clientSocket = reqManager.getClientSocketFromFd(cgiFd);

				if (sockManager[i].revents & POLLIN) {
					reqManager.readCgiFd(cgiFd);
				}

				if (sockManager[i].revents & POLLHUP) {
					reqManager.setCgiReadComplete(cgiFd);
				}

				if ((sockManager[i].revents & (POLLIN | POLLHUP)) && reqManager.isCgiReadComplete(cgiFd)) {
					Response resp = reqManager.cgiGetResponse(cgiFd);
					handleResponse(resp, NULL, reqManager, sockManager, clientSocket);

					reqManager.removeFdMap(cgiFd);
					sockManager.removeClientSocket(cgiFd);
				}

				if (sockManager[i].revents & POLLOUT) {
					reqManager.writeCgiFd(cgiFd);
					// Cgi Writing completed, it should mark it to read for read completion
					if (reqManager.isCgiWriteComplete(cgiFd)) {
						reqManager.removeFdMap(cgiFd);
						sockManager.removeClientSocket(cgiFd);
					}
				}
			}
		}

		// Delete related dangling fds
		for (unsigned int i = 0; i < removed_list.size(); i++) {
			int fd = reqManager.popDanglingFd(removed_list[i]);
			while (fd != -1) {
				sockManager.removeClientSocket(fd);
				fd = reqManager.popDanglingFd(removed_list[i]);
			}
		}
	}
}