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;
}
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;
}