/* R_SERVICE_UNAVAILABLE: 503 */
void send_r_service_unavailable(request * req) /* 503 */
{
static char body[] =
"<HTML><HEAD><TITLE>503 Service Unavailable</TITLE></HEAD>\n"
"<BODY><H1>503 Service Unavailable</H1>\n"
"There are too many connections in use right now.\r\n"
"Please try again later.\r\n</BODY></HTML>\n";
static int _body_len;
static char *body_len;
if (!_body_len)
_body_len = strlen(body);
if (!body_len)
body_len = strdup(simple_itoa(_body_len));
SQUASH_KA(req);
req->response_status = R_SERVICE_UNAV;
if (!req->simple) {
req_write(req, "HTTP/1.0 503 Service Unavailable\r\n");
print_http_headers(req);
req_write(req, "Content-Length: ");
req_write(req, body_len);
req_write(req, "\r\nContent-Type: " HTML "\r\n\r\n"); /* terminate header
*/
}
if (req->method != M_HEAD) {
req_write(req, body);
}
req_flush(req);
}
/* R_MOVED_TEMP: 302 */
void send_redirect_temp(request * req, char *url, char *more_hdr)
{
SQUASH_KA(req);
req->response_status = R_MOVED_TEMP;
if (!req->simple) {
req_write(req, "HTTP/1.0 302 Moved Temporarily\r\n");
print_http_headers(req);
req_write(req, "Content-Type: " HTML "\r\n");
req_write(req, "Location: ");
req_write_escape_http(req, url);
req_write(req, "\r\n");
req_write(req, more_hdr);
req_write(req, "\r\n\r\n");
}
if (req->method != M_HEAD) {
req_write(req,
"<HTML><HEAD><TITLE>302 Moved Temporarily</TITLE></HEAD>\n"
"<BODY>\n<H1>302 Moved</H1>The document has moved\n"
"<A HREF=\"");
req_write_escape_html(req, url);
req_write(req, "\">here</A>.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_NOT_MODIFIED: 304 */
void send_r_not_modified(request * req)
{
req_write(req, "HTTP/1.0 304 Not Modified\r\n");
req->response_status = R_NOT_MODIFIED;
print_http_headers(req);
print_content_type(req);
req_write(req, "\r\n"); /* terminate header */
req_flush(req);
}
/* R_BAD_REQUEST: 400 */
void send_r_bad_request(request * req)
{
req->response_status = R_BAD_REQUEST;
if (!req->simple) {
req_write(req, "HTTP/1.0 400 Bad Request\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>400 Bad Request</TITLE></HEAD>\n"
"<BODY><H1>400 Bad Request</H1>\nYour client has issued "
"a malformed or illegal request.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_NOT_IMP: 501 */
void send_r_not_implemented(request * req)
{
req->response_status = R_NOT_IMP;
if (!req->simple) {
req_write(req, "HTTP/1.0 501 Not Implemented\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>501 Not Implemented</TITLE></HEAD>\n"
"<BODY><H1>501 Not Implemented</H1>\nPOST to non-script "
"is not supported in Boa.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_ERROR: 500 */
void send_r_error(request * req)
{
req->response_status = R_ERROR;
if (!req->simple) {
req_write(req, "HTTP/1.0 500 Server Error\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>500 Server Error</TITLE></HEAD>\n"
"<BODY><H1>500 Server Error</H1>\nThe server encountered "
"an internal error and could not complete your request.\n"
"</BODY></HTML>\n");
}
req_flush(req);
}
/* R_NOT_FOUND: 404 */
void send_r_not_found(request * req)
{
req->response_status = R_NOT_FOUND;
if (!req->simple) {
req_write(req, "HTTP/1.0 404 Not Found\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD>\n"
"<BODY><H1>404 Not Found</H1>\nThe requested URL ");
req_write(req, escape_string(req->request_uri, e_s));
req_write(req, " was not found on this server.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_BAD_GATEWAY: 502 */
void send_r_bad_gateway(request * req)
{
SQUASH_KA(req);
req->response_status = R_BAD_GATEWAY;
if (!req->simple) {
req_write(req, "HTTP/1.0 502 Bad Gateway" CRLF);
print_http_headers(req);
req_write(req, "Content-Type: " HTML CRLF CRLF); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req,
"<HTML><HEAD><TITLE>502 Bad Gateway</TITLE></HEAD>\n"
"<BODY><H1>502 Bad Gateway</H1>\nThe CGI was "
"not CGI/1.1 compliant.\n" "</BODY></HTML>\n");
}
req_flush(req);
}
/* R_FORBIDDEN: 403 */
void send_r_forbidden(request * req)
{
req->response_status = R_FORBIDDEN;
if (!req->simple) {
req_write(req, "HTTP/1.0 403 Forbidden\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>403 Forbidden</TITLE></HEAD>\n"
"<BODY><H1>403 Forbidden</H1>\nYour client does not "
"have permission to get URL ");
req_write(req, escape_string(req->request_uri, e_s));
req_write(req, " from this server.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_NOT_IMP: 505 */
void send_r_bad_version(request * req)
{
req->response_status = R_BAD_VERSION;
if (!req->simple) {
req_write(req, "HTTP/1.0 505 HTTP Version Not Supported\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>505 HTTP Version Not Supported</TITLE></HEAD>\n"
"<BODY><H1>505 HTTP Version Not Supported</H1>\nHTTP versions "
"other than 0.9 and 1.0 "
"are not supported in Boa.\n<p><p>Version encountered: ");
req_write(req, req->http_version);
req_write(req, "<p><p></BODY></HTML>\n");
}
req_flush(req);
}
/* R_UNAUTHORIZED: 401 */
void send_r_unauthorized(request * req, const char *realm_name)
{
req->response_status = R_UNAUTHORIZED;
if (!req->simple) {
req_write(req, "HTTP/1.0 401 Unauthorized\r\n");
print_http_headers(req);
req_write(req, "WWW-Authenticate: Basic realm=\"");
req_write(req, realm_name);
req_write(req, "\"\r\n");
req_write(req, "Content-Type: text/html\r\n\r\n"); /* terminate header */
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>401 Unauthorized</TITLE></HEAD>\n"
"<BODY><H1>401 Unauthorized</H1>\nYour client does not "
"have permission to get URL ");
req_write(req, escape_string(req->request_uri, e_s));
req_write(req, " from this server.\n</BODY></HTML>\n");
}
req_flush(req);
}
/* R_MOVED_PERM: 301 */
void send_redirect_perm(request * req, char *url)
{
req->response_status = R_MOVED_PERM;
if (!req->simple) {
req_write(req, "HTTP/1.0 301 Moved Permanently\r\n");
print_http_headers(req);
req_write(req, "Content-Type: text/html\r\n");
req_write(req, "Location: ");
req_write(req, escape_string(url, e_s));
req_write(req, "\r\n\r\n");
}
if (req->method != M_HEAD) {
req_write(req, "<HTML><HEAD><TITLE>301 Moved Permanently</TITLE></HEAD>\n"
"<BODY>\n<H1>301 Moved</H1>The document has moved\n"
"<A HREF=\"");
req_write(req, escape_string(url, e_s));
req_write(req, "\">here</A>.\n</BODY></HTML>\n");
}
req_flush(req);
}
static void
img_png_flush (png_structp png_ptr)
{
req_flush( (( PImgLoadFileInstance) png_get_io_ptr(png_ptr))-> req);
}
int init_get(request * req)
{
int data_fd, saved_errno;
struct stat statbuf;
volatile unsigned int bytes_free;
//fprintf(stderr, "###[%s %d] req->pathname=%s###\n", __FUNCTION__, __LINE__, req->pathname);
//fprintf(stderr, "###[%s %d] req->client_stream=%s###\n", __FUNCTION__, __LINE__, req->client_stream);
//fprintf(stderr, "###[%s %d] req->logline=%s###\n", __FUNCTION__, __LINE__, req->logline);
//fprintf(stderr, "###[%s %d] req->request_uri=%s###\n", __FUNCTION__, __LINE__, req->request_uri);
//fprintf(stderr, "###[%s %d] req->host=%s###\n", __FUNCTION__, __LINE__, req->host);
/* A special GET request: "GET /boaform/formWlanRedirect?redirect-url=wlbasic.htm&wlan_id=0 HTTP/1.1" */
if (strstr(req->request_uri, "formWlanRedirect")) {
char *redirectUrl, *strWlanId, *ptr;
extern void formWlanRedirect2(request *wp, char *redirectUrl, char *strWlanId);
if ((ptr = strstr(req->client_stream, "redirect-url="))) {
redirectUrl = ptr + strlen("redirect-url=");
if ((ptr = strstr(redirectUrl, "&wlan_id="))) {
*ptr = '\0';
strWlanId = ptr + strlen("&wlan_id=");
if ((ptr = strstr(strWlanId, " HTTP"))) {
*ptr = '\0';
//fprintf(stderr, "###[%s %d] redirectUrl=%s strWlanId=%s###\n", __FUNCTION__, __LINE__, redirectUrl, strWlanId);
formWlanRedirect2(req, redirectUrl, strWlanId);
return 0;
}
}
}
}
data_fd = open(req->pathname, O_RDONLY);
saved_errno = errno; /* might not get used */
#ifdef GUNZIP
if (data_fd == -1 && errno == ENOENT) {
/* cannot open */
/* it's either a gunzipped file or a directory */
char gzip_pathname[MAX_PATH_LENGTH];
unsigned int len;
len = strlen(req->pathname);
if (len + 4 > sizeof(gzip_pathname)) {
log_error_doc(req);
fprintf(stderr, "Pathname + .gz too long! (%s)\n", req->pathname);
send_r_bad_request(req);
return 0;
}
memcpy(gzip_pathname, req->pathname, len);
memcpy(gzip_pathname + len, ".gz", 3);
gzip_pathname[len + 3] = '\0';
data_fd = open(gzip_pathname, O_RDONLY);
if (data_fd != -1) {
close(data_fd);
req->response_status = R_REQUEST_OK;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(gzip_pathname);
if (!req->pathname) {
boa_perror(req, "strdup req->pathname for gzipped filename " __FILE__ ":" STR(__LINE__));
return 0;
}
if (req->http_version != HTTP09) {
req_write(req, http_ver_string(req->http_version));
req_write(req, " 200 OK-GUNZIP" CRLF);
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, CRLF);
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
}
#endif
if (data_fd == -1) {
log_error_doc(req);
errno = saved_errno;
DEBUG(DEBUG_BOA) {
perror("document open");
fprintf(stderr, "req->pathname=%s\n", (req->pathname ? req->pathname : "null"));
}
#if 0
if (saved_errno == ENOENT)
send_r_not_found(req);
else if (saved_errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
#else
send_redirect_perm(req,"home.htm");
#endif
return 0;
}
int init_get2(request * req)
{
int data_fd;
//Brad add begin for update content length
char *content_length_orig1;
char *content_length_orig2;
int orig_char_length=0;
int exact_char_length=0;
int byte_shift=0;
int exact_size=0;
int total_length_shift=0;
char *exact_content=NULL;
int head_offset=0;
int first_offset=0;
int antecedent_segment=0;
int subsequent_segment=0;
//Brad add end for update content length
#ifdef GUNZIP
char buf[MAX_PATH_LENGTH];
#endif
struct stat statbuf;
SQUASH_KA(req);
complete_env(req);
middle_segment=0;
req->cgi_env[req->cgi_env_index] = NULL; /* terminate cgi env */
if ((strstr(req->request_uri,".htm")==NULL) &&
(strstr(req->request_uri,".asp")==NULL)) {
return 1;
}
data_fd = open(req->pathname, O_RDONLY);
if (data_fd == -1) { /* cannot open */
#ifdef GUNZIP
sprintf(buf, "%s.gz", req->pathname);
data_fd = open(buf, O_RDONLY);
if (data_fd == -1) {
#endif
int errno_save = errno;
log_error_doc(req);
errno = errno_save;
#if 0
perror("document open");
#endif
// syslog(LOG_ERR, "Error opening %s for %s: %s\n", req->pathname,
// req->remote_ip_addr, strerror(errno_save));
errno = errno_save;
if (errno == ENOENT)
send_r_not_found(req);
else if (errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
#ifdef GUNZIP
}
close(data_fd);
req->response_status = R_REQUEST_OK;
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, "\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(buf);
return init_cgi(req); /* 1 - OK, 2 - die */
#endif
}
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) {
close(data_fd); /* close dir */
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
if (server_port != 80)
sprintf(buffer, "http://%s:%d%s/", req->host?req->host:server_name, server_port,
req->request_uri);
else
sprintf(buffer, "http://%s%s/", req->host?req->host:server_name, req->request_uri);
send_redirect_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf); /* updates statbuf */
if (data_fd == -1) { /* couldn't do it */
return 0; /* errors reported by get_dir */
}
else if (data_fd == 0) {
return 1;
}
}
//start modify here : tony
#if 0
if (req->if_modified_since &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
#endif
req->filesize = statbuf.st_size;
// req->last_modified = statbuf.st_mtime;
if (req->method == M_HEAD) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
/* MAP_OPTIONS: see compat.h */
req->data_mem = mmap(0, req->filesize,
#ifdef USE_NLS
PROT_READ|PROT_WRITE
#else
PROT_READ
#endif
, MAP_OPTIONS,data_fd, 0);
close(data_fd); /* close data file */
if ((long) req->data_mem == -1) {
boa_perror(req, "mmap");
return 0;
}
send_r_request_ok(req); /* All's well */
{
//parse and send asp page
char *left,*right,*last_right=req->data_mem;
int bob;
first_offset=req->buffer_end; //Brad add for update content length
while (1) {
left=strstr(last_right,"<%");
if (left!=NULL)
right=strstr(left,"%>");
if ((left!=NULL) && (right!=NULL)) {
bob=(unsigned int)left-(unsigned int)last_right;
#ifdef SUPPORT_ASP
while((bob+req->buffer_end+10)>(req->max_buffer_size)) { //Brad modify
int ret;
ret=allocNewBuffer(req);
if (ret==-1) {
bob=req->max_buffer_size- req->buffer_end;
printf("will break\n");
break;
}
}
#endif
antecedent_segment =antecedent_segment+bob; //Brad add for update content length
if (bob>=0) {
memcpy(req->buffer + req->buffer_end, req->data_mem + req->filepos, bob);
last_right=right+2;
req->buffer_end += bob;
req->filepos += (bob+(unsigned int)last_right-(unsigned int)left);
handleScript(req,left,right);
}
}
else {
bob=(unsigned int)req->data_mem+req->filesize-(unsigned int)last_right;
#ifdef SUPPORT_ASP
while((bob+req->buffer_end+10)>req->max_buffer_size) { //Brad modify
int ret;
ret=allocNewBuffer(req);
if (ret==-1) {
bob=req->max_buffer_size- req->buffer_end;
break;
}
}
#endif
subsequent_segment = subsequent_segment+bob; //Brad add for update content length
if (bob > 0) {
memcpy(req->buffer + req->buffer_end, req->data_mem + req->filepos, bob);
req->buffer_end += bob;
req->filepos += bob;
}
break;
}
}
}
//Brad add begin for update content length
exact_content = req->buffer+first_offset;
exact_size = antecedent_segment+middle_segment+subsequent_segment;
//fprintf(stderr, "the exact total length of asp file=%d\n", exact_size);
content_length_orig1 = strstr(req->buffer, "Content-Length:");
content_length_orig2 = strstr(content_length_orig1, "\r\n");
content_length_orig1 = content_length_orig1 + strlen("Content-Length: ");
orig_char_length = content_length_orig2 - content_length_orig1;
//fprintf(stderr, "the orig_char_length=%d\n", orig_char_length);
exact_char_length = strlen(simple_itoa(exact_size));
//fprintf(stderr, "the exact_char_length=%d\n", exact_char_length);
if(orig_char_length == exact_char_length) {
//fprintf(stderr, "Update the content length with the same char length!\n");
memcpy(content_length_orig1, simple_itoa(exact_size),exact_char_length);
}else if(orig_char_length < exact_char_length) {
//fprintf(stderr, " Update the content length with shift to later bytes!\n");
byte_shift = exact_char_length - orig_char_length;
head_offset = first_offset- (content_length_orig2 - req->buffer);
total_length_shift = head_offset+exact_size;
memmove((content_length_orig2+byte_shift), content_length_orig2, total_length_shift);
memcpy(content_length_orig1, simple_itoa(exact_size),exact_char_length);
req->buffer_end = req->buffer_end+byte_shift;
}else {
//fprintf(stderr, "Update the content length with shift to preceding bytes!\n");
byte_shift = orig_char_length - exact_char_length;
head_offset = first_offset- (content_length_orig2 - req->buffer);
total_length_shift = head_offset+exact_size;
memmove((content_length_orig2-byte_shift), content_length_orig2, total_length_shift);
memcpy(content_length_orig1, simple_itoa(exact_size),exact_char_length);
req->buffer_end = req->buffer_end-byte_shift;
}
//Brad add end for update content length
if (req->filepos == req->filesize) {
// req->status = CLOSE;
return 0; /* done! */
}
/* We lose statbuf here, so make sure response has been sent */
return 1;
}
int get_dir(request * req, struct stat *statbuf)
{
char pathname_with_index[MAX_PATH_LENGTH];
int data_fd;
if (directory_index) { /* look for index.html first?? */
strcpy(pathname_with_index, req->pathname);
strcat(pathname_with_index, directory_index);
/*
sprintf(pathname_with_index, "%s%s", req->pathname, directory_index);
*/
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) { /* user's index file */
strcpy(req->request_uri, directory_index); /* for mimetype */
fstat(data_fd, statbuf);
return data_fd;
}
if (errno == EACCES) {
send_r_forbidden(req);
return -1;
} else if (errno != ENOENT) {
/* if there is an error *other* than EACCES or ENOENT */
send_r_not_found(req);
return -1;
}
#ifdef GUNZIP
/* if we are here, trying index.html didn't work
* try index.html.gz
*/
strcat(pathname_with_index, ".gz");
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) { /* user's index file */
close(data_fd);
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
if (req->pathname)
free(req->pathname);
req->pathname = strdup(pathname_with_index);
if (!req->pathname) {
log_error_time();
perror("strdup");
send_r_error(req);
return 0;
}
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: ");
req_write(req, get_mime_type(directory_index));
req_write(req, "\r\n\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
#endif
}
/* only here if index.html, index.html.gz don't exist */
if (dirmaker != NULL) { /* don't look for index.html... maybe automake? */
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
/* the indexer should take care of all headers */
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: text/html\r\n\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
/* in this case, 0 means success */
} else if (cachedir) {
return get_cachedir_file(req, statbuf);
} else { /* neither index.html nor autogenerate are allowed */
send_r_forbidden(req);
return -1; /* nothing worked */
}
}
int init_get(request * req)
{
int data_fd, saved_errno, dynamic=0;
struct stat statbuf;
volatile int bytes;
data_fd = open(req->pathname, O_RDONLY);
saved_errno = errno; /* might not get used */
#ifdef GUNZIP
if (data_fd == -1 && errno == ENOENT) {
/* cannot open */
/* it's either a gunzipped file or a directory */
char gzip_pathname[MAX_PATH_LENGTH];
int len;
len = strlen(req->pathname);
memcpy(gzip_pathname, req->pathname, len);
memcpy(gzip_pathname + len, ".gz", 3);
gzip_pathname[len + 3] = '\0';
data_fd = open(gzip_pathname, O_RDONLY);
if (data_fd != -1) {
close(data_fd);
req->response_status = R_REQUEST_OK;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(gzip_pathname);
if (!req->pathname) {
log_error_time();
perror("strdup");
send_r_error(req);
return 0;
}
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, "\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
}
#endif
if (data_fd == -1) {
log_error_doc(req);
errno = saved_errno;
perror("document open");
if (saved_errno == ENOENT)
send_r_not_found(req);
else if (saved_errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
}
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) { /* directory */
close(data_fd); /* close dir */
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
if (server_port != 80)
sprintf(buffer, "http://%s:%d%s/", server_name,
server_port, req->request_uri);
else
sprintf(buffer, "http://%s%s/", server_name,
req->request_uri);
send_r_moved_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf); /* updates statbuf */
if (data_fd == -1) /* couldn't do it */
return 0; /* errors reported by get_dir */
else if (data_fd <= 1)
/* data_fd == 0 -> close it down, 1 -> continue */
return data_fd;
/* else, data_fd contains the fd of the file... */
}
#ifdef DAVINCI_IPCAM
if (req->http_uri && (req->http_uri->uri_flag & URI_FLAG_NEED_PARSE))
dynamic = 1;
#endif
if (req->if_modified_since && !dynamic &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
req->filesize = statbuf.st_size;
req->last_modified = statbuf.st_mtime;
if (req->method == M_HEAD || req->filesize == 0) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
if (req->filesize > MAX_FILE_MMAP) {
send_r_request_ok(req); /* All's well */
req->status = PIPE_READ;
req->cgi_status = CGI_BUFFER;
req->data_fd = data_fd;
req_flush(req); /* this should *always* complete due to
the size of the I/O buffers */
req->header_line = req->header_end = req->buffer;
return 1;
}
if (req->filesize == 0) { /* done */
send_r_request_ok(req); /* All's well *so far* */
close(data_fd);
return 1;
}
/* NOTE: I (Jon Nelson) tried performing a read(2)
* into the output buffer provided the file data would
* fit, before mmapping, and if successful, writing that
* and stopping there -- all to avoid the cost
* of a mmap. Oddly, it was *slower* in benchmarks.
*/
req->mmap_entry_var = find_mmap(data_fd, &statbuf);
if (req->mmap_entry_var == NULL) {
req->buffer_end = 0;
if (errno == ENOENT)
send_r_not_found(req);
else if (errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
close(data_fd);
return 0;
}
req->data_mem = req->mmap_entry_var->mmap;
close(data_fd); /* close data file */
if ((long) req->data_mem == -1) {
boa_perror(req, "mmap");
return 0;
}
#ifdef DAVINCI_IPCAM
if (dynamic) {
char *addr = (char *)malloc(req->filesize + 1025);
if (addr) {
req->mem_flag |= MFLAG_IS_MEMORY;
req->mmap_ptr = req->data_mem;
req->mmap_size = req->filesize;
memcpy(addr+1024, req->data_mem, req->filesize);
addr[req->filesize+1024] = '\0';
req->data_mem = addr;
req->filesize = html_argument_parse(req->authority, addr+1024, req->data_mem);
send_request_ok_no_cache(req); /* All's well */
return 1;
}
}
#endif // DAVINCI_IPCAM
send_r_request_ok(req); /* All's well */
bytes = BUFFER_SIZE - req->buffer_end;
/* bytes is now how much the buffer can hold
* after the headers
*/
if (bytes > 0) {
if (bytes > req->filesize)
bytes = req->filesize;
if (sigsetjmp(env, 1) == 0) {
handle_sigbus = 1;
memcpy(req->buffer + req->buffer_end, req->data_mem, bytes);
handle_sigbus = 0;
/* OK, SIGBUS **after** this point is very bad! */
} else {
/* sigbus! */
log_error_doc(req);
reset_output_buffer(req);
send_r_error(req);
fprintf(stderr, "%sGot SIGBUS in memcpy!\n", get_commonlog_time());
return 0;
}
req->buffer_end += bytes;
req->filepos += bytes;
if (req->filesize == req->filepos) {
req_flush(req);
req->status = DONE;
}
}
/* We lose statbuf here, so make sure response has been sent */
return 1;
}
int init_get(request * req)
{
int data_fd, saved_errno;
struct stat statbuf;
volatile int bytes;
data_fd = open(req->pathname, O_RDONLY);
saved_errno = errno;
#ifdef GUNZIP
if (data_fd == -1 && errno == ENOENT) {
char gzip_pathname[MAX_PATH_LENGTH];
int len;
len = strlen(req->pathname);
memcpy(gzip_pathname, req->pathname, len);
memcpy(gzip_pathname + len, ".gz", 3);
gzip_pathname[len + 3] = '\0';
data_fd = open(gzip_pathname, O_RDONLY);
if (data_fd != -1) {
close(data_fd);
req->response_status = R_REQUEST_OK;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(gzip_pathname);
if (!req->pathname) {
log_error_time();
perror("strdup");
send_r_error(req);
return 0;
}
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, "\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
}
#endif
if (data_fd == -1) {
log_error_doc(req);
errno = saved_errno;
perror("document open");
if (saved_errno == ENOENT)
send_r_not_found(req);
else if (saved_errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
}
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) {
close(data_fd);
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
if (server_port != 80)
sprintf(buffer, "http://%s:%d%s/", server_name,
server_port, req->request_uri);
else
sprintf(buffer, "http://%s%s/", server_name,
req->request_uri);
send_r_moved_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf);
if (data_fd == -1)
return 0;
else if (data_fd <= 1)
return data_fd;
}
if (req->if_modified_since &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
req->filesize = statbuf.st_size;
req->last_modified = statbuf.st_mtime;
if (req->method == M_HEAD || req->filesize == 0) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
if (req->filesize > MAX_FILE_MMAP) {
send_r_request_ok(req);
req->status = PIPE_READ;
req->cgi_status = CGI_BUFFER;
req->data_fd = data_fd;
req_flush(req); /* this should *always* complete due to
the size of the I/O buffers */
req->header_line = req->header_end = req->buffer;
return 1;
}
if (req->filesize == 0) {
send_r_request_ok(req);
close(data_fd);
return 1;
}
/* NOTE: I (Jon Nelson) tried performing a read(2)
* into the output buffer provided the file data would
* fit, before mmapping, and if successful, writing that
* and stopping there -- all to avoid the cost
* of a mmap. Oddly, it was *slower* in benchmarks.
*/
req->mmap_entry_var = find_mmap(data_fd, &statbuf);
if (req->mmap_entry_var == NULL) {
req->buffer_end = 0;
if (errno == ENOENT)
send_r_not_found(req);
else if (errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
close(data_fd);
return 0;
}
req->data_mem = req->mmap_entry_var->mmap;
close(data_fd);
if ((long) req->data_mem == -1) {
boa_perror(req, "mmap");
return 0;
}
send_r_request_ok(req);
bytes = BUFFER_SIZE - req->buffer_end;
/* bytes is now how much the buffer can hold
* after the headers
*/
if (bytes > 0) {
if (bytes > req->filesize)
bytes = req->filesize;
if (sigsetjmp(env, 1) == 0) {
handle_sigbus = 1;
memcpy(req->buffer + req->buffer_end, req->data_mem, bytes);
handle_sigbus = 0;
} else {
log_error_doc(req);
reset_output_buffer(req);
send_r_error(req);
fprintf(stderr, "%sGot SIGBUS in memcpy!\n", get_commonlog_time());
return 0;
}
req->buffer_end += bytes;
req->filepos += bytes;
if (req->filesize == req->filepos) {
req_flush(req);
req->status = DONE;
}
}
return 1;
}
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;
}
int init_get(request * req)
{
int data_fd;
struct stat statbuf;
data_fd = open(req->pathname, O_RDONLY);
if (data_fd == -1) { /* cannot open */
/* it's either a gunzipped file or a directory */
#ifdef GUNZIP
char gzip_pathname[MAX_PATH_LENGTH];
int len;
len = strlen(req->pathname);
memcpy(gzip_pathname, req->pathname, len);
memcpy(gzip_pathname + len, ".gz", 3);
gzip_pathname[len + 3] = '\0';
data_fd = open(gzip_pathname, O_RDONLY);
if (data_fd == -1) {
#endif
int errno_save = errno;
log_error_doc(req);
errno = errno_save;
perror("document open");
errno = errno_save;
if (errno == ENOENT)
send_r_not_found(req);
else if (errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
#ifdef GUNZIP
}
close(data_fd);
req->response_status = R_REQUEST_OK;
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, "\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(gzip_pathname);
return init_cgi(req);
#endif
}
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) { /* directory */
close(data_fd); /* close dir */
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
if (server_port != 80)
sprintf(buffer, "http://%s:%d%s/", server_name,
server_port, req->request_uri);
else
sprintf(buffer, "http://%s%s/", server_name,
req->request_uri);
send_redirect_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf); /* updates statbuf */
if (data_fd == -1) /* couldn't do it */
return 0; /* errors reported by get_dir */
else if (data_fd <= 1)
/* data_fd == 0 -> close it down, 1 -> continue */
return data_fd;
/* else, data_fd contains the fd of the file... */
}
if (req->if_modified_since &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
req->filesize = statbuf.st_size;
req->last_modified = statbuf.st_mtime;
if (req->method == M_HEAD) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
if (req->filesize > MAX_FILE_MMAP) {
send_r_request_ok(req); /* All's well */
req->status = PIPE_READ;
req->cgi_status = CGI_BUFFER;
req->data_fd = data_fd;
req_flush(req); /* this should *always* complete due to
the size of the I/O buffers */
req->header_line = req->header_end = req->buffer;
return 1;
}
req->mmap_entry_var = find_mmap(data_fd, &statbuf);
if (req->mmap_entry_var == NULL) {
send_r_error(req);
close(data_fd);
return 0;
}
req->data_mem = req->mmap_entry_var->mmap;
close(data_fd); /* close data file */
if ((long) req->data_mem == -1) {
boa_perror(req, "mmap");
return 0;
}
send_r_request_ok(req); /* All's well */
{ /* combine first part of file with headers */
int bob;
bob = BUFFER_SIZE - req->buffer_end;
/* bob is now how much the buffer can hold
* after the headers
*/
if (bob > 0) {
if (bob > req->filesize)
bob = req->filesize;
memcpy(req->buffer + req->buffer_end, req->data_mem, bob);
req->buffer_end += bob;
req->filepos += bob;
if (req->filesize == req->filepos) {
req_flush(req);
req->status = DONE;
return 1; /* get it flushed next time around if need be */
}
}
}
/* We lose statbuf here, so make sure response has been sent */
return 1;
}
int get_dir(request * req, struct stat *statbuf)
{
char pathname_with_index[MAX_PATH_LENGTH];
int data_fd;
sprintf(pathname_with_index, "%s%s", req->pathname, directory_index);
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) { /* user's index file */
strcat(req->request_uri, directory_index); /* for mimetype */
fstat(data_fd, statbuf);
return data_fd;
}
if (errno == EACCES) {
send_r_forbidden(req);
return -1;
}
#ifdef GUNZIP
strcat(pathname_with_index, ".gz");
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) { /* user's index file */
close(data_fd);
req->response_status = R_REQUEST_OK;
if (req->method == M_HEAD) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: ");
req_write(req, get_mime_type(directory_index));
req_write(req, "\r\n\r\n");
req_flush(req);
return 0;
}
if (req->pathname)
free(req->pathname);
req->pathname = strdup(pathname_with_index);
if (init_cgi(req) == 0)
return -1;
return 0; /* in this case, 0 means success */
} else
#endif
if (dirmaker != NULL) {
req->response_status = R_REQUEST_OK;
/* the indexer should take care of all headers */
if (!req->simple || req->method == M_HEAD) {
req_write(req, "HTTP/1.0 200 OK\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: ");
req_write(req, get_mime_type(directory_index));
req_write(req, "\r\n\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return (init_cgi(req) == 0 ? -1 : 0);
/* in this case, 0 means success */
}
send_r_forbidden(req);
return -1; /* nothing worked */
}
int get_dir(request * req, struct stat *statbuf)
{
char pathname_with_index[MAX_PATH_LENGTH];
int data_fd;
if (directory_index) {
strcpy(pathname_with_index, req->pathname);
strcat(pathname_with_index, directory_index);
/*
sprintf(pathname_with_index, "%s%s", req->pathname, directory_index);
*/
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) {
strcpy(req->request_uri, directory_index);
fstat(data_fd, statbuf);
return data_fd;
}
if (errno == EACCES) {
send_r_forbidden(req);
return -1;
} else if (errno != ENOENT) {
send_r_not_found(req);
return -1;
}
#ifdef GUNZIP
/* if we are here, trying index.html didn't work
* try index.html.gz
*/
strcat(pathname_with_index, ".gz");
data_fd = open(pathname_with_index, O_RDONLY);
if (data_fd != -1) {
close(data_fd);
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
if (req->pathname)
free(req->pathname);
req->pathname = strdup(pathname_with_index);
if (!req->pathname) {
log_error_time();
perror("strdup");
send_r_error(req);
return 0;
}
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: ");
req_write(req, get_mime_type(directory_index));
req_write(req, "\r\n\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
#endif
}
if (dirmaker != NULL) {
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK\r\n");
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: text/html\r\n\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
} else if (cachedir) {
return get_cachedir_file(req, statbuf);
} else {
send_r_forbidden(req);
return -1;
}
}
int process_get(request * req)
{
off_t bytes_written;
volatile off_t bytes_to_write;
if (req->method == M_HEAD) {
return complete_response(req);
}
bytes_to_write = (req->ranges->stop - req->ranges->start) + 1;
if (bytes_to_write > system_bufsize)
bytes_to_write = system_bufsize;
if (setjmp(env) == 0) {
handle_sigbus = 1;
bytes_written = write(req->fd, req->data_mem + req->ranges->start,
bytes_to_write);
handle_sigbus = 0;
/* OK, SIGBUS **after** this point is very bad! */
} else {
/* sigbus! */
req->status = DEAD;
log_error_doc(req);
fprintf(stderr, "%sGot SIGBUS in write(2)!\n",
get_commonlog_time());
/* sending an error here is inappropriate
* if we are here, the file is mmapped, and thus,
* a content-length has been sent. If we send fewer bytes
* the client knows there has been a problem.
* We run the risk of accidentally sending the right number
* of bytes (or a few too many) and the client
* won't be the wiser.
*/
return 0;
}
if (bytes_written < 0) {
if (errno == EWOULDBLOCK || errno == EAGAIN)
return -1;
/* request blocked at the pipe level, but keep going */
else {
#ifdef QUIET_DISCONNECT
if (errno != EPIPE) {
#else
if (1) {
#endif
log_error_doc(req);
/* Can generate lots of log entries, */
perror("write");
/* OK to disable if your logs get too big */
}
req->status = DEAD;
return 0;
}
}
req->bytes_written += bytes_written;
req->ranges->start += bytes_written;
if ((req->ranges->stop + 1 - req->ranges->start) == 0) {
return complete_response(req);
}
return 1; /* more to do */
}
/*
* Name: get_dir
* Description: Called from process_get if the request is a directory.
* statbuf must describe directory on input, since we may need its
* device, inode, and mtime.
* statbuf is updated, since we may need to check mtimes of a cache.
* returns:
* -1 error
* 0 cgi (either gunzip or auto-generated)
* >0 file descriptor of file
*/
int get_dir(request * req, struct stat *statbuf)
{
char pathname_with_index[MAX_PATH_LENGTH];
int data_fd;
if (directory_index) { /* look for index.html first?? */
unsigned int l1, l2;
l1 = strlen(req->pathname);
l2 = strlen(directory_index);
#ifdef GUNZIP
if (l1 + l2 + 3 + 1 > sizeof(pathname_with_index)) { /* for .gz */
#else
if (l1 + l2 + 1 > sizeof(pathname_with_index)) {
#endif
errno = ENOMEM;
boa_perror(req, "pathname_with_index not large enough for pathname + index");
return -1;
}
memcpy(pathname_with_index, req->pathname, l1); /* doesn't copy NUL */
memcpy(pathname_with_index + l1, directory_index, l2 + 1); /* does */
data_fd = open(pathname_with_index, O_RDONLY|O_LARGEFILE);
if (data_fd != -1) { /* user's index file */
/* We have to assume that directory_index will fit, because
* if it doesn't, well, that's a huge configuration problem.
* this is only the 'index.html' pathname for mime type
*/
memcpy(req->request_uri, directory_index, l2 + 1); /* for mimetype */
fstat(data_fd, statbuf);
return data_fd;
}
if (errno == EACCES) {
send_r_forbidden(req);
return -1;
} else if (errno != ENOENT) {
/* if there is an error *other* than EACCES or ENOENT */
send_r_not_found(req);
return -1;
}
#ifdef GUNZIP
/* if we are here, trying index.html didn't work
* try index.html.gz
*/
strcat(pathname_with_index, ".gz");
data_fd = open(pathname_with_index, O_RDONLY|O_LARGEFILE);
if (data_fd != -1) { /* user's index file */
close(data_fd);
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
if (req->pathname)
free(req->pathname);
req->pathname = strdup(pathname_with_index);
if (!req->pathname) {
boa_perror(req, "strdup of pathname_with_index for .gz files " __FILE__ ":" STR(__LINE__));
return 0;
}
if (req->http_version != HTTP09) {
req_write(req, http_ver_string(req->http_version));
req_write(req, " 200 OK-GUNZIP" CRLF);
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: ");
req_write(req, get_mime_type(directory_index));
req_write(req, CRLF CRLF);
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
#endif
}
/* only here if index.html, index.html.gz don't exist */
if (dirmaker != NULL) { /* don't look for index.html... maybe automake? */
req->response_status = R_REQUEST_OK;
SQUASH_KA(req);
/* the indexer should take care of all headers */
if (req->http_version != HTTP09) {
req_write(req, http_ver_string(req->http_version));
req_write(req, " 200 OK" CRLF);
print_http_headers(req);
print_last_modified(req);
req_write(req, "Content-Type: text/html" CRLF CRLF);
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
/* in this case, 0 means success */
} else if (cachedir) {
return get_cachedir_file(req, statbuf);
} else { /* neither index.html nor autogenerate are allowed */
send_r_forbidden(req);
return -1; /* nothing worked */
}
}
static int get_cachedir_file(request * req, struct stat *statbuf)
{
char pathname_with_index[MAX_PATH_LENGTH];
int data_fd;
time_t real_dir_mtime;
real_dir_mtime = statbuf->st_mtime;
/* the sizeof() doesn't need a -1 because snprintf will
* include the NUL when calculating if the size is enough
*/
snprintf(pathname_with_index, sizeof(pathname_with_index),
"%s/dir.%d." PRINTF_OFF_T_ARG, cachedir,
(int) statbuf->st_dev, statbuf->st_ino);
data_fd = open(pathname_with_index, O_RDONLY|O_LARGEFILE);
if (data_fd != -1) { /* index cache */
fstat(data_fd, statbuf);
if (statbuf->st_mtime > real_dir_mtime) {
statbuf->st_mtime = real_dir_mtime; /* lie */
strcpy(req->request_uri, directory_index); /* for mimetype */
return data_fd;
}
close(data_fd);
unlink(pathname_with_index); /* cache is stale, delete it */
}
if (index_directory(req, pathname_with_index) == -1)
return -1;
data_fd = open(pathname_with_index, O_RDONLY|O_LARGEFILE); /* Last chance */
if (data_fd != -1) {
strcpy(req->request_uri, directory_index); /* for mimetype */
fstat(data_fd, statbuf);
statbuf->st_mtime = real_dir_mtime; /* lie */
return data_fd;
}
boa_perror(req, "re-opening dircache");
return -1; /* Nothing worked. */
}
int init_get(request * req)
{
int data_fd;
char buf[MAX_PATH_LENGTH];
struct stat statbuf;
req->cgi_env[req->cgi_env_index] = NULL; /* terminate cgi env */
data_fd = open(req->pathname, O_RDONLY);
if (data_fd == -1) { /* cannot open */
#ifdef GUNZIP
sprintf(buf, "%s.gz", req->pathname);
data_fd = open(buf, O_RDONLY);
if (data_fd == -1) {
#endif
int errno_save = errno;
log_error_doc(req);
errno = errno_save;
#if 0
perror("document open");
#endif
syslog(LOG_ERR, "Error opening %s for %s: %s\n", req->pathname,
req->remote_ip_addr, strerror(errno_save));
errno = errno_save;
if (errno == ENOENT)
send_r_not_found(req);
else if (errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
#ifdef GUNZIP
}
close(data_fd);
req->response_status = R_REQUEST_OK;
if (!req->simple) {
req_write(req, "HTTP/1.0 200 OK-GUNZIP\r\n");
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, "\r\n");
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(buf);
return init_cgi(req); /* 1 - OK, 2 - die */
#endif
}
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) { /* directory */
close(data_fd); /* close dir */
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
if (server_port != 80)
sprintf(buffer, "http://%s:%d%s/", req->host?req->host:server_name, server_port,
req->request_uri);
else
sprintf(buffer, "http://%s%s/", req->host?req->host:server_name, req->request_uri);
send_redirect_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf); /* updates statbuf */
if (data_fd == -1) /* couldn't do it */
return 0; /* errors reported by get_dir */
else if (data_fd == 0)
return 1;
}
if (req->if_modified_since &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
req->filesize = statbuf.st_size;
req->last_modified = statbuf.st_mtime;
if (req->method == M_HEAD) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
/* MAP_OPTIONS: see compat.h */
req->data_mem = mmap(0, req->filesize,
#ifdef USE_NLS
PROT_READ|PROT_WRITE
#else
PROT_READ
#endif
, MAP_OPTIONS,data_fd, 0);
close(data_fd); /* close data file */
if ((long) req->data_mem == -1) {
boa_perror(req, "mmap");
return 0;
}
send_r_request_ok(req); /* All's well */
{
int bob;
bob = BUFFER_SIZE - req->buffer_end;
if (bob > 0) {
if (bob > req->filesize - req->filepos)
bob = req->filesize - req->filepos;
memcpy(req->buffer + req->buffer_end,
req->data_mem + req->filepos,
bob);
req->buffer_end += bob;
req->filepos += bob;
}
}
if (req->filepos == req->filesize) {
req->status = CLOSE;
return 0; /* done! */
}
/* We lose statbuf here, so make sure response has been sent */
return 1;
}
/*===========================================================================*
* do_fcntl *
*===========================================================================*/
int do_fcntl(void)
{
/* Perform the fcntl(fd, cmd, ...) system call. */
register struct filp *f;
int new_fd, fl, r = OK, fcntl_req, fcntl_argx;
tll_access_t locktype;
scratch(fp).file.fd_nr = job_m_in.m_lc_vfs_fcntl.fd;
scratch(fp).io.io_buffer = job_m_in.m_lc_vfs_fcntl.arg_ptr;
scratch(fp).io.io_nbytes = job_m_in.m_lc_vfs_fcntl.cmd;
fcntl_req = job_m_in.m_lc_vfs_fcntl.cmd;
fcntl_argx = job_m_in.m_lc_vfs_fcntl.arg_int;
/* Is the file descriptor valid? */
locktype = (fcntl_req == F_FREESP) ? VNODE_WRITE : VNODE_READ;
if ((f = get_filp(scratch(fp).file.fd_nr, locktype)) == NULL)
return(err_code);
switch (fcntl_req) {
case F_DUPFD:
/* This replaces the old dup() system call. */
if (fcntl_argx < 0 || fcntl_argx >= OPEN_MAX) r = EINVAL;
else if ((r = get_fd(fp, fcntl_argx, 0, &new_fd, NULL)) == OK) {
f->filp_count++;
fp->fp_filp[new_fd] = f;
r = new_fd;
}
break;
case F_GETFD:
/* Get close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
r = 0;
if (FD_ISSET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set))
r = FD_CLOEXEC;
break;
case F_SETFD:
/* Set close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
if (fcntl_argx & FD_CLOEXEC)
FD_SET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set);
else
FD_CLR(scratch(fp).file.fd_nr, &fp->fp_cloexec_set);
break;
case F_GETFL:
/* Get file status flags (O_NONBLOCK and O_APPEND). */
fl = f->filp_flags & (O_NONBLOCK | O_APPEND | O_ACCMODE);
r = fl;
break;
case F_SETFL:
/* Set file status flags (O_NONBLOCK and O_APPEND). */
fl = O_NONBLOCK | O_APPEND;
f->filp_flags = (f->filp_flags & ~fl) | (fcntl_argx & fl);
break;
case F_GETLK:
case F_SETLK:
case F_SETLKW:
/* Set or clear a file lock. */
r = lock_op(f, fcntl_req);
break;
case F_FREESP:
{
/* Free a section of a file */
off_t start, end, offset;
struct flock flock_arg;
/* Check if it's a regular file. */
if (!S_ISREG(f->filp_vno->v_mode)) r = EINVAL;
else if (!(f->filp_mode & W_BIT)) r = EBADF;
else {
/* Copy flock data from userspace. */
r = sys_datacopy_wrapper(who_e, scratch(fp).io.io_buffer,
SELF, (vir_bytes) &flock_arg, sizeof(flock_arg));
}
if (r != OK) break;
/* Convert starting offset to signed. */
offset = (off_t) flock_arg.l_start;
/* Figure out starting position base. */
switch(flock_arg.l_whence) {
case SEEK_SET: start = 0; break;
case SEEK_CUR: start = f->filp_pos; break;
case SEEK_END: start = f->filp_vno->v_size; break;
default: r = EINVAL;
}
if (r != OK) break;
/* Check for overflow or underflow. */
if (offset > 0 && start + offset < start) r = EINVAL;
else if (offset < 0 && start + offset > start) r = EINVAL;
else {
start += offset;
if (start < 0) r = EINVAL;
}
if (r != OK) break;
if (flock_arg.l_len != 0) {
if (start >= f->filp_vno->v_size) r = EINVAL;
else if ((end = start + flock_arg.l_len) <= start) r = EINVAL;
else if (end > f->filp_vno->v_size) end = f->filp_vno->v_size;
} else {
end = 0;
}
if (r != OK) break;
r = req_ftrunc(f->filp_vno->v_fs_e, f->filp_vno->v_inode_nr,start,end);
if (r == OK && flock_arg.l_len == 0)
f->filp_vno->v_size = start;
break;
}
case F_GETNOSIGPIPE:
r = !!(f->filp_flags & O_NOSIGPIPE);
break;
case F_SETNOSIGPIPE:
if (fcntl_argx)
f->filp_flags |= O_NOSIGPIPE;
else
f->filp_flags &= ~O_NOSIGPIPE;
break;
case F_FLUSH_FS_CACHE:
{
struct vnode *vn = f->filp_vno;
mode_t mode = f->filp_vno->v_mode;
if (!super_user) {
r = EPERM;
} else if (S_ISBLK(mode)) {
/* Block device; flush corresponding device blocks. */
r = req_flush(vn->v_bfs_e, vn->v_sdev);
} else if (S_ISREG(mode) || S_ISDIR(mode)) {
/* Directory or regular file; flush hosting FS blocks. */
r = req_flush(vn->v_fs_e, vn->v_dev);
} else {
/* Remaining cases.. Meaning unclear. */
r = ENODEV;
}
break;
}
default:
r = EINVAL;
}
unlock_filp(f);
return(r);
}
void process_requests(void)
{
int retval = 0;
request *current, *trailer;
current = request_ready;
while (current) {
#ifdef CRASHDEBUG
crashdebug_current = current;
#endif
if (current->buffer_end) {
req_flush(current);
if (current->status == CLOSE)
retval = 0;
else
retval = 1;
} else {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
default:
retval = 0;
#if 0
fprintf(stderr, "Unknown status (%d), closing!\n",
current->status);
#endif
break;
}
}
if (lame_duck_mode)
SQUASH_KA(current);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
default: /* everything else means an error, jump ship */
send_r_error(current);
/* fall-through */
case 0: /* request complete */
trailer = current;
current = current->next;
free_request(&request_ready, trailer);
break;
case 1: /* more to do */
current->time_last = time_counter;
current = current->next;
break;
}
}
#ifdef CRASHDEBUG
crashdebug_current = current;
#endif
}
void process_requests(int server_sock)
{
int retval = 0;
request *current, *trailer;
if (pending_requests) {
get_request(server_sock);
#ifdef ORIGINAL_BEHAVIOR
pending_requests = 0;
#endif
}
current = request_ready;
while (current) {
time(¤t_time);
retval = 1; /* emulate "success" in case we don't have to flush */
if (current->buffer_end && /* there is data in the buffer */
current->status < TIMED_OUT) {
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval >= 0) {
/* notice the >= which is different from below?
Here, we may just be flushing headers.
We don't want to return 0 because we are not DONE
or DEAD */
retval = 1;
}
}
if (retval == 1) {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
case IOSHUFFLE:
#ifdef HAVE_SENDFILE
retval = io_shuffle_sendfile(current);
#else
retval = io_shuffle(current);
#endif
break;
case DONE:
/* a non-status that will terminate the request */
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval > 0) {
retval = 1;
}
break;
case TIMED_OUT:
case DEAD:
retval = 0;
current->buffer_end = 0;
SQUASH_KA(current);
break;
default:
retval = 0;
fprintf(stderr, "Unknown status (%d), "
"closing!\n", current->status);
current->status = DEAD;
break;
}
}
if (sigterm_flag)
{
SQUASH_KA(current);
}
/* we put this here instead of after the switch so that
* if we are on the last request, and get_request is successful,
* current->next is valid!
*/
if (pending_requests)
get_request(server_sock);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
case 0: /* request complete */
current->time_last = current_time;
trailer = current;
current = current->next;
free_request(trailer);
break;
case 1: /* more to do */
current->time_last = current_time;
current = current->next;
break;
default:
log_error_doc(current);
fprintf(stderr, "Unknown retval in process.c - "
"Status: %d, retval: %d\n", current->status, retval);
current->status = DEAD;
current = current->next;
break;
}
}
}
int init_get(request * req)
{
int data_fd, saved_errno;
struct stat statbuf;
volatile off_t bytes_free;
data_fd = open(req->pathname, O_RDONLY|O_LARGEFILE);
saved_errno = errno; /* might not get used */
while (use_lang_rewrite && data_fd == -1 && errno == ENOENT) {
/* We cannot open that file - Check whether we can rewrite it
* to a different language suffix. We only support filenames
* of the format: "foo.ll.html" as an alias for "foo.html". */
unsigned int len;
len = strlen(req->pathname);
if (len < 6 || strcmp (req->pathname + len - 5, ".html"))
break; /* does not end in ".html" */
if (len > 8 && req->pathname[len-8] == '.'
&& req->pathname[len-7] >= 'a' && req->pathname[len-7] <= 'z'
&& req->pathname[len-6] >= 'a' && req->pathname[len-6] <= 'z') {
/* The request was for a language dependent file. Strip
* it and try the generic form. */
char save_name[8];
strcpy (save_name, req->pathname + len - 7);
strcpy (req->pathname + len - 7, "html");
data_fd = open(req->pathname, O_RDONLY);
if (data_fd == -1)
strcpy (req->pathname + len - 7, save_name);
break;
}
else if ( 0 ) {
/* Fixme: Other items to try from the list of accepted_languages */
data_fd = open(req->pathname, O_RDONLY);
}
else
break;
}
#ifdef GUNZIP
if (data_fd == -1 && errno == ENOENT) {
/* cannot open */
/* it's either a gunzipped file or a directory */
char gzip_pathname[MAX_PATH_LENGTH];
unsigned int len;
len = strlen(req->pathname);
if (len + 4 > sizeof(gzip_pathname)) {
log_error_doc(req);
fprintf(stderr, "Pathname + .gz too long! (%s)\n", req->pathname);
send_r_bad_request(req);
return 0;
}
memcpy(gzip_pathname, req->pathname, len);
memcpy(gzip_pathname + len, ".gz", 3);
gzip_pathname[len + 3] = '\0';
data_fd = open(gzip_pathname, O_RDONLY|O_LARGEFILE);
if (data_fd != -1) {
close(data_fd);
req->response_status = R_REQUEST_OK;
if (req->pathname)
free(req->pathname);
req->pathname = strdup(gzip_pathname);
if (!req->pathname) {
boa_perror(req, "strdup req->pathname for gzipped filename " __FILE__ ":" STR(__LINE__));
return 0;
}
if (req->http_version != HTTP09) {
req_write(req, http_ver_string(req->http_version));
req_write(req, " 200 OK-GUNZIP" CRLF);
print_http_headers(req);
print_content_type(req);
print_last_modified(req);
req_write(req, CRLF);
req_flush(req);
}
if (req->method == M_HEAD)
return 0;
return init_cgi(req);
}
}
#endif
if (data_fd == -1) {
log_error_doc(req);
errno = saved_errno;
perror("document open");
if (saved_errno == ENOENT)
send_r_not_found(req);
else if (saved_errno == EACCES)
send_r_forbidden(req);
else
send_r_bad_request(req);
return 0;
}
#ifdef ACCESS_CONTROL
if (!access_allow(req->pathname)) {
send_r_forbidden(req);
return 0;
}
#endif
fstat(data_fd, &statbuf);
if (S_ISDIR(statbuf.st_mode)) { /* directory */
close(data_fd); /* close dir */
if (req->pathname[strlen(req->pathname) - 1] != '/') {
char buffer[3 * MAX_PATH_LENGTH + 128];
unsigned int len;
#ifdef ALLOW_LOCAL_REDIRECT
len = strlen(req->request_uri);
if (len + 2 > sizeof(buffer)) {
send_r_error(req);
return 0;
}
memcpy(buffer, req->request_uri, len);
buffer[len] = '/';
buffer[len+1] = '\0';
#else
char *host = server_name;
unsigned int l2;
char *port = NULL;
const char *prefix = hsts_header? "https://" : "http://";
static unsigned int l3 = 0;
static unsigned int l4 = 0;
if (l4 == 0) {
l4 = strlen(prefix);
}
len = strlen(req->request_uri);
if (!port && server_port != 80 && !no_redirect_port) {
port = strdup(simple_itoa(server_port));
if (port == NULL) {
errno = ENOMEM;
boa_perror(req, "Unable to perform simple_itoa conversion on server port!");
return 0;
}
l3 = strlen(port);
}
/* l3 and l4 are done */
if (req->host) {
/* only shows up in vhost mode */
/* what about the port? (in vhost_mode?) */
/* we don't currently report ports that differ
* from out "bound" (listening) port, so we don't care
*/
host = req->host;
}
l2 = strlen(host);
if (server_port != 80 && !no_redirect_port) {
if (l4 + l2 + 1 + l3 + len + 1 > sizeof(buffer)) {
errno = ENOMEM;
boa_perror(req, "buffer not large enough for directory redirect");
return 0;
}
memcpy(buffer, prefix, l4);
memcpy(buffer + l4, host, l2);
buffer[l4 + l2] = ':';
memcpy(buffer + l4 + l2 + 1, port, l3);
memcpy(buffer + l4 + l2 + 1 + l3, req->request_uri, len);
buffer[l4 + l2 + 1 + l3 + len] = '/';
buffer[l4 + l2 + 1 + l3 + len + 1] = '\0';
} else {
if (l4 + l2 + len + 1 > sizeof(buffer)) {
errno = ENOMEM;
boa_perror(req, "buffer not large enough for directory redirect");
return 0;
}
memcpy(buffer, prefix, l4);
memcpy(buffer + l4, host, l2);
memcpy(buffer + l4 + l2, req->request_uri, len);
buffer[l4 + l2 + len] = '/';
buffer[l4 + l2 + len + 1] = '\0';
}
#endif /* ALLOW LOCAL REDIRECT */
send_r_moved_perm(req, buffer);
return 0;
}
data_fd = get_dir(req, &statbuf); /* updates statbuf */
if (data_fd < 0) /* couldn't do it */
return 0; /* errors reported by get_dir */
else if (data_fd == 0 || data_fd == 1)
return data_fd;
/* else, data_fd contains the fd of the file... */
}
if (!S_ISREG(statbuf.st_mode)) { /* regular file */
log_error_doc(req);
fprintf(stderr, "Resulting file is not a regular file.\n");
send_r_bad_request(req);
close(data_fd);
return 0;
}
/* If-UnModified-Since asks
* is the file newer than date located in time_cval
* yes -> return 412
* no -> return 200
*
* If-Modified-Since asks
* is the file date less than or same as the date located in time_cval
* yes -> return 304
* no -> return 200
*
* If-Unmodified-Since overrides If-Modified-Since
*/
/*
if (req->headers[H_IF_UNMODIFIED_SINCE] &&
modified_since(&(statbuf.st_mtime),
req->headers[H_IF_UNMODIFIED_SINCE])) {
send_r_precondition_failed(req);
return 0;
} else
*/
if (req->if_modified_since &&
!modified_since(&(statbuf.st_mtime), req->if_modified_since)) {
send_r_not_modified(req);
close(data_fd);
return 0;
}
req->filesize = statbuf.st_size;
req->last_modified = statbuf.st_mtime;
/* ignore if-range without range */
if (req->header_ifrange && !req->ranges)
req->header_ifrange = NULL;
/* we don't support it yet */
req->header_ifrange = NULL;
/* parse ranges now */
/* we have to wait until req->filesize exists to fix them up */
/* fixup handles handles communicating with the client */
/* ranges_fixup logs as appropriate, and sends
* send_r_invalid_range on error.
*/
if (req->filesize == 0) {
if (req->http_version < HTTP11) {
send_r_request_ok(req);
close(data_fd);
return 0;
}
send_r_no_content(req);
close(data_fd);
return 0;
}
if (req->ranges && !ranges_fixup(req)) {
close(data_fd);
return 0;
}
/* if no range has been set, use default range */
#if 0
DEBUG(DEBUG_RANGE) {
log_error_time();
fprintf(stderr, "if-range: %s\time_cval: %d\tmtime: %d\n",
req->header_ifrange, req->time_cval, statbuf->st_mtime);
}
#endif
/*
If the entity tag given in the If-Range header matches the current
entity tag for the entity, then the server should provide the
specified sub-range of the entity using a 206 (Partial content)
response.
If the entity tag does not match, then the server should
return the entire entity using a 200 (OK) response.
*/
/* IF we have range data *and* no if-range or if-range matches... */
#ifdef MAX_FILE_MMAP
if (req->filesize > MAX_FILE_MMAP) {
req->data_fd = data_fd;
req->status = IOSHUFFLE;
} else
#endif
{
/* NOTE: I (Jon Nelson) tried performing a read(2)
* into the output buffer provided the file data would
* fit, before mmapping, and if successful, writing that
* and stopping there -- all to avoid the cost
* of a mmap. Oddly, it was *slower* in benchmarks.
*/
req->mmap_entry_var = find_mmap(data_fd, &statbuf);
if (req->mmap_entry_var == NULL) {
req->data_fd = data_fd;
req->status = IOSHUFFLE;
} else {
req->data_mem = req->mmap_entry_var->mmap;
close(data_fd); /* close data file */
}
}
if (!req->ranges) {
req->ranges = range_pool_pop();
req->ranges->start = 0;
req->ranges->stop = -1;
if (!ranges_fixup(req)) {
return 0;
}
send_r_request_ok(req);
} else {
/* FIXME: support if-range header here, by the following logic:
* if !req->header_ifrange || st_mtime > header_ifrange,
* send_r_partial_content
* else
* reset-ranges, etc...
*/
if (!req->header_ifrange) {
send_r_partial_content(req);
} else {
/* either no if-range or the if-range does not match */
ranges_reset(req);
req->ranges = range_pool_pop();
req->ranges->start = 0;
req->ranges->stop = -1;
if (!ranges_fixup(req)) {
return 0;
}
send_r_request_ok(req);
}
}
if (req->method == M_HEAD) {
return complete_response(req);
}
bytes_free = 0;
if (req->data_mem) {
/* things can really go tilt if req->buffer_end > BUFFER_SIZE,
* but basically that can't happen
*/
/* We lose statbuf here, so make sure response has been sent */
bytes_free = BUFFER_SIZE - req->buffer_end;
/* 256 bytes for the **trailing** headers */
/* bytes is now how much the buffer can hold
* after the headers
*/
}
if (req->data_mem && bytes_free > 256) {
unsigned int want;
Range *r;
r = req->ranges;
want = (r->stop - r->start) + 1;
if (bytes_free > want)
bytes_free = want;
else {
/* bytes_free <= want */
;
}
if (setjmp(env) == 0) {
handle_sigbus = 1;
memcpy(req->buffer + req->buffer_end,
req->data_mem + r->start, bytes_free);
handle_sigbus = 0;
/* OK, SIGBUS **after** this point is very bad! */
} else {
/* sigbus! */
log_error_doc(req);
reset_output_buffer(req);
send_r_error(req);
log_error("Got SIGBUS in memcpy\n");
return 0;
}
req->buffer_end += bytes_free;
req->bytes_written += bytes_free;
r->start += bytes_free;
if (bytes_free == want) {
/* this will fit due to the 256 extra bytes_free */
return complete_response(req);
}
}
/* We lose statbuf here, so make sure response has been sent */
return 1;
}
void process_requests(int server_s, struct soap *soap)/*by SeanHou*/
{
/* :TODO:Monday, December 01, 2014 11:17:36 HKT:SeanHou: */
int OnvifEN = 0;
int lookupindex = 0;
char service_uri[100] = "";
memset((void*)&soap->peer, 0, sizeof(soap->peer));
soap->socket = SOAP_INVALID_SOCKET;
soap->error = SOAP_OK;
soap->errmode = 0;
soap->keep_alive = 0;
fprintf(stderr, "Warning:" \
"(==>%s).\n", __func__);
/* :TODO:End--- */
int retval = 0;
request *current, *trailer;
if (pending_requests) {
get_request(server_s);
#ifdef ORIGINAL_BEHAVIOR
pending_requests = 0;
#endif
}
current = request_ready;
while (current) {
/* :TODO:Monday, December 01, 2014 11:18:42 HKT:SeanHou: juge is onvif */
OnvifEN = isonvif(current->client_stream, service_uri, &lookupindex);
if(OnvifEN == 1)
{
fprintf(stderr, "[boa:onvif] Warning: is onvif line[%d]remote port[%d]h2ns[%d]remote ip[%s]\n", __LINE__, current->remote_port, htons(current->remote_port), current->remote_ip_addr);
struct sockaddr_in onvif_client_addr;
memset(&onvif_client_addr, 0, sizeof(onvif_client_addr));
onvif_client_addr.sin_family = AF_INET;
onvif_client_addr.sin_port = htons(current->remote_port);//随机端口
onvif_client_addr.sin_addr.s_addr = inet_addr(current->remote_ip_addr);//
soap->socket = current->fd;
soap->peer = onvif_client_addr;
if (soap_valid_socket(soap->socket))
{
soap->ip = ntohl(soap->peer.sin_addr.s_addr);
soap->port = (int)ntohs(soap->peer.sin_port);
soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
}
g_onvif_buffer = (char *)soap_malloc(soap, sizeof(current->client_stream));
strcpy(g_onvif_buffer, current->client_stream);//mark
soap_begin_recv(soap);
if (soap_envelope_begin_in(soap))
{
soap_send_fault(soap);
}
if (soap_recv_header(soap))
{
soap_send_fault(soap);
}
if (soap_body_begin_in(soap))
{
soap_send_fault(soap);
}
int errorCode = 0;
if (errorCode = soap_serve_request(soap))
{
fprintf(stderr, "[boa:onvif]soap_serve_request fail, errorCode %d \n", errorCode);
soap_send_fault(soap);
}
memset(current->client_stream, 0, CLIENT_STREAM_SIZE );
soap_dealloc(soap, NULL);
soap_destroy(soap);
soap_end(soap);
current->status = DONE;
close(soap->socket);
continue;
}
/* :TODO:End--- */
time(¤t_time);
if (current->buffer_end && /* there is data in the buffer */
current->status != DEAD && current->status != DONE) {
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval >= 0) {
/* notice the >= which is different from below?
Here, we may just be flushing headers.
We don't want to return 0 because we are not DONE
or DEAD */
retval = 1;
}
} else {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
case DONE:
/* a non-status that will terminate the request */
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval > 0) {
retval = 1;
}
break;
case DEAD:
retval = 0;
current->buffer_end = 0;
SQUASH_KA(current);
break;
default:
retval = 0;
fprintf(stderr, "Unknown status (%d), "
"closing!\n", current->status);
current->status = DEAD;
break;
}
}
if (sigterm_flag)
SQUASH_KA(current);
/* we put this here instead of after the switch so that
* if we are on the last request, and get_request is successful,
* current->next is valid!
*/
if (pending_requests)
get_request(server_s);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
case 0: /* request complete */
current->time_last = current_time;
trailer = current;
current = current->next;
free_request(&request_ready, trailer);
break;
case 1: /* more to do */
current->time_last = current_time;
current = current->next;
break;
default:
log_error_time();
fprintf(stderr, "Unknown retval in process.c - "
"Status: %d, retval: %d\n", current->status, retval);
current = current->next;
break;
}
}
}
