void ready_request(request * req)
{
dequeue(&request_block, req);
enqueue(&request_ready, req);
if (req->buffer_end) {
BOA_FD_CLR(req, req->fd, BOA_WRITE);
} else {
switch (req->status) {
case IOSHUFFLE:
#ifndef HAVE_SENDFILE
if (req->buffer_end - req->buffer_start == 0) {
BOA_FD_CLR(req, req->data_fd, BOA_READ);
break;
}
#endif
case WRITE:
case PIPE_WRITE:
case DONE:
BOA_FD_CLR(req, req->fd, BOA_WRITE);
break;
case PIPE_READ:
BOA_FD_CLR(req, req->data_fd, BOA_READ);
break;
case BODY_WRITE:
BOA_FD_CLR(req, req->post_data_fd, BOA_WRITE);
break;
default:
BOA_FD_CLR(req, req->fd, BOA_READ);
}
}
}
void loop(int server_s)
{
FD_ZERO(BOA_READ);
FD_ZERO(BOA_WRITE);
max_fd = -1;
while (1) {
/* handle signals here */
if (sighup_flag)
sighup_run();
if (sigchld_flag)
sigchld_run();
if (sigalrm_flag)
sigalrm_run();
if (sigterm_flag) {
/* sigterm_flag:
* 1. caught, unprocessed.
* 2. caught, stage 1 processed
*/
if (sigterm_flag == 1) {
sigterm_stage1_run();
BOA_FD_CLR(req, server_s, BOA_READ);
close(server_s);
/* make sure the server isn't in the block list */
server_s = -1;
}
if (sigterm_flag == 2 && !request_ready && !request_block) {
sigterm_stage2_run(); /* terminal */
}
} else {
if (total_connections > max_connections) {
/* FIXME: for poll we don't subtract 20. why? */
BOA_FD_CLR(req, server_s, BOA_READ);
} else {
BOA_FD_SET(req, server_s, BOA_READ); /* server always set */
}
}
pending_requests = 0;
/* max_fd is > 0 when something is blocked */
if (max_fd) {
struct timeval req_timeout; /* timeval for select */
req_timeout.tv_sec = (request_ready ? 0 : default_timeout);
req_timeout.tv_usec = 0l; /* reset timeout */
if (select(max_fd + 1, BOA_READ,
BOA_WRITE, NULL,
(request_ready || request_block ?
&req_timeout : NULL)) == -1) {
/* what is the appropriate thing to do here on EBADF */
if (errno == EINTR)
continue; /* while(1) */
else if (errno != EBADF) {
DIE("select");
}
}
/* FIXME: optimize for when select returns 0 (timeout).
* Thus avoiding many operations in fdset_update
* and others.
*/
if (!sigterm_flag && FD_ISSET(server_s, BOA_READ)) {
pending_requests = 1;
}
time(¤t_time); /* for "new" requests if we've been in
* select too long */
/* if we skip this section (for example, if max_fd == 0),
* then we aren't listening anyway, so we can't accept
* new conns. Don't worry about it.
*/
}
/* reset max_fd */
max_fd = -1;
if (request_block) {
/* move selected req's from request_block to request_ready */
fdset_update();
}
/* any blocked req's move from request_ready to request_block */
if (pending_requests || request_ready) {
process_requests(server_s);
}
}
}
static void free_request(request * req)
{
int i;
/* free_request should *never* get called by anything but
process_requests */
if (req->buffer_end && req->status < TIMED_OUT) {
/*
WARN("request sent to free_request before DONE.");
*/
req->status = DONE;
/* THIS IS THE SAME CODE EXECUTED BY THE 'DONE' SECTION
* of process_requests. It must be exactly the same!
*/
i = req_flush(req);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (i == -2) { /* error */
req->status = DEAD;
} else if (i > 0) {
return;
}
}
/* put request on the free list */
dequeue(&request_ready, req); /* dequeue from ready or block list */
/* set response status to 408 if the client has timed out */
if (req->status == TIMED_OUT && req->response_status == 0)
req->response_status = 408;
/* always log */
log_access(req);
if (req->mmap_entry_var)
release_mmap(req->mmap_entry_var);
else if (req->data_mem)
munmap(req->data_mem, req->filesize);
if (req->data_fd) {
close(req->data_fd);
BOA_FD_CLR(req, req->data_fd, BOA_READ);
}
if (req->post_data_fd) {
close(req->post_data_fd);
BOA_FD_CLR(req, req->post_data_fd, BOA_WRITE);
}
if (req->response_status >= 400)
status.errors++;
for (i = COMMON_CGI_COUNT; i < req->cgi_env_index; ++i) {
if (req->cgi_env[i]) {
free(req->cgi_env[i]);
} else {
log_error_time();
fprintf(stderr, "Warning: CGI Environment contains NULL value"
"(index %d of %d).\n", i, req->cgi_env_index);
}
}
if (req->pathname)
free(req->pathname);
if (req->path_info)
free(req->path_info);
if (req->path_translated)
free(req->path_translated);
if (req->script_name)
free(req->script_name);
if (req->host)
free(req->host);
if (req->ranges)
ranges_reset(req);
if (req->status < TIMED_OUT && (req->keepalive == KA_ACTIVE) &&
(req->response_status < 500 && req->response_status != 0) && req->kacount > 0) {
sanitize_request(req, 0);
--(req->kacount);
status.requests++;
enqueue(&request_block, req);
BOA_FD_SET(req, req->fd, BOA_READ);
BOA_FD_CLR(req, req->fd, BOA_WRITE);
return;
}
/*
While debugging some weird errors, Jon Nelson learned that
some versions of Netscape Navigator break the
HTTP specification.
Some research on the issue brought up:
http://www.apache.org/docs/misc/known_client_problems.html
As quoted here:
"
Trailing CRLF on POSTs
This is a legacy issue. The CERN webserver required POST
data to have an extra CRLF following it. Thus many
clients send an extra CRLF that is not included in the
Content-Length of the request. Apache works around this
problem by eating any empty lines which appear before a
request.
"
Boa will (for now) hack around this stupid bug in Netscape
(and Internet Exploder)
by reading up to 32k after the connection is all but closed.
This should eliminate any remaining spurious crlf sent
by the client.
Building bugs *into* software to be compatible is
just plain wrong
*/
if (req->method == M_POST) {
char buf[32768];
read(req->fd, buf, sizeof(buf));
}
close(req->fd);
BOA_FD_CLR(req, req->fd, BOA_READ);
BOA_FD_CLR(req, req->fd, BOA_WRITE);
total_connections--;
enqueue(&request_free, req);
return;
}
void loop(int server_s)
{
FD_ZERO(BOA_READ);
FD_ZERO(BOA_WRITE);
max_fd = -1;
while (1) {
/* handle signals here */
if (sighup_flag)
sighup_run();
if (sigchld_flag)
sigchld_run();
if (sigalrm_flag)
sigalrm_run();
if (sigterm_flag) {
/* sigterm_flag:
* 1. caught, unprocessed.
* 2. caught, stage 1 processed
*/
if (sigterm_flag == 1) {
sigterm_stage1_run();
BOA_FD_CLR(req, server_s, BOA_READ);
close(server_s);
/* make sure the server isn't in the block list */
server_s = -1;
}
if (sigterm_flag == 2 && !request_ready && !request_block) {
sigterm_stage2_run(); /* terminal */
}
} else {
if (total_connections > max_connections) {
/* FIXME: for poll we don't subtract 20. why? */
BOA_FD_CLR(req, server_s, BOA_READ);
} else {
BOA_FD_SET(req, server_s, BOA_READ); /* server always set */
}
}
if (isREBOOTASP == 1) {
if(last_req_after_upgrade != req_after_upgrade){
last_req_after_upgrade = req_after_upgrade;
}
}
pending_requests = 0;
/* max_fd is > 0 when something is blocked */
if (max_fd) {
struct timeval req_timeout; /* timeval for select */
req_timeout.tv_sec = (request_ready ? 0 : default_timeout);
req_timeout.tv_usec = 0l; /* reset timeout */
if (select(max_fd + 1, BOA_READ,
BOA_WRITE, NULL,
(request_ready || request_block ?
&req_timeout : NULL)) == -1) {
/* what is the appropriate thing to do here on EBADF */
if (errno == EINTR) {
//fprintf(stderr,"####%s:%d isFWUPGRADE=%d isREBOOTASP=%d###\n", __FILE__, __LINE__ ,isFWUPGRADE , isREBOOTASP);
//fprintf(stderr,"####%s:%d last_req_after_upgrade=%d req_after_upgrade=%d confirm_last_req=%d###\n", __FILE__, __LINE__ ,last_req_after_upgrade , req_after_upgrade, confirm_last_req);
if (isFWUPGRADE !=0 && isREBOOTASP == 1 ) {
if (last_req_after_upgrade == req_after_upgrade)
confirm_last_req++;
if (confirm_last_req >3)
goto ToUpgrade;
} else if(isCFGUPGRADE ==2 && isREBOOTASP == 1 ) {
goto ToReboot;
}
else if (isFWUPGRADE ==0 && isREBOOTASP == 1) {
if (last_req_after_upgrade == req_after_upgrade)
confirm_last_req++;
if (confirm_last_req >3) {
isFWUPGRADE = 0;
isREBOOTASP = 0;
//isFAKEREBOOT = 0;
confirm_last_req=0;
}
}
continue; /* while(1) */
}
else if (errno != EBADF) {
DIE("select");
}
}
/* FIXME: optimize for when select returns 0 (timeout).
* Thus avoiding many operations in fdset_update
* and others.
*/
if (!sigterm_flag && FD_ISSET(server_s, BOA_READ)) {
pending_requests = 1;
}
time(¤t_time); /* for "new" requests if we've been in
* select too long */
/* if we skip this section (for example, if max_fd == 0),
* then we aren't listening anyway, so we can't accept
* new conns. Don't worry about it.
*/
}
/* reset max_fd */
max_fd = -1;
if (request_block) {
/* move selected req's from request_block to request_ready */
fdset_update();
}
/* any blocked req's move from request_ready to request_block */
if (pending_requests || request_ready) {
if (isFWUPGRADE !=0 && isREBOOTASP == 1 ){
req_after_upgrade++;
}else if(isFWUPGRADE ==0 && isREBOOTASP == 1){
req_after_upgrade++;
}
process_requests(server_s);
continue;
}
ToUpgrade:
if (isFWUPGRADE !=0 && isREBOOTASP == 1 ) {
char buffer[200];
//fprintf(stderr,"\r\n [%s-%u] FirmwareUpgrade start",__FILE__,__LINE__);
FirmwareUpgrade(firmware_data, firmware_len, 0, buffer);
//fprintf(stderr,"\r\n [%s-%u] FirmwareUpgrade end",__FILE__,__LINE__);
//system("echo 7 > /proc/gpio"); // disable system LED
isFWUPGRADE=0;
isREBOOTASP=0;
//reboot_time = 5;
break;
}
ToReboot:
if(isCFGUPGRADE == 2 && isREBOOTASP ==1) {
isCFGUPGRADE=0;
isREBOOTASP=0;
system("reboot");
for(;;);
}
}
}
