static void mk_request_free(struct session_request *sr)
{
if (sr->fd_file > 0) {
close(sr->fd_file);
}
if (sr->headers.location) {
mk_mem_free(sr->headers.location);
}
if (sr->uri_processed.data != sr->uri.data) {
mk_pointer_free(&sr->uri_processed);
}
if (sr->real_path.data != sr->real_path_static) {
mk_pointer_free(&sr->real_path);
}
}
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,
HTTP_DIRECTORY_BACKWARD, sizeof(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 resource requested doesn't exists, let's
* 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) {
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 {
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 a index file */
mk_pointer index_file;
char tmppath[MAX_PATH];
index_file = mk_request_index(sr->real_path.data, tmppath, MAX_PATH);
if (index_file.data) {
if (sr->real_path.data != sr->real_path_static) {
mk_pointer_free(&sr->real_path);
sr->real_path = index_file;
sr->real_path.data = strdup(index_file.data);
}
/* If it's static, and 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 = strdup(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[MAX_PATH];
n = readlink(sr->real_path.data, linked_file, MAX_PATH);
if (n < 0) {
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
}
}
/* Plugin Stage 30: look for handlers for this request */
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 listen 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 == HTTP_METHOD_PUT || sr->method == HTTP_METHOD_DELETE ||
sr->method == HTTP_METHOD_UNKNOWN) {
return mk_request_error(MK_SERVER_NOT_IMPLEMENTED, cs, sr);
}
/* 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);
}
/* counter connections */
sr->headers.pconnections_left = (int)
(config->max_keep_alive_request - cs->counter_connections);
sr->headers.last_modified = sr->file_info.last_modification;
if (sr->if_modified_since.data && sr->method == 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;
}
}
mk_header_set_http_status(sr, MK_HTTP_OK);
sr->headers.location = NULL;
/* Object size for log and response headers */
sr->headers.content_length = sr->file_info.size;
sr->headers.real_length = sr->file_info.size;
/* Process methods */
if (sr->method == HTTP_METHOD_GET || sr->method == HTTP_METHOD_HEAD) {
sr->headers.content_type = mime->type;
/* Range */
if (sr->range.data != NULL && config->resume == MK_TRUE) {
if (mk_http_range_parse(sr) < 0) {
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);
}
}
}
else {
/* without content-type */
mk_pointer_reset(&sr->headers.content_type);
}
/* Open file */
if (sr->file_info.size > 0) {
sr->fd_file = open(sr->real_path.data, sr->file_info.flags_read_only);
if (sr->fd_file == -1) {
MK_TRACE("open() failed");
return mk_request_error(MK_CLIENT_FORBIDDEN, cs, sr);
}
}
/* Send headers */
mk_header_send(cs->socket, cs, sr);
if (sr->headers.content_length == 0) {
return 0;
}
/* Send file content*/
if (sr->method == HTTP_METHOD_GET || sr->method == HTTP_METHOD_POST) {
/* Calc bytes to send & offset */
if (mk_http_range_set(sr, sr->file_info.size) != 0) {
return mk_request_error(MK_CLIENT_BAD_REQUEST, cs, sr);
}
bytes = mk_http_send_file(cs, sr);
}
return bytes;
}
