322 lines
6.7 KiB
C++
322 lines
6.7 KiB
C++
|
|
#include "Webserv.hpp"
|
|
|
|
int g_last_signal;
|
|
bool g_run;
|
|
void signal_handler(int signum)
|
|
{
|
|
g_last_signal = signum;
|
|
}
|
|
|
|
Webserv::Webserv()
|
|
{
|
|
std::cerr << "Server init\n";
|
|
|
|
_epfd = ::epoll_create1(0); // (EPOLL_CLOEXEC) for CGI fork ?
|
|
if (_epfd == -1)
|
|
{
|
|
std::perror("err epoll_create1(): ");
|
|
throw std::runtime_error("Epoll init");
|
|
}
|
|
|
|
std::signal(SIGPIPE, signal_handler);
|
|
std::signal(SIGINT, signal_handler);
|
|
}
|
|
|
|
/* Webserv::Webserv(Webserv const &src)
|
|
{
|
|
|
|
} */
|
|
|
|
Webserv::Webserv(std::vector<ServerConfig>* servers)
|
|
: _servers(servers)
|
|
{
|
|
// talk to luke about what all this does
|
|
// the Param Constructor might need to do dif stuff
|
|
std::cout << "Server init\n";
|
|
|
|
_epfd = ::epoll_create1(0); // (EPOLL_CLOEXEC) for CGI fork ?
|
|
if (_epfd == -1)
|
|
{
|
|
std::perror("err epoll_create1(): ");
|
|
throw std::runtime_error("Epoll init");
|
|
}
|
|
}
|
|
|
|
Webserv::~Webserv()
|
|
{
|
|
close(_socket_fd);
|
|
close(_epfd);
|
|
_close_all_clients();
|
|
std::cerr << "Server destroyed\n";
|
|
}
|
|
|
|
/* Webserv & Webserv::operator=(Webserv const &rhs)
|
|
{
|
|
|
|
} */
|
|
|
|
///////////////
|
|
// Functions //
|
|
|
|
void Webserv::init_virtual_servers() // ADD config param
|
|
{
|
|
_socket_fd = ::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0); // (SOCK_CLOEXEC) for CGI fork ?
|
|
if (_socket_fd == -1)
|
|
{
|
|
std::perror("err socket(): ");
|
|
throw std::runtime_error("Socket init");
|
|
}
|
|
|
|
_bind(_socket_fd, 80);
|
|
_listen(_socket_fd, 512); // 512 arbitrary
|
|
|
|
if (_epoll_update(_socket_fd, EPOLLIN, EPOLL_CTL_ADD) == -1)
|
|
throw std::runtime_error("Socket init");
|
|
}
|
|
|
|
void Webserv::start()
|
|
{
|
|
std::cerr << "Server started\n";
|
|
struct epoll_event events[MAX_EVENTS];
|
|
int nfds;
|
|
int i;
|
|
int count_loop = 0;
|
|
|
|
g_run = true;
|
|
while (g_run)
|
|
{
|
|
std::cerr << ++count_loop << "----loop epoll()\n";
|
|
nfds = ::epoll_wait(_epfd, events, MAX_EVENTS, TIMEOUT);
|
|
if (nfds == -1)
|
|
{
|
|
std::perror("err epoll_wait(): ");
|
|
throw std::runtime_error("Epoll wait");
|
|
}
|
|
else if (nfds == 0)
|
|
{
|
|
if (!_clients.empty())
|
|
{
|
|
std::cerr << "Timeout " << TIMEOUT << "ms\n";
|
|
_close_all_clients();
|
|
}
|
|
}
|
|
i = 0;
|
|
while (i < nfds)
|
|
{
|
|
// if ((events[i].data.u32 == SERVER_FD) && (events[i].events & EPOLLIN)) // Dont work, see "SERVER_FD" define
|
|
if ((events[i].data.fd == _socket_fd) && (events[i].events & EPOLLIN))
|
|
_accept_connection(events[i].data.fd);
|
|
else if (events[i].events & EPOLLIN)
|
|
_read_request(static_cast<Client*>(events[i].data.ptr));
|
|
else if (events[i].events & EPOLLOUT)
|
|
_send_response(static_cast<Client*>(events[i].data.ptr));
|
|
++i;
|
|
_actual_client = NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
///////////////////////
|
|
// Private Functions //
|
|
|
|
void Webserv::_accept_connection(int fd)
|
|
{
|
|
struct sockaddr_in addr;
|
|
socklen_t addr_len;
|
|
int accepted_fd;
|
|
|
|
std::cerr << "accept()\n";
|
|
addr_len = sizeof addr;
|
|
accepted_fd = ::accept(fd, (sockaddr*)&addr, &addr_len);
|
|
if (accepted_fd == -1)
|
|
{
|
|
std::perror("err accept(): ");
|
|
return ;
|
|
}
|
|
::fcntl(accepted_fd, F_SETFL, O_NONBLOCK);
|
|
|
|
_clients.push_back(Client());
|
|
_clients.back().fd = accepted_fd;
|
|
|
|
_epoll_update(accepted_fd, EPOLLIN, EPOLL_CTL_ADD, &_clients.back());
|
|
}
|
|
|
|
//////////
|
|
// READ //
|
|
void Webserv::_read_request(Client *client)
|
|
{
|
|
char buf[BUFSIZE+1];
|
|
ssize_t ret;
|
|
_actual_client = client;
|
|
|
|
std::cerr << "recv()\n";
|
|
ret = ::recv(client->fd, buf, BUFSIZE, 0);
|
|
if (ret == -1)
|
|
{
|
|
std::perror("err recv(): ");
|
|
// if (g_last_signal)
|
|
// _handle_last_signal();
|
|
// else
|
|
// _close_client(client->fd);
|
|
|
|
std::cerr << "client ptr =" << client << "\n"; // DEBUG
|
|
std::cerr << "client.fd =" << client->fd << "\n"; // DEBUG
|
|
return ;
|
|
}
|
|
/*
|
|
if (ret == BUFSIZE)
|
|
// send error like "request too long" to client
|
|
*/
|
|
|
|
buf[ret] = '\0';
|
|
client->raw_request.append(buf);
|
|
|
|
_epoll_update(client->fd, EPOLLOUT, EPOLL_CTL_MOD, client);
|
|
}
|
|
|
|
///////////
|
|
// WRITE //
|
|
void Webserv::_send_response(Client *client)
|
|
{
|
|
ssize_t ret;
|
|
_actual_client = client;
|
|
|
|
std::cerr << "send()\n";
|
|
std::cerr << "RAW_REQUEST\n|\n" << client->raw_request << "|\n";
|
|
|
|
ret = ::send(client->fd, MSG_TEST, sizeof MSG_TEST - 1, 0);
|
|
if (ret == -1)
|
|
{
|
|
std::perror("err send(): ");
|
|
if (g_last_signal)
|
|
_handle_last_signal();
|
|
// else
|
|
// _close_client(client->fd);
|
|
return ;
|
|
}
|
|
|
|
_close_client(client->fd);
|
|
// if (client->raw_request.find("Connection: keep-alive") == std::string::npos)
|
|
// _close_client(client->fd);
|
|
// else
|
|
// _epoll_update(client->fd, EPOLLIN, EPOLL_CTL_MOD, client);
|
|
|
|
client->raw_request.clear();
|
|
}
|
|
|
|
|
|
////////////////////
|
|
// Misc functions //
|
|
|
|
int Webserv::_epoll_update(int fd, uint32_t events, int op)
|
|
{
|
|
struct epoll_event ev;
|
|
std::memset(&ev, 0, sizeof ev);
|
|
ev.events = events;
|
|
ev.data.fd = fd;
|
|
if (::epoll_ctl(_epfd, op, fd, &ev) == -1)
|
|
{
|
|
std::perror("err _epoll_update(): ");
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int Webserv::_epoll_update(int fd, uint32_t events, int op, void *ptr)
|
|
{
|
|
struct epoll_event ev;
|
|
std::memset(&ev, 0, sizeof ev);
|
|
ev.events = events;
|
|
ev.data.ptr = ptr;
|
|
if (::epoll_ctl(_epfd, op, fd, &ev) == -1)
|
|
{
|
|
std::perror("err _epoll_update(): ");
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
void Webserv::_handle_last_signal()
|
|
{
|
|
if (g_last_signal == SIGPIPE)
|
|
{
|
|
std::cerr << "SIGPIPE\n";
|
|
if (_actual_client)
|
|
{
|
|
_close_client(_actual_client->fd);
|
|
_actual_client = NULL;
|
|
}
|
|
}
|
|
else if (g_last_signal == SIGINT)
|
|
{
|
|
g_run = false;
|
|
}
|
|
g_last_signal = 0;
|
|
}
|
|
|
|
void Webserv::_close_client(int fd)
|
|
{
|
|
std::vector<Client>::iterator it = _clients.begin();
|
|
while (it != _clients.end())
|
|
{
|
|
if (it->fd == fd)
|
|
{
|
|
// _epoll_update(fd, 0, EPOLL_CTL_DEL); // normalement superflu, DEBUG
|
|
if (::close(fd) == -1)
|
|
std::perror("err close(): ");
|
|
else
|
|
std::cerr << "close fd " << fd << "\n";
|
|
_clients.erase(it);
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
}
|
|
|
|
void Webserv::_close_all_clients()
|
|
{
|
|
while (!_clients.empty())
|
|
{
|
|
// _epoll_update(_clients.back().fd, 0, EPOLL_CTL_DEL); // normalement superflu, DEBUG
|
|
if (::close(_clients.back().fd) == -1)
|
|
std::perror("err close(): ");
|
|
else
|
|
std::cerr << "close fd " << _clients.back().fd << "\n";
|
|
_clients.pop_back();
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////
|
|
// Init functions //
|
|
|
|
void Webserv::_bind(int socket_fd, in_port_t port)
|
|
{
|
|
// cast invalid ? how to ?
|
|
// const struct sockaddr* cast_test = static_cast<const struct sockaddr*>(addr);
|
|
|
|
struct sockaddr_in addr;
|
|
std::memset(&addr, 0, sizeof addr);
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_port = ::htons(port);
|
|
addr.sin_addr.s_addr = ::htonl(INADDR_ANY); // htonl useless with 0 value (INADDR_ANY) ?
|
|
|
|
if (::bind(socket_fd, (const sockaddr*)&addr, sizeof addr) == -1)
|
|
{
|
|
std::perror("err bind(): ");
|
|
throw std::runtime_error("Socket bind");
|
|
}
|
|
}
|
|
|
|
void Webserv::_listen(int socket_fd, unsigned int max_connections)
|
|
{
|
|
if (::listen(socket_fd, max_connections) == -1)
|
|
{
|
|
std::perror("err listen(): ");
|
|
throw std::runtime_error("Socket listen");
|
|
}
|
|
}
|