src/method.c

   1 /*  Monkey HTTP Daemon
   2  *  ------------------
   3  *  Copyright (C) 2001-2008, Eduardo Silva P.
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <stdio.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <sys/socket.h>
  24 #include <sys/wait.h>
  25 #include <netinet/in.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include "monkey.h"
  32
  33 #include "str.h"
  34 #include "memory.h"
  35 #include "http.h"
  36 #include "http_status.h"
  37 #include "header.h"
  38 #include "socket.h"
  39 #include "logfile.h"
  40 #include "config.h"
  41 #include "utils.h"
  42 #include "file.h"
  43 /* POST METHOD */
  44 int M_METHOD_Post(struct client_request *cr, struct request *s_request)
  45 {
  46         /*
  47         char *tmp;
  48         char buffer[MAX_REQUEST_BODY];
  49         int content_length_post=0;
  50
  51         if(!(tmp=Request_Find_Variable(s_request->body, RH_CONTENT_LENGTH))){
  52                 Request_Error(M_CLIENT_LENGHT_REQUIRED, cr, s_request,0,s_request->log);
  53                 return -1;
  54         }
  55
  56         content_length_post = (int) atoi(tmp);
  57         mk_mem_free(tmp);
  58
  59         if(content_length_post<=0 || content_length_post >=MAX_REQUEST_BODY){
  60                 Request_Error(M_CLIENT_BAD_REQUEST, cr, s_request, 0, s_request->log);
  61                 return -1;
  62         }
  63
  64         if(!(tmp = Request_Find_Variable(s_request->body, RH_CONTENT_TYPE))){
  65                 Request_Error(M_CLIENT_BAD_REQUEST, cr, s_request, 0, s_request->log);
  66                 return -1;
  67         }
  68
  69         s_request->content_type = tmp;
  70
  71         if(s_request->post_variables==NULL || strlen(s_request->post_variables)<=4) {
  72                 s_request->post_variables=NULL;
  73                 return -1;
  74         }
  75
  76         if(strlen(s_request->post_variables) < content_length_post){
  77                 content_length_post=strlen(buffer);
  78         }
  79
  80         s_request->content_length=content_length_post;
  81         */
  82         return 0;
  83
  84 }
  85
  86 /* Reuturn the POST variables sent in the request */
  87 char *M_Get_POST_Vars(char *request, int index, char *strend)
  88 {
  89     int i=index;
  90     int length, length_string_end;
  91     int last_byte = 1;
  92
  93     length = strlen(request);
  94     length_string_end = strlen(strend);
  95     if(length_string_end == 2)
  96     {
  97         last_byte = 0;
  98     }
  99
 100     for(i=index; i<=length; i++)
 101     {
 102         if(strncmp(request+i, strend, length_string_end)==0)
 103         {
 104             break;
 105         }
 106     }
 107     return mk_string_copy_substr(request, index, i-last_byte);
 108 }
 109
 110
 111 /* Send_Header , envia las cabeceras principales */
 112 int M_METHOD_send_headers(int fd, struct client_request *cr,
 113                 struct request *sr, struct log_info *s_log)
 114 {
 115         int fd_status=0;
 116         unsigned long len=0;
 117         char *buffer=0;
 118         struct header_values *sh;
 119         struct mk_iov *iov;
 120         char *date=0;
 121
 122         sh = sr->headers;
 123
 124         iov = mk_iov_create(50);
 125
 126         /* Status Code */
 127         switch(sh->status){
 128                 case M_HTTP_OK:
 129                         mk_iov_add_entry(iov, RESP_HTTP_OK, LEN_RESP_HTTP_OK,
 130                                         MK_IOV_BREAK_LINE, MK_IOV_NOT_FREE_BUF);
 131                         break;
 132
 133                 case M_HTTP_PARTIAL:
 134                         mk_iov_add_entry(iov, RESP_HTTP_PARTIAL,
 135                                         LEN_RESP_HTTP_PARTIAL,
 136                                         MK_IOV_BREAK_LINE,
 137                                         MK_IOV_NOT_FREE_BUF);
 138                         break;
 139
 140                 case M_REDIR_MOVED:
 141                         s_log->status=S_LOG_OFF;
 142                         mk_iov_add_entry(iov, RESP_REDIR_MOVED,
 143                                         LEN_RESP_REDIR_MOVED,
 144                                         MK_IOV_BREAK_LINE,
 145                                         MK_IOV_NOT_FREE_BUF);
 146                         break;
 147
 148                 case M_REDIR_MOVED_T:
 149                         s_log->status=S_LOG_ON;
 150                         mk_iov_add_entry(iov, RESP_REDIR_MOVED_T,
 151                                         LEN_RESP_REDIR_MOVED_T,
 152                                         MK_IOV_BREAK_LINE,
 153                                         MK_IOV_NOT_FREE_BUF);
 154                         break;
 155
 156                 case M_NOT_MODIFIED:
 157                         s_log->status=S_LOG_OFF;
 158                         mk_iov_add_entry(iov, RESP_NOT_MODIFIED,
 159                                         LEN_RESP_NOT_MODIFIED,
 160                                         MK_IOV_BREAK_LINE,
 161                                         MK_IOV_NOT_FREE_BUF);
 162                         break;
 163
 164                 case M_CLIENT_BAD_REQUEST:
 165                         mk_iov_add_entry(iov, RESP_CLIENT_BAD_REQUEST,
 166                                         LEN_RESP_CLIENT_BAD_REQUEST,
 167                                         MK_IOV_BREAK_LINE,
 168                                         MK_IOV_NOT_FREE_BUF);
 169                         break;
 170
 171                 case M_CLIENT_FORBIDDEN:
 172                         mk_iov_add_entry(iov, RESP_CLIENT_FORBIDDEN,
 173                                         LEN_RESP_CLIENT_FORBIDDEN,
 174                                         MK_IOV_BREAK_LINE,
 175                                         MK_IOV_NOT_FREE_BUF);
 176                         break;
 177
 178                 case M_CLIENT_NOT_FOUND:
 179                         mk_iov_add_entry(iov, RESP_CLIENT_NOT_FOUND,
 180                                         LEN_RESP_CLIENT_NOT_FOUND,
 181                                         MK_IOV_BREAK_LINE,
 182                                         MK_IOV_NOT_FREE_BUF);
 183                         break;
 184
 185                 case M_CLIENT_METHOD_NOT_ALLOWED:
 186                         mk_iov_add_entry(iov, RESP_CLIENT_METHOD_NOT_ALLOWED,
 187                                         LEN_RESP_CLIENT_METHOD_NOT_ALLOWED,
 188                                         MK_IOV_BREAK_LINE,
 189                                         MK_IOV_NOT_FREE_BUF);
 190                         break;
 191
 192                 case M_CLIENT_REQUEST_TIMEOUT:
 193                         mk_iov_add_entry(iov, RESP_CLIENT_REQUEST_TIMEOUT,
 194                                         LEN_RESP_CLIENT_REQUEST_TIMEOUT,
 195                                         MK_IOV_BREAK_LINE,
 196                                         MK_IOV_NOT_FREE_BUF);
 197                         s_log->status=S_LOG_OFF;
 198                         break;
 199
 200                 case M_CLIENT_LENGHT_REQUIRED:
 201                         mk_iov_add_entry(iov, RESP_CLIENT_LENGTH_REQUIRED,
 202                                         LEN_RESP_CLIENT_LENGTH_REQUIRED,
 203                                         MK_IOV_BREAK_LINE,
 204                                         MK_IOV_NOT_FREE_BUF);
 205                         break;
 206
 207                 case M_SERVER_INTERNAL_ERROR:
 208                         mk_iov_add_entry(iov, RESP_SERVER_INTERNAL_ERROR,
 209                                         LEN_RESP_SERVER_INTERNAL_ERROR,
 210                                         MK_IOV_BREAK_LINE,
 211                                         MK_IOV_NOT_FREE_BUF);
 212                         break;
 213
 214                 case M_SERVER_HTTP_VERSION_UNSUP:
 215                         mk_iov_add_entry(iov, RESP_SERVER_HTTP_VERSION_UNSUP,
 216                                         LEN_RESP_SERVER_HTTP_VERSION_UNSUP,
 217                                         MK_IOV_BREAK_LINE,
 218                                         MK_IOV_NOT_FREE_BUF);
 219                         break;
 220         };
 221
 222         if(sh->status!=0){
 223                 s_log->final_response = sh->status;
 224         }
 225
 226         if(fd_status<0){
 227                 mk_iov_free(iov);
 228                 return -1;
 229         }
 230
 231         /* Informacion del server */
 232         mk_iov_add_entry(iov, sr->host_conf->header_host_signature,
 233                         strlen(sr->host_conf->header_host_signature),
 234                         MK_IOV_BREAK_LINE, MK_IOV_NOT_FREE_BUF);
 235
 236         /* Fecha */
 237         date = PutDate_string(0);
 238         m_build_buffer(&buffer, &len, "Date: %s", date);
 239         mk_iov_add_entry(iov, buffer, len,
 240                         MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 241         mk_mem_free(date);
 242
 243         /* Location */
 244         if(sh->location!=NULL)
 245         {
 246                 m_build_buffer(
 247                         &buffer,
 248                         &len,
 249                         "Location: %s",
 250                         sh->location);
 251
 252                 mk_iov_add_entry(iov, buffer, len,
 253                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 254         }
 255
 256         /* Last-Modified */
 257         if(sh->last_modified!=NULL){
 258                 m_build_buffer(
 259                         &buffer,
 260                         &len,
 261                         "%s %s",
 262                         RH_LAST_MODIFIED,
 263                         sh->last_modified);
 264                 mk_iov_add_entry(iov, buffer, len,
 265                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 266         }
 267
 268         /* Connection */
 269         if(cr->counter_connections<config->max_keep_alive_request && config->keep_alive==VAR_ON){
 270                 m_build_buffer(
 271                         &buffer,
 272                         &len,
 273                         "Keep-Alive: timeout=%i, max=%i",
 274                         config->keep_alive_timeout,
 275                         config->max_keep_alive_request-cr->counter_connections);
 276                 mk_iov_add_entry(iov, buffer, len,
 277                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 278
 279                 m_build_buffer(
 280                         &buffer,
 281                         &len,
 282                         "Connection: Keep-Alive");
 283                 mk_iov_add_entry(iov, buffer, len,
 284                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 285         }
 286         else{
 287                 m_build_buffer(
 288                         &buffer,
 289                         &len,
 290                         "Connection: close");
 291                 mk_iov_add_entry(iov, buffer, len,
 292                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 293         }
 294
 295         /* Tipo de contenido de la informacion */
 296         if(sh->content_type!=NULL){
 297                 m_build_buffer(
 298                         &buffer,
 299                         &len,
 300                         "Content-Type: %s",
 301                         sh->content_type);
 302                 mk_iov_add_entry(iov, buffer, len,
 303                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 304         }
 305
 306         /* Ranges */
 307         m_build_buffer(
 308                         &buffer,
 309                         &len,
 310                         "Accept-Ranges: bytes",
 311                         sh->content_type);
 312         mk_iov_add_entry(iov, buffer, len,
 313                         MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 314
 315         //printf("\n->sh->cl: %i", sh->content_length);
 316         //fflush(stdout);
 317
 318         /* Tamaño total de la informacion a enviar */
 319         if((sh->content_length!=0 &&
 320                         (sh->ranges[0]>=0 || sh->ranges[1]>=0)) &&
 321                         config->resume==VAR_ON){
 322                 long int length;
 323
 324         /* yyy- */
 325         if(sh->ranges[0]>=0 && sh->ranges[1]==-1){
 326                 length = (unsigned int) ( sh->content_length - sh->ranges[0] );
 327                 m_build_buffer(
 328                                 &buffer,
 329                                 &len,
 330                                 "%s %i",
 331                                 RH_CONTENT_LENGTH,
 332                                 length);
 333                 mk_iov_add_entry(iov, buffer, len,
 334                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 335
 336                 m_build_buffer(
 337                                 &buffer,
 338                                 &len,
 339                                 "%s bytes %d-%d/%d",
 340                                 RH_CONTENT_RANGE,
 341                                 sh->ranges[0],
 342                                 (sh->content_length - 1),
 343                                 sh->content_length);
 344                 mk_iov_add_entry(iov, buffer, len,
 345                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 346         }
 347
 348         /* yyy-xxx */
 349         if(sh->ranges[0]>=0 && sh->ranges[1]>=0){
 350                 length = (unsigned int) abs(sh->ranges[1] - sh->ranges[0]) + 1;
 351                 m_build_buffer(
 352                                 &buffer,
 353                                 &len,
 354                                 "%s %d",
 355                                 RH_CONTENT_LENGTH,
 356                                 length);
 357                 mk_iov_add_entry(iov, buffer, len,
 358                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 359
 360                 m_build_buffer(
 361                                 &buffer,
 362                                 &len,
 363                                 "%s bytes %d-%d/%d",
 364                                 RH_CONTENT_RANGE,
 365                                 sh->ranges[0],
 366                                 sh->ranges[1],
 367                                 sh->content_length);
 368                 }
 369                 mk_iov_add_entry(iov, buffer, len,
 370                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 371
 372                 /* -xxx */
 373                 if(sh->ranges[0]==-1 && sh->ranges[1]>=0){
 374                         m_build_buffer(
 375                                         &buffer,
 376                                         &len,
 377                                         "%s %d",
 378                                         RH_CONTENT_LENGTH,
 379                                         sh->ranges[1]);
 380                         mk_iov_add_entry(iov, buffer, len,
 381                                         MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 382
 383                         m_build_buffer(
 384                                         &buffer,
 385                                         &len,
 386                                         "%s bytes %d-%d/%d",
 387                                         RH_CONTENT_RANGE,
 388                                         (sh->content_length - sh->ranges[1]),
 389                                         (sh->content_length - 1),
 390                                         sh->content_length);
 391                         mk_iov_add_entry(iov, buffer, len,
 392                                         MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 393                 }
 394         }
 395         else if(sh->content_length>=0)
 396         {
 397                 m_build_buffer(
 398                                 &buffer,
 399                                 &len,
 400                                 "%s %d",
 401                                 RH_CONTENT_LENGTH,
 402                                 sh->content_length);
 403                 mk_iov_add_entry(iov, buffer, len,
 404                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 405         }
 406         else if(sh->status==M_REDIR_MOVED)
 407         {
 408                 m_build_buffer(
 409                                 &buffer,
 410                                 &len,
 411                                 "%s %d",
 412                                 RH_CONTENT_LENGTH,
 413                                 sh->content_length);
 414                 mk_iov_add_entry(iov, buffer, len,
 415                                 MK_IOV_BREAK_LINE, MK_IOV_FREE_BUF);
 416         }
 417
 418         if(sh->cgi==SH_NOCGI)
 419         {
 420                 mk_iov_add_separator(iov, MK_IOV_BREAK_LINE);
 421         }
 422         mk_socket_set_cork_flag(fd, TCP_CORK_ON);
 423         mk_iov_send(fd, iov);
 424         mk_iov_free(iov);
 425         return 0;
 426 }
 427