static int mk_http_directory_redirect_check(struct client_session *cs,
struct session_request *sr)
{
int port_redirect = 0;
char *host;
char *location = 0;
char *real_location = 0;
unsigned long len;
/*
* We have to check if there is a slash at the end of
* this string. If it doesn't exist, we send a redirection header.
*/
if (sr->uri_processed.data[sr->uri_processed.len - 1] == '/') {
return 0;
}
host = mk_ptr_t_to_buf(sr->host);
/*
* Add ending slash to the location string
*/
location = mk_mem_malloc(sr->uri_processed.len + 2);
memcpy(location, sr->uri_processed.data, sr->uri_processed.len);
location[sr->uri_processed.len] = '/';
location[sr->uri_processed.len + 1] = '\0';
/* FIXME: should we done something similar for SSL = 443 */
if (sr->host.data && sr->port > 0) {
if (sr->port != config->standard_port) {
port_redirect = sr->port;
}
}
if (port_redirect > 0) {
mk_string_build(&real_location, &len, "%s://%s:%i%s",
config->transport, host, port_redirect, location);
}
else {
mk_string_build(&real_location, &len, "%s://%s%s",
config->transport, host, location);
}
MK_TRACE("Redirecting to '%s'", real_location);
mk_mem_free(host);
mk_header_set_http_status(sr, MK_REDIR_MOVED);
sr->headers.content_length = 0;
mk_ptr_t_reset(&sr->headers.content_type);
sr->headers.location = real_location;
sr->headers.cgi = SH_NOCGI;
sr->headers.pconnections_left =
(config->max_keep_alive_request - cs->counter_connections);
mk_header_send(cs->socket, cs, sr);
mk_server_cork_flag(cs->socket, TCP_CORK_OFF);
/*
* we do not free() real_location
* as it's freed by iov
*/
mk_mem_free(location);
sr->headers.location = NULL;
return -1;
}
int mk_http_init(struct client_session *cs, struct session_request *sr)
{
int ret;
int bytes = 0;
struct mimetype *mime;
MK_TRACE("HTTP Protocol Init");
/* Request to root path of the virtualhost in question */
if (sr->uri_processed.len == 1 && sr->uri_processed.data[0] == '/') {
sr->real_path.data = sr->host_conf->documentroot.data;
sr->real_path.len = sr->host_conf->documentroot.len;
}
/* Compose real path */
if (sr->user_home == MK_FALSE) {
int len;
len = sr->host_conf->documentroot.len + sr->uri_processed.len;
if (len < MK_PATH_BASE) {
memcpy(sr->real_path_static,
sr->host_conf->documentroot.data,
sr->host_conf->documentroot.len);
memcpy(sr->real_path_static + sr->host_conf->documentroot.len,
sr->uri_processed.data,
sr->uri_processed.len);
sr->real_path_static[len] = '\0';
sr->real_path.data = sr->real_path_static;
sr->real_path.len = len;
}
else {
ret = mk_buffer_cat(&sr->real_path,
sr->host_conf->documentroot.data,
sr->host_conf->documentroot.len,
sr->uri_processed.data,
sr->uri_processed.len);
if (ret < 0) {
MK_TRACE("Error composing real path");
return EXIT_ERROR;
}
}
}
/* Check backward directory request */
if (memmem(sr->uri_processed.data, sr->uri_processed.len,
MK_HTTP_DIRECTORY_BACKWARD,
sizeof(MK_HTTP_DIRECTORY_BACKWARD) - 1)) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
if (mk_file_get_info(sr->real_path.data, &sr->file_info) != 0) {
/* if the requested resource doesn't exist,
* check if some plugin would like to handle it
*/
MK_TRACE("No file, look for handler plugin");
ret = mk_plugin_stage_run(MK_PLUGIN_STAGE_30, cs->socket, NULL, cs, sr);
if (ret == MK_PLUGIN_RET_CLOSE_CONX) {
if (sr->headers.status > 0) {
return mk_request_error(sr->headers.status, cs, sr);
}
else {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
}
else if (ret == MK_PLUGIN_RET_CONTINUE) {
return MK_PLUGIN_RET_CONTINUE;
}
else if (ret == MK_PLUGIN_RET_END) {
return EXIT_NORMAL;
}
if (sr->file_info.exists == MK_FALSE) {
return mk_request_error(MK_CLIENT_NOT_FOUND, cs, sr);
}
else if (sr->stage30_blocked == MK_FALSE) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
}
/* is it a valid directory ? */
if (sr->file_info.is_directory == MK_TRUE) {
/* Send redirect header if end slash is not found */
if (mk_http_directory_redirect_check(cs, sr) == -1) {
MK_TRACE("Directory Redirect");
/* Redirect has been sent */
return -1;
}
/* looking for an index file */
mk_ptr_t index_file;
char tmppath[MK_MAX_PATH];
index_file = mk_request_index(sr->real_path.data, tmppath, MK_MAX_PATH);
if (index_file.data) {
if (sr->real_path.data != sr->real_path_static) {
mk_ptr_t_free(&sr->real_path);
sr->real_path = index_file;
sr->real_path.data = mk_string_dup(index_file.data);
}
/* If it's static and it still fits */
else if (index_file.len < MK_PATH_BASE) {
memcpy(sr->real_path_static, index_file.data, index_file.len);
sr->real_path_static[index_file.len] = '\0';
sr->real_path.len = index_file.len;
}
/* It was static, but didn't fit */
else {
sr->real_path = index_file;
sr->real_path.data = mk_string_dup(index_file.data);
}
mk_file_get_info(sr->real_path.data, &sr->file_info);
}
}
/* Check symbolic link file */
if (sr->file_info.is_link == MK_TRUE) {
if (config->symlink == MK_FALSE) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
else {
int n;
char linked_file[MK_MAX_PATH];
n = readlink(sr->real_path.data, linked_file, MK_MAX_PATH);
if (n < 0) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
}
}
/* Plugin Stage 30: look for handlers for this request */
if (sr->stage30_blocked == MK_FALSE) {
ret = mk_plugin_stage_run(MK_PLUGIN_STAGE_30, cs->socket, NULL, cs, sr);
MK_TRACE("[FD %i] STAGE_30 returned %i", cs->socket, ret);
switch (ret) {
case MK_PLUGIN_RET_CONTINUE:
return MK_PLUGIN_RET_CONTINUE;
case MK_PLUGIN_RET_CLOSE_CONX:
if (sr->headers.status > 0) {
return mk_request_error(sr->headers.status, cs, sr);
}
else {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
case MK_PLUGIN_RET_END:
return EXIT_NORMAL;
}
}
/*
* Monkey listens for PUT and DELETE methods in addition to GET, POST and
* HEAD, but it does not care about them, so if any plugin did not worked
* on it, Monkey will return error 501 (501 Not Implemented).
*/
if (sr->method == MK_HTTP_METHOD_PUT || sr->method == MK_HTTP_METHOD_DELETE ||
sr->method == MK_HTTP_METHOD_UNKNOWN) {
return mk_request_error(MK_SERVER_NOT_IMPLEMENTED, cs, sr);
}
/* counter connections */
sr->headers.pconnections_left = (int)
(config->max_keep_alive_request - cs->counter_connections);
/* Set default value */
mk_header_set_http_status(sr, MK_HTTP_OK);
sr->headers.location = NULL;
sr->headers.content_length = 0;
/*
* For OPTIONS method, we let the plugin handle it and
* return without any content.
*/
if (sr->method == MK_HTTP_METHOD_OPTIONS) {
sr->headers.allow_methods.data = MK_HTTP_METHOD_AVAILABLE;
sr->headers.allow_methods.len = strlen(MK_HTTP_METHOD_AVAILABLE);
mk_ptr_t_reset(&sr->headers.content_type);
mk_header_send(cs->socket, cs, sr);
return EXIT_NORMAL;
}
else {
mk_ptr_t_reset(&sr->headers.allow_methods);
}
/* read permissions and check file */
if (sr->file_info.read_access == MK_FALSE) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
/* Matching MimeType */
mime = mk_mimetype_find(&sr->real_path);
if (!mime) {
mime = mimetype_default;
}
if (sr->file_info.is_directory == MK_TRUE) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
/* get file size */
if (sr->file_info.size < 0) {
return mk_request_error(MK_CLIENT_NOT_FOUND, cs, sr);
}
sr->headers.last_modified = sr->file_info.last_modification;
if (sr->if_modified_since.data && sr->method == MK_HTTP_METHOD_GET) {
time_t date_client; /* Date sent by client */
time_t date_file_server; /* Date server file */
date_client = mk_utils_gmt2utime(sr->if_modified_since.data);
date_file_server = sr->file_info.last_modification;
if (date_file_server <= date_client && date_client > 0 &&
date_client <= log_current_utime) {
mk_header_set_http_status(sr, MK_NOT_MODIFIED);
mk_header_send(cs->socket, cs, sr);
return EXIT_NORMAL;
}
}
/* Object size for log and response headers */
sr->headers.content_length = sr->file_info.size;
sr->headers.real_length = sr->file_info.size;
/* Open file */
if (mk_likely(sr->file_info.size > 0)) {
sr->fd_file = mk_vhost_open(sr);
if (sr->fd_file == -1) {
MK_TRACE("open() failed");
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
sr->bytes_to_send = sr->file_info.size;
}
/* Process methods */
if (sr->method == MK_HTTP_METHOD_GET || sr->method == MK_HTTP_METHOD_HEAD) {
sr->headers.content_type = mime->type;
/* HTTP Ranges */
if (sr->range.data != NULL && config->resume == MK_TRUE) {
if (mk_http_range_parse(sr) < 0) {
sr->headers.ranges[0] = -1;
sr->headers.ranges[1] = -1;
return mk_request_error(MK_CLIENT_BAD_REQUEST, cs, sr);
}
if (sr->headers.ranges[0] >= 0 || sr->headers.ranges[1] >= 0) {
mk_header_set_http_status(sr, MK_HTTP_PARTIAL);
}
/* Calc bytes to send & offset */
if (mk_http_range_set(sr, sr->file_info.size) != 0) {
sr->headers.content_length = -1;
sr->headers.ranges[0] = -1;
sr->headers.ranges[1] = -1;
return mk_request_error(MK_CLIENT_REQUESTED_RANGE_NOT_SATISF, cs, sr);
}
}
}
else {
/* without content-type */
mk_ptr_t_reset(&sr->headers.content_type);
}
/* Send headers */
mk_header_send(cs->socket, cs, sr);
if (mk_unlikely(sr->headers.content_length == 0)) {
return 0;
}
/* Send file content */
if (sr->method == MK_HTTP_METHOD_GET || sr->method == MK_HTTP_METHOD_POST) {
bytes = mk_http_send_file(cs, sr);
}
return bytes;
}
static int mk_http_request_prepare(struct mk_http_session *cs,
struct mk_http_request *sr)
{
int status = 0;
char *temp;
struct mk_list *hosts = &mk_config->hosts;
struct mk_list *alias;
struct mk_http_header *header;
/*
* Process URI, if it contains ASCII encoded strings like '%20',
* it will return a new memory buffer with the decoded string, otherwise
* it returns NULL
*/
temp = mk_utils_url_decode(sr->uri);
if (temp) {
sr->uri_processed.data = temp;
sr->uri_processed.len = strlen(temp);
}
else {
sr->uri_processed.data = sr->uri.data;
sr->uri_processed.len = sr->uri.len;
}
/* Always assign the default vhost' */
sr->host_conf = mk_list_entry_first(hosts, struct host, _head);
sr->user_home = MK_FALSE;
/* Valid request URI? */
if (sr->uri_processed.data[0] != '/') {
mk_http_error(MK_CLIENT_BAD_REQUEST, cs, sr);
return MK_EXIT_OK;
}
/* Check if we have a Host header: Hostname ; port */
mk_http_point_header(&sr->host, &cs->parser, MK_HEADER_HOST);
/* Header: Connection */
mk_http_point_header(&sr->connection, &cs->parser, MK_HEADER_CONNECTION);
/* Header: Range */
mk_http_point_header(&sr->range, &cs->parser, MK_HEADER_RANGE);
/* Header: If-Modified-Since */
mk_http_point_header(&sr->if_modified_since,
&cs->parser,
MK_HEADER_IF_MODIFIED_SINCE);
/* HTTP/1.1 needs Host header */
if (!sr->host.data && sr->protocol == MK_HTTP_PROTOCOL_11) {
mk_http_error(MK_CLIENT_BAD_REQUEST, cs, sr);
return MK_EXIT_OK;
}
/* Should we close the session after this request ? */
mk_http_keepalive_check(cs, sr);
/* Content Length */
header = &cs->parser.headers[MK_HEADER_CONTENT_LENGTH];
if (header->type == MK_HEADER_CONTENT_LENGTH) {
sr->_content_length.data = header->val.data;
sr->_content_length.len = header->val.len;
}
else {
sr->_content_length.data = NULL;
}
/* Assign the first node alias */
alias = &sr->host_conf->server_names;
sr->host_alias = mk_list_entry_first(alias,
struct host_alias, _head);
if (sr->host.data) {
/* Set the given port */
if (cs->parser.header_host_port > 0) {
sr->port = cs->parser.header_host_port;
}
/* Match the virtual host */
mk_vhost_get(sr->host, &sr->host_conf, &sr->host_alias);
/* Check if this virtual host have some redirection */
if (sr->host_conf->header_redirect.data) {
mk_header_set_http_status(sr, MK_REDIR_MOVED);
sr->headers.location = mk_string_dup(sr->host_conf->header_redirect.data);
sr->headers.content_length = 0;
sr->headers.location = NULL;
mk_header_prepare(cs, sr);
return 0;
}
}
/* Is requesting an user home directory ? */
if (mk_config->user_dir &&
sr->uri_processed.len > 2 &&
sr->uri_processed.data[1] == MK_USER_HOME) {
if (mk_user_init(cs, sr) != 0) {
mk_http_error(MK_CLIENT_NOT_FOUND, cs, sr);
return MK_EXIT_ABORT;
}
}
/* Plugins Stage 20 */
int ret;
ret = mk_plugin_stage_run_20(cs, sr);
if (ret == MK_PLUGIN_RET_CLOSE_CONX) {
MK_TRACE("STAGE 20 requested close conexion");
return MK_EXIT_ABORT;
}
/* Normal HTTP process */
status = mk_http_init(cs, sr);
MK_TRACE("[FD %i] HTTP Init returning %i", cs->socket, status);
return status;
}
