src/header.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. <edsiper@gmail.com>
   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 <stdlib.h>
  24 #include <string.h>
  25
  26 #include "monkey.h"
  27 #include "header.h"
  28 #include "memory.h"
  29 #include "request.h"
  30 #include "logfile.h"
  31 #include "iov.h"
  32 #include "http_status.h"
  33 #include "config.h"
  34 #include "socket.h"
  35 #include "utils.h"
  36 #include "clock.h"
  37 #include "cache.h"
  38 #include "http.h"
  39
  40 int mk_header_iov_add_entry(struct mk_iov *mk_io, mk_pointer data,
  41                             mk_pointer sep, int free)
  42 {
  43     return mk_iov_add_entry(mk_io, data.data, data.len, sep, free);
  44 }
  45
  46 struct mk_iov *mk_header_iov_get()
  47 {
  48     return pthread_getspecific(mk_cache_iov_header);
  49 }
  50
  51 void mk_header_iov_free(struct mk_iov *iov)
  52 {
  53     mk_iov_free_marked(iov);
  54 }
  55
  56 /* Send_Header , envia las cabeceras principales */
  57 int mk_header_send(int fd, struct client_request *cr,
  58                    struct request *sr, struct log_info *s_log)
  59 {
  60     int fd_status = 0;
  61     unsigned long len = 0;
  62     char *buffer = 0;
  63     struct header_values *sh;
  64     struct mk_iov *iov;
  65
  66     sh = sr->headers;
  67
  68     iov = mk_header_iov_get();
  69
  70     /* Status Code */
  71     switch (sh->status) {
  72     case M_HTTP_OK:
  73         mk_header_iov_add_entry(iov, mk_hr_http_ok,
  74                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
  75         break;
  76
  77     case M_HTTP_PARTIAL:
  78         mk_header_iov_add_entry(iov, mk_hr_http_partial,
  79                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
  80         break;
  81
  82     case M_REDIR_MOVED:
  83         s_log->status = S_LOG_ON;
  84         mk_header_iov_add_entry(iov, mk_hr_redir_moved,
  85                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
  86         break;
  87
  88     case M_REDIR_MOVED_T:
  89         s_log->status = S_LOG_ON;
  90         mk_header_iov_add_entry(iov, mk_hr_redir_moved_t,
  91                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
  92         break;
  93
  94     case M_NOT_MODIFIED:
  95         s_log->status = S_LOG_ON;
  96         mk_header_iov_add_entry(iov, mk_hr_not_modified,
  97                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
  98         break;
  99
 100     case M_CLIENT_BAD_REQUEST:
 101         mk_header_iov_add_entry(iov, mk_hr_client_bad_request,
 102                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 103         break;
 104
 105     case M_CLIENT_FORBIDDEN:
 106         mk_header_iov_add_entry(iov, mk_hr_client_forbidden,
 107                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 108         break;
 109
 110     case M_CLIENT_NOT_FOUND:
 111         mk_header_iov_add_entry(iov, mk_hr_client_not_found,
 112                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 113         break;
 114
 115     case M_CLIENT_METHOD_NOT_ALLOWED:
 116         mk_header_iov_add_entry(iov, mk_hr_client_method_not_allowed,
 117                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 118         break;
 119
 120     case M_CLIENT_REQUEST_TIMEOUT:
 121         mk_header_iov_add_entry(iov, mk_hr_client_request_timeout,
 122                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 123         s_log->status = S_LOG_OFF;
 124         break;
 125
 126     case M_CLIENT_LENGTH_REQUIRED:
 127         mk_header_iov_add_entry(iov, mk_hr_client_length_required,
 128                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 129         break;
 130
 131     case M_SERVER_NOT_IMPLEMENTED:
 132         mk_header_iov_add_entry(iov, mk_hr_server_not_implemented,
 133                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 134         break;
 135
 136     case M_SERVER_INTERNAL_ERROR:
 137         mk_header_iov_add_entry(iov, mk_hr_server_internal_error,
 138                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 139         break;
 140
 141     case M_SERVER_HTTP_VERSION_UNSUP:
 142         mk_header_iov_add_entry(iov,
 143                                 mk_hr_server_http_version_unsup,
 144                                 mk_iov_none, MK_IOV_NOT_FREE_BUF);
 145         break;
 146     };
 147
 148     if (sh->status != 0) {
 149         s_log->final_response = sh->status;
 150     }
 151
 152     if (fd_status < 0) {
 153         mk_header_iov_free(iov);
 154         return -1;
 155     }
 156
 157     /* Server details */
 158     mk_iov_add_entry(iov, sr->host_conf->header_host_signature.data,
 159                      sr->host_conf->header_host_signature.len,
 160                      mk_iov_crlf, MK_IOV_NOT_FREE_BUF);
 161
 162     /* Date */
 163     mk_iov_add_entry(iov,
 164                      mk_header_short_date.data,
 165                      mk_header_short_date.len,
 166                      mk_iov_none, MK_IOV_NOT_FREE_BUF);
 167     mk_iov_add_entry(iov,
 168                      header_current_time.data,
 169                      header_current_time.len,
 170                      mk_iov_none, MK_IOV_NOT_FREE_BUF);
 171
 172     /* Connection */
 173     if (config->keep_alive == VAR_ON &&
 174         sr->keep_alive == VAR_ON &&
 175         cr->counter_connections < config->max_keep_alive_request) {
 176
 177         /* A valid connection header */
 178         if (sr->connection.len > 0) {
 179             m_build_buffer(&buffer,
 180                            &len,
 181                            "Keep-Alive: timeout=%i, max=%i"
 182                            MK_CRLF,
 183                            config->keep_alive_timeout,
 184                            (config->max_keep_alive_request -
 185                             cr->counter_connections)
 186                            );
 187             mk_iov_add_entry(iov, buffer, len, mk_iov_none, MK_IOV_FREE_BUF);
 188             mk_iov_add_entry(iov,
 189                              mk_header_conn_ka.data,
 190                              mk_header_conn_ka.len,
 191                              mk_iov_none, MK_IOV_NOT_FREE_BUF);
 192         }
 193     }
 194     else if(sr->close_now == VAR_ON) {
 195         mk_iov_add_entry(iov,
 196                          mk_header_conn_close.data,
 197                          mk_header_conn_close.len,
 198                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 199     }
 200
 201     /* Location */
 202     if (sh->location != NULL) {
 203         mk_iov_add_entry(iov,
 204                          mk_header_short_location.data,
 205                          mk_header_short_location.len,
 206                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 207
 208         mk_iov_add_entry(iov,
 209                          sh->location,
 210                          strlen(sh->location), mk_iov_crlf, MK_IOV_FREE_BUF);
 211     }
 212
 213     /* Last-Modified */
 214     if (sh->last_modified.len > 0) {
 215         mk_iov_add_entry(iov, mk_header_last_modified.data,
 216                          mk_header_last_modified.len,
 217                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 218         mk_iov_add_entry(iov, sh->last_modified.data,
 219                          sh->last_modified.len,
 220                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 221     }
 222
 223     /* Content type */
 224     if (sh->content_type.len > 0) {
 225         mk_iov_add_entry(iov,
 226                          mk_header_short_ct.data,
 227                          mk_header_short_ct.len,
 228                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 229
 230         mk_iov_add_entry(iov,
 231                          sh->content_type.data,
 232                          sh->content_type.len,
 233                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 234     }
 235
 236     /* Transfer Encoding */
 237     switch (sh->transfer_encoding) {
 238     case MK_HEADER_TE_TYPE_CHUNKED:
 239         mk_iov_add_entry(iov,
 240                          mk_header_te_chunked.data,
 241                          mk_header_te_chunked.len,
 242                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 243         break;
 244     }
 245
 246     /* Content-Length */
 247     if ((sh->content_length != 0 &&
 248          (sh->ranges[0] >= 0 || sh->ranges[1] >= 0)) &&
 249         config->resume == VAR_ON) {
 250         long int length = -1;
 251
 252         /* yyy- */
 253         if (sh->ranges[0] >= 0 && sh->ranges[1] == -1) {
 254             length = (unsigned int)
 255                 (sh->content_length - sh->ranges[0]);
 256             m_build_buffer(&buffer, &len, "%s %i", RH_CONTENT_LENGTH, length);
 257             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 258
 259             m_build_buffer(&buffer,
 260                            &len,
 261                            "%s bytes %d-%d/%d",
 262                            RH_CONTENT_RANGE,
 263                            sh->ranges[0],
 264                            (sh->content_length - 1), sh->content_length);
 265             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 266         }
 267
 268         /* yyy-xxx */
 269         if (sh->ranges[0] >= 0 && sh->ranges[1] >= 0) {
 270             length = (unsigned int)
 271                 abs(sh->ranges[1] - sh->ranges[0]) + 1;
 272             m_build_buffer(&buffer, &len, "%s %d", RH_CONTENT_LENGTH, length);
 273             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 274
 275             m_build_buffer(&buffer,
 276                            &len,
 277                            "%s bytes %d-%d/%d",
 278                            RH_CONTENT_RANGE,
 279                            sh->ranges[0], sh->ranges[1], sh->content_length);
 280
 281             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 282         }
 283
 284         /* -xxx */
 285         if (sh->ranges[0] == -1 && sh->ranges[1] > 0) {
 286             length = (unsigned int) sh->ranges[1];
 287
 288             if (length > sh->content_length) {
 289                 length = sh->content_length;
 290                 sh->ranges[1] = sh->content_length;
 291             }
 292
 293             m_build_buffer(&buffer, &len, "%s %d", RH_CONTENT_LENGTH, length);
 294             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 295
 296             m_build_buffer(&buffer,
 297                            &len,
 298                            "%s bytes %d-%d/%d",
 299                            RH_CONTENT_RANGE,
 300                            (sh->content_length - sh->ranges[1]),
 301                            (sh->content_length - 1), sh->content_length);
 302             mk_iov_add_entry(iov, buffer, len, mk_iov_crlf, MK_IOV_FREE_BUF);
 303         }
 304
 305         /* FIXME: logger routines and data should be handled by a plugin
 306          * in Monkey 0.11.0
 307          */
 308         if (length >= 0) {
 309             mk_pointer_free(&sr->log->size_p);
 310             sr->log->size = length;
 311             sr->log->size_p = mk_utils_int2mkp(length);
 312         }
 313     }
 314     else if (sh->content_length >= 0) {
 315         mk_iov_add_entry(iov, mk_header_content_length.data,
 316                          mk_header_content_length.len,
 317                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 318
 319         mk_iov_add_entry(iov, sh->content_length_p.data,
 320                          sh->content_length_p.len,
 321                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 322     }
 323
 324     if (sh->cgi == SH_NOCGI || sh->breakline == MK_HEADER_BREAKLINE) {
 325         mk_iov_add_entry(iov, mk_iov_crlf.data, mk_iov_crlf.len,
 326                          mk_iov_none, MK_IOV_NOT_FREE_BUF);
 327     }
 328
 329     mk_socket_set_cork_flag(fd, TCP_CORK_ON);
 330     mk_iov_send(fd, iov, MK_IOV_SEND_TO_SOCKET);
 331
 332 #ifdef DEBUG_HEADERS_OUT
 333     mk_iov_send(0, iov, MK_IOV_SEND_TO_SOCKET);
 334 #endif
 335
 336     mk_header_iov_free(iov);
 337
 338     return 0;
 339 }
 340
 341 char *mk_header_chunked_line(int len)
 342 {
 343     char *buf;
 344
 345     buf = mk_mem_malloc_z(10);
 346     snprintf(buf, 9, "%x%s", len, MK_CRLF);
 347
 348     return buf;
 349 }
 350
 351 struct header_values *mk_header_create()
 352 {
 353     struct header_values *headers;
 354
 355     headers =
 356         (struct header_values *) mk_mem_malloc(sizeof(struct header_values));
 357     headers->ranges[0] = -1;
 358     headers->ranges[1] = -1;
 359     headers->content_length = -1;
 360     headers->transfer_encoding = -1;
 361     mk_pointer_reset(&headers->content_length_p);
 362     mk_pointer_reset(&headers->content_type);
 363     mk_pointer_reset(&headers->last_modified);
 364     headers->location = NULL;
 365
 366     return headers;
 367 }