/*
* flask_request_handler - Processes incoming flask request. Pareses the
* request and builds response depending on process results.
*
* @param i client socket identifier
* @return 1 when successful, 0 otherwise
*/
int flask_request_handler(int i)
{
int no_data_read = 0;
int readret;
int errnoSave;
tcp_connection *curr_connection = &((engine.connections)[i]);
memset(engine.buf, 0, BUF_SIZE);
readret = recv(i, engine.buf, BUF_SIZE - curr_connection->request_index, 0);
if (readret == 0)
{
init_connection(curr_connection);
close(i);
FD_CLR(i,&(engine.rfds));
FD_CLR(i,&(engine.wfds));
return 0;
}
else if (readret < 1)
{
errnoSave = errno;
if (errnoSave == ECONNRESET)
{
init_connection(curr_connection);
close(i);
fprintf(stderr, "Client disconneted.\n");
return -1;
}
else
{
curr_connection->status = 500;
build_response(curr_connection);
FD_SET(i, &(engine.wfds));
no_data_read = 1;
}
}
if (no_data_read == 0)
{
memcpy(curr_connection->request, engine.buf, readret);
curr_connection->request_index = readret;
curr_connection->status = 200;
process_buffer(curr_connection, i);
build_response(curr_connection);
FD_SET(i, &(engine.wfds));
}
return 1;
}
/**
* Listening and handling incoming requests
*/
void HttpServer::listen()
{
try
{
// Start server
boost::asio::io_service io_service;
tcp::endpoint localhost(tcp::v4(), this->port);
tcp::acceptor acceptor(io_service, localhost);
std::cout << "Server has started. Listening on address localhost:" << this->port
<< " (that's 127.0.0.1:" << this->port << " for you Windows folks).\n\n"
<< "Now type this address into your browser." << std::endl;
// Reply to incoming HTTP requests
while (1)
{
boost::system::error_code error_code;
// Accept connection
tcp::socket socket(io_service);
acceptor.accept(socket);
// Send HTTP response
std::string filepath = parse_request(socket, error_code);
boost::asio::write(socket, boost::asio::buffer(build_response(filepath)), error_code);
}
}
catch (std::exception& e)
{
std::cerr << e.what() << std::endl;
}
}
int main(int argc, char* argv[])
{
obuf bufout;
obuf* out;
const char* recipient;
const char* sender;
parse_args(argc, argv);
if (opt_starttime && now < opt_starttime)
ignore("Autoresponder is not active yet");
if (opt_endtime && now > opt_endtime)
ignore("Autoresponder is no longer active");
recipient = getenv("RECIPIENT");
if(!recipient)
usage("RECIPIENT is not set, must be run from qmail.");
sender = getenv("SENDER");
if(!sender)
usage("SENDER is not set, must be run from qmail.");
check_sender(sender);
str_copys(&subject, "Your mail");
read_parse_headers();
// Check rate that SENDER has sent
if(!count_history(sender)) {
log_sender(sender, 0);
ignore("SENDER has sent too many messages");
}
if(opt_nosend)
out = &outbuf;
else {
int msgfd = qmail_start();
if (!obuf_init(&bufout, msgfd, 0, IOBUF_NEEDSCLOSE, 0))
fail_temp("Could not initialize output buffer.");
out = &bufout;
}
obuf_put3s(out, "To: <", sender, ">\n");
if(opt_subject_prefix)
obuf_put4s(out, "Subject: ", opt_subject_prefix, subject.s, "\n");
if((!opt_no_inreplyto) && (message_id.len != 0))
obuf_put3s(out, "In-Reply-To: ", message_id.s, "\n");
build_response(out, sender, recipient);
if (!obuf_close(out))
fail_temp("Could not close output.");
if (!opt_nosend)
qmail_finish(sender);
log_sender(sender, 1);
return 0;
}
/* Buffer Function to arrange function parameters*/
int passarray(char* path,http_response_t *response,http_request_t *request,int newfd)
{
time_date(response);
filetype(request,response);
filesize(&path,response,request);
build_response(request, response);
send_response(response,&path,newfd);
return 0;
}
static const response* apply_rule(const struct rule* rule)
{
const response* resp;
unsigned long maxdatabytes;
resp = build_response(rule->code, &rule->response);
apply_environment(&rule->environment);
maxdatabytes = session_getnum("maxdatabytes", ~0UL);
if (maxdatabytes == 0
|| (rule->databytes > 0
&& maxdatabytes > rule->databytes))
session_setnum("maxdatabytes", rule->databytes);
return resp;
}
/*------------------------------------------------------------------------------*/
static void
cluster_getparam(int thr_nb, void *data, cl_error_desc_t *err_desc)
{
xmlDocPtr doc = NULL;
xmlNodePtr exanodes_node;
int ret;
exalog_debug("getparam");
/* Create XML document */
doc = xmlNewDoc(BAD_CAST("1.0"));
if (doc == NULL)
{
set_error(err_desc, -EXA_ERR_XML_INIT, "Failed to create result document");
return;
}
exanodes_node = xmlNewNode(NULL, BAD_CAST("Exanodes"));
if (exanodes_node == NULL)
{
set_error(err_desc, -EXA_ERR_XML_INIT,
"Failed to create node in result document");
xmlFreeDoc(doc);
return;
}
xmlDocSetRootElement(doc, exanodes_node);
ret = build_response(exanodes_node);
if (ret == EXA_SUCCESS)
{
xmlChar *xmlchar_doc;
int buf_size;
xmlDocDumpFormatMemory(doc, &xmlchar_doc, &buf_size, 1);
send_payload_str((char *)xmlchar_doc);
xmlFree(xmlchar_doc);
}
xmlFreeDoc(doc);
set_error(err_desc, ret, NULL);
}
static void manage_single_request(int peer_sfd)
{
s_start(&requests_time);
http_request_t *request = (http_request_t*)malloc(sizeof(http_request_t));
http_response_t *response = (http_response_t*)malloc(sizeof(http_response_t));
strcpy(response->resource_path,path_root);
next_request(peer_sfd, request);
build_response(request, response);
send_response(peer_sfd, response);
clear_responses(response);
free(request);
free(response);
s_stop(&requests_time);
get_time_difference(&requests_time);
}
