src/http.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2
   3 /*  Monkey HTTP Daemon
   4  *  ------------------
   5  *  Copyright (C) 2001-2010, Eduardo Silva P.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29
  30 #include "monkey.h"
  31 #include "memory.h"
  32 #include "http.h"
  33 #include "http_status.h"
  34 #include "file.h"
  35 #include "utils.h"
  36 #include "config.h"
  37 #include "str.h"
  38 #include "method.h"
  39 #include "socket.h"
  40 #include "mimetype.h"
  41 #include "logfile.h"
  42 #include "header.h"
  43 #include "plugin.h"
  44
  45 int mk_http_method_check(mk_pointer method)
  46 {
  47     if (strncasecmp(method.data, HTTP_METHOD_GET_STR, method.len) == 0) {
  48         return HTTP_METHOD_GET;
  49     }
  50
  51     if (strncasecmp(method.data, HTTP_METHOD_POST_STR, method.len) == 0) {
  52         return HTTP_METHOD_POST;
  53     }
  54
  55     if (strncasecmp(method.data, HTTP_METHOD_HEAD_STR, method.len) == 0) {
  56         return HTTP_METHOD_HEAD;
  57     }
  58
  59     return METHOD_NOT_FOUND;
  60 }
  61
  62 mk_pointer mk_http_method_check_str(int method)
  63 {
  64     switch (method) {
  65     case HTTP_METHOD_GET:
  66         return mk_http_method_get_p;
  67
  68     case HTTP_METHOD_POST:
  69         return mk_http_method_post_p;
  70
  71     case HTTP_METHOD_HEAD:
  72         return mk_http_method_head_p;
  73     }
  74     return mk_http_method_null_p;
  75 }
  76
  77 int mk_http_method_get(char *body)
  78 {
  79     int int_method, pos = 0;
  80     int max_len_method = 5;
  81     mk_pointer method;
  82
  83     /* Max method length is 4 (POST/HEAD) */
  84     pos = mk_string_char_search(body, ' ', 5);
  85     if (pos <= 2 || pos >= max_len_method) {
  86         return METHOD_NOT_FOUND;
  87     }
  88
  89     method.data = body;
  90     method.len = (unsigned long) pos;
  91
  92     int_method = mk_http_method_check(method);
  93
  94     return int_method;
  95 }
  96
  97 int mk_http_protocol_check(char *protocol, int len)
  98 {
  99     if (strncasecmp(protocol, HTTP_PROTOCOL_11_STR, len) == 0) {
 100         return HTTP_PROTOCOL_11;
 101     }
 102     if (strncasecmp(protocol, HTTP_PROTOCOL_10_STR, len) == 0) {
 103         return HTTP_PROTOCOL_10;
 104     }
 105     if (strncasecmp(protocol, HTTP_PROTOCOL_09_STR, len) == 0) {
 106         return HTTP_PROTOCOL_09;
 107     }
 108
 109     return HTTP_PROTOCOL_UNKNOWN;
 110 }
 111
 112 mk_pointer mk_http_protocol_check_str(int protocol)
 113 {
 114     if (protocol == HTTP_PROTOCOL_11) {
 115         return mk_http_protocol_11_p;
 116     }
 117     if (protocol == HTTP_PROTOCOL_10) {
 118         return mk_http_protocol_10_p;
 119     }
 120     if (protocol == HTTP_PROTOCOL_09) {
 121         return mk_http_protocol_09_p;
 122     }
 123
 124     return mk_http_protocol_null_p;
 125 }
 126
 127 int mk_http_init(struct client_request *cr, struct request *sr)
 128 {
 129     int ret;
 130     int debug_error = 0, bytes = 0;
 131     struct mimetype *mime;
 132     mk_pointer gmt_file_unix_time;      // gmt time of server file (unix time)
 133
 134 #ifdef TRACE
 135     MK_TRACE("HTTP Protocol Init");
 136 #endif
 137
 138     /* Normal request default site */
 139     if ((strcmp(sr->uri_processed, "/")) == 0) {
 140         sr->real_path.data = mk_string_dup(sr->host_conf->documentroot.data);
 141         sr->real_path.len = sr->host_conf->documentroot.len;
 142     }
 143
 144     if (sr->user_home == VAR_OFF) {
 145         mk_buffer_cat(&sr->real_path, sr->host_conf->documentroot.data,
 146                       sr->uri_processed);
 147     }
 148
 149     if (sr->method != HTTP_METHOD_HEAD) {
 150         debug_error = 1;
 151     }
 152
 153     if (mk_string_search_n(sr->uri.data, HTTP_DIRECTORY_BACKWARD,
 154                            sr->uri.len) >= 0) {
 155         sr->log->final_response = M_CLIENT_FORBIDDEN;
 156         mk_request_error(M_CLIENT_FORBIDDEN, cr, sr, debug_error, sr->log);
 157         return -1;
 158     }
 159
 160     /* Plugin Stage 30: look for handlers for this request */
 161     if (mk_plugin_stage_run(MK_PLUGIN_STAGE_30, 0, NULL, cr, sr) ==
 162         MK_PLUGIN_RET_CLOSE_CONX) {
 163         sr->log->final_response = M_CLIENT_FORBIDDEN;
 164         mk_request_error(M_CLIENT_FORBIDDEN, cr, sr, debug_error, sr->log);
 165         return -1;
 166     }
 167
 168     sr->file_info = mk_file_get_info(sr->real_path.data);
 169
 170     if (!sr->file_info) {
 171         /* if the resource requested doesn't exists, let's
 172          * check if some plugin would like to handle it
 173          */
 174         if (mk_plugin_stage_run(MK_PLUGIN_STAGE_40, cr->socket, NULL, cr, sr)
 175             == 0) {
 176             return -1;
 177         }
 178
 179         mk_request_error(M_CLIENT_NOT_FOUND, cr, sr, debug_error, sr->log);
 180         return -1;
 181     }
 182
 183     /* Check symbolic link file */
 184     if (sr->file_info->is_link == MK_FILE_TRUE) {
 185         if (config->symlink == VAR_OFF) {
 186             sr->log->final_response = M_CLIENT_FORBIDDEN;
 187             mk_request_error(M_CLIENT_FORBIDDEN, cr, sr,
 188                              debug_error, sr->log);
 189             return -1;
 190         }
 191         else {
 192             int n;
 193             char linked_file[MAX_PATH];
 194             n = readlink(sr->real_path.data, linked_file, MAX_PATH);
 195             /*
 196                if(Deny_Check(linked_file)==-1) {
 197                sr->log->final_response=M_CLIENT_FORBIDDEN;
 198                mk_request_error(M_CLIENT_FORBIDDEN, cr, sr, debug_error, sr->log);
 199                return -1;
 200                }
 201              */
 202
 203         }
 204     }
 205
 206     /* is it a valid directory ? */
 207     if (sr->file_info->is_directory == MK_FILE_TRUE) {
 208         /* Send redirect header if end slash is not found */
 209         if (mk_http_directory_redirect_check(cr, sr) == -1) {
 210             /* Redirect has been sent */
 211             return -1;
 212         }
 213
 214         /* looking for a index file */
 215         mk_pointer index_file;
 216         index_file = mk_request_index(sr->real_path.data);
 217
 218         if (index_file.data) {
 219             mk_mem_free(sr->file_info);
 220             mk_pointer_free(&sr->real_path);
 221
 222             sr->real_path = index_file;
 223             sr->file_info = mk_file_get_info(sr->real_path.data);
 224         }
 225     }
 226
 227     /* read permissions and check file */
 228     if (sr->file_info->read_access == MK_FILE_FALSE) {
 229         mk_request_error(M_CLIENT_FORBIDDEN, cr, sr, 1, sr->log);
 230         return -1;
 231     }
 232
 233     /* Matching MimeType  */
 234     mime = mk_mimetype_find(&sr->real_path);
 235     if (!mime) {
 236         mime = mimetype_default;
 237     }
 238
 239     if (sr->file_info->is_directory == MK_FILE_TRUE) {
 240         mk_request_error(M_CLIENT_FORBIDDEN, cr, sr, 1, sr->log);
 241         return -1;
 242     }
 243
 244     /* Plugin Stage 40: look for handlers for this request */
 245     ret = mk_plugin_stage_run(MK_PLUGIN_STAGE_40, cr->socket, NULL, cr, sr);
 246     if (ret == MK_PLUGIN_RET_CONTINUE) {
 247         return ret;
 248     }
 249
 250     /* get file size */
 251     if (sr->file_info->size < 0) {
 252         mk_request_error(M_CLIENT_NOT_FOUND, cr, sr, 1, sr->log);
 253         return -1;
 254     }
 255
 256     /* counter connections */
 257     sr->headers->pconnections_left = (int)
 258         (config->max_keep_alive_request - cr->counter_connections);
 259
 260
 261     gmt_file_unix_time =
 262         PutDate_string((time_t) sr->file_info->last_modification);
 263
 264     if (sr->if_modified_since.data && sr->method == HTTP_METHOD_GET) {
 265         time_t date_client;     // Date send by client
 266         time_t date_file_server;        // Date server file
 267
 268         date_client = PutDate_unix(sr->if_modified_since.data);
 269         date_file_server = sr->file_info->last_modification;
 270
 271         if ((date_file_server <= date_client) && (date_client > 0)) {
 272             sr->headers->status = M_NOT_MODIFIED;
 273             mk_header_send(cr->socket, cr, sr, sr->log);
 274             mk_pointer_free(&gmt_file_unix_time);
 275             return 0;
 276         }
 277     }
 278     sr->headers->status = M_HTTP_OK;
 279     sr->headers->cgi = SH_NOCGI;
 280     sr->headers->last_modified = gmt_file_unix_time;
 281     sr->headers->location = NULL;
 282
 283     /* Object size for log and response headers */
 284     sr->log->size = sr->headers->content_length = sr->file_info->size;
 285     sr->log->size_p = sr->headers->content_length_p =
 286         mk_utils_int2mkp(sr->file_info->size);
 287
 288     if (sr->method == HTTP_METHOD_GET || sr->method == HTTP_METHOD_POST) {
 289         sr->headers->content_type = mime->type;
 290         /* Range */
 291         if (sr->range.data != NULL && config->resume == VAR_ON) {
 292             if (mk_http_range_parse(sr) < 0) {
 293                 mk_request_error(M_CLIENT_BAD_REQUEST, cr, sr, 1, sr->log);
 294                 mk_pointer_free(&gmt_file_unix_time);
 295                 return -1;
 296             }
 297             if (sr->headers->ranges[0] >= 0 || sr->headers->ranges[1] >= 0)
 298                 sr->headers->status = M_HTTP_PARTIAL;
 299         }
 300     }
 301     else {                      /* without content-type */
 302         mk_pointer_reset(&sr->headers->content_type);
 303     }
 304
 305     mk_header_send(cr->socket, cr, sr, sr->log);
 306
 307     if (sr->headers->content_length == 0) {
 308         return 0;
 309     }
 310
 311     /* Sending file */
 312     if ((sr->method == HTTP_METHOD_GET || sr->method == HTTP_METHOD_POST)
 313         && sr->file_info->size > 0) {
 314         sr->fd_file = open(sr->real_path.data, config->open_flags);
 315
 316         if (sr->fd_file == -1) {
 317             perror("open");
 318             return -1;
 319         }
 320
 321         /* Calc bytes to send & offset */
 322         if (mk_http_range_set(sr, sr->file_info->size) != 0) {
 323             mk_request_error(M_CLIENT_BAD_REQUEST, cr, sr, 1, sr->log);
 324             return -1;
 325         }
 326         bytes = SendFile(cr->socket, cr, sr);
 327     }
 328
 329     return bytes;
 330 }
 331
 332 int mk_http_directory_redirect_check(struct client_request *cr,
 333                                      struct request *sr)
 334 {
 335     char *host;
 336     char *location = 0;
 337     char *real_location = 0;
 338     unsigned long len;
 339
 340     /*
 341      * We have to check if exist an slash to the end of
 342      * this string, if doesn't exist we send a redirection header
 343      */
 344     if (sr->uri_processed[strlen(sr->uri_processed) - 1] == '/') {
 345         return 0;
 346     }
 347
 348     host = mk_pointer_to_buf(sr->host);
 349
 350     m_build_buffer(&location, &len, "%s/", sr->uri_processed);
 351     if (config->serverport == config->standard_port) {
 352         m_build_buffer(&real_location, &len, "http://%s%s", host, location);
 353     }
 354     else {
 355         m_build_buffer(&real_location, &len, "http://%s:%i%s",
 356                        host, config->serverport, location);
 357     }
 358
 359     mk_mem_free(host);
 360
 361     sr->headers->status = M_REDIR_MOVED;
 362     sr->headers->content_length = -1;
 363     mk_pointer_reset(&sr->headers->content_type);
 364     sr->headers->location = real_location;
 365     sr->headers->cgi = SH_NOCGI;
 366     sr->headers->pconnections_left =
 367         (config->max_keep_alive_request - cr->counter_connections);
 368
 369     mk_header_send(cr->socket, cr, sr, sr->log);
 370     mk_socket_set_cork_flag(cr->socket, TCP_CORK_OFF);
 371
 372     /*
 373      *  we do not free() real_location
 374      *  as it's freed by iov
 375      */
 376     mk_mem_free(location);
 377     sr->headers->location = NULL;
 378     return -1;
 379 }
 380
 381 /*
 382  * Check if a connection can continue open using as criteria
 383  * the keepalive headers vars and Monkey configuration
 384  */
 385 int mk_http_keepalive_check(int socket, struct client_request *cr)
 386 {
 387     if (!cr->request) {
 388         return -1;
 389     }
 390
 391     if (config->keep_alive == VAR_OFF || cr->request->keep_alive == VAR_OFF) {
 392         return -1;
 393     }
 394
 395     if (cr->counter_connections >= config->max_keep_alive_request) {
 396         return -1;
 397     }
 398
 399     return 0;
 400 }
 401
 402 int mk_http_range_set(struct request *sr, long file_size)
 403 {
 404     struct header_values *sh = sr->headers;
 405
 406     sr->bytes_to_send = file_size;
 407     sr->bytes_offset = 0;
 408
 409     if (config->resume == VAR_ON && sr->range.data) {
 410         /* yyy- */
 411         if (sh->ranges[0] >= 0 && sh->ranges[1] == -1) {
 412             sr->bytes_offset = sh->ranges[0];
 413             sr->bytes_to_send = file_size - sr->bytes_offset;
 414         }
 415
 416         /* yyy-xxx */
 417         if (sh->ranges[0] >= 0 && sh->ranges[1] >= 0) {
 418             sr->bytes_offset = sh->ranges[0];
 419             sr->bytes_to_send = labs(sh->ranges[1] - sh->ranges[0]) + 1;
 420         }
 421
 422         /* -xxx */
 423         if (sh->ranges[0] == -1 && sh->ranges[1] > 0) {
 424             sr->bytes_to_send = sh->ranges[1];
 425             sr->bytes_offset = file_size - sh->ranges[1];
 426         }
 427
 428         if (sr->bytes_offset > file_size || sr->bytes_to_send > file_size) {
 429             return -1;
 430         }
 431
 432         lseek(sr->fd_file, sr->bytes_offset, SEEK_SET);
 433     }
 434     return 0;
 435
 436
 437 }
 438
 439 int mk_http_range_parse(struct request *sr)
 440 {
 441     int eq_pos, sep_pos, len;
 442     char *buffer = 0;
 443
 444     if (!sr->range.data)
 445         return -1;
 446
 447     if ((eq_pos = mk_string_search_n(sr->range.data, "=", sr->range.len)) < 0)
 448         return -1;
 449
 450     if (strncasecmp(sr->range.data, "Bytes", eq_pos) != 0)
 451         return -1;
 452
 453     if ((sep_pos = mk_string_search_n(sr->range.data, "-",
 454                                       sr->range.len)) < 0)
 455         return -1;
 456
 457     len = sr->range.len;
 458
 459     /* =-xxx */
 460     if (eq_pos + 1 == sep_pos) {
 461         sr->headers->ranges[0] = -1;
 462         sr->headers->ranges[1] =
 463             (unsigned long) atol(sr->range.data + sep_pos + 1);
 464
 465         if (sr->headers->ranges[1] <= 0) {
 466             return -1;
 467         }
 468         return 0;
 469     }
 470
 471     /* =yyy-xxx */
 472     if ((eq_pos + 1 != sep_pos) && (len > sep_pos + 1)) {
 473         buffer = mk_string_copy_substr(sr->range.data, eq_pos + 1, sep_pos);
 474         sr->headers->ranges[0] = (unsigned long) atol(buffer);
 475         mk_mem_free(buffer);
 476
 477         buffer = mk_string_copy_substr(sr->range.data, sep_pos + 1, len);
 478         sr->headers->ranges[1] = (unsigned long) atol(buffer);
 479         mk_mem_free(buffer);
 480
 481         if (sr->headers->ranges[1] <= 0 ||
 482             sr->headers->ranges[0] > sr->headers->ranges[1]) {
 483             return -1;
 484         }
 485
 486         return 0;
 487     }
 488     /* =yyy- */
 489     if ((eq_pos + 1 != sep_pos) && (len == sep_pos + 1)) {
 490         buffer = mk_string_copy_substr(sr->range.data, eq_pos + 1, len);
 491         sr->headers->ranges[0] = (unsigned long) atol(buffer);
 492         mk_mem_free(buffer);
 493         return 0;
 494     }
 495
 496     return -1;
 497 }
 498
 499 /*
 500  * Check if client request still has pending data
 501  *
 502  * Return 0 when all expected data has arrived or -1 when
 503  * the connection is on a pending status due to HTTP spec
 504  *
 505  * This function is called from request.c :: mk_handler_read(..)
 506  */
 507 int mk_http_pending_request(struct client_request *cr)
 508 {
 509     int n, len;
 510     char *str;
 511
 512     len = cr->body_length;
 513
 514     /* try to match CRLF end */
 515     if (strcmp(cr->body + len - mk_endblock.len, mk_endblock.data) == 0) {
 516         n = len - mk_endblock.len;
 517     }
 518     else {
 519         n = mk_string_search(cr->body, mk_endblock.data);
 520     }
 521
 522     if (n <= 0) {
 523         return -1;
 524     }
 525
 526     if (cr->first_block_end < 0) {
 527         cr->first_block_end = n;
 528     }
 529
 530     str = cr->body + n + mk_endblock.len;
 531
 532     if (cr->first_method == HTTP_METHOD_UNKNOWN) {
 533         cr->first_method = mk_http_method_get(cr->body);
 534     }
 535
 536     if (cr->first_method == HTTP_METHOD_POST) {
 537         if (cr->first_block_end > 0) {
 538             /* if first block has ended, we need to verify if exists
 539              * a previous block end, that will means that the POST
 540              * method has sent the whole information.
 541              * just for ref: pipelining is not allowed with POST
 542              */
 543             if (cr->first_block_end == cr->body_length - mk_endblock.len) {
 544                 /* Content-length is required, if is it not found,
 545                  * we pass as successfull in order to raise the error
 546                  * later
 547                  */
 548                 if (mk_method_post_content_length(cr->body) < 0) {
 549                     cr->status = MK_REQUEST_STATUS_COMPLETED;
 550                     return 0;
 551                 }
 552             }
 553             else {
 554                 cr->status = MK_REQUEST_STATUS_COMPLETED;
 555                 return 0;
 556             }
 557         }
 558         else {
 559             return -1;
 560         }
 561     }
 562
 563     cr->status = MK_REQUEST_STATUS_COMPLETED;
 564     return 0;
 565 }
 566
 567 mk_pointer *mk_http_status_get(short int code)
 568 {
 569     mk_list_sint_t *l;
 570
 571     l = mk_http_status_list;
 572     while (l) {
 573         if (l->index == code) {
 574             return &l->value;
 575         }
 576         else {
 577             l = l->next;
 578         }
 579     }
 580
 581     return NULL;
 582 }
 583
 584 void mk_http_status_add(short int val[2])
 585 {
 586     short i, len = 6;
 587     char *str_val;
 588     mk_list_sint_t *list, *new;
 589
 590     for (i = val[0]; i <= val[1]; i++) {
 591
 592         new = mk_mem_malloc(sizeof(mk_list_sint_t));
 593         new->index = i;
 594         new->next = NULL;
 595
 596         str_val = mk_mem_malloc(6);
 597         snprintf(str_val, len - 1, "%i", i);
 598
 599         new->value.data = str_val;
 600         new->value.len = 3;
 601
 602         if (!mk_http_status_list) {
 603             mk_http_status_list = new;
 604         }
 605         else {
 606             list = mk_http_status_list;
 607             while (list->next)
 608                 list = list->next;
 609
 610             list->next = new;
 611             list = new;
 612         }
 613     }
 614 }
 615
 616 void mk_http_status_list_init()
 617 {
 618     /* Status type */
 619     short int success[2] = { 200, 206 };
 620     short int redirections[2] = { 300, 305 };
 621     short int client_errors[2] = { 400, 415 };
 622     short int server_errors[2] = { 500, 505 };
 623
 624     mk_http_status_add(success);
 625     mk_http_status_add(redirections);
 626     mk_http_status_add(client_errors);
 627     mk_http_status_add(server_errors);
 628 }