src/connection.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 "monkey.h"
  23 #include "http.h"
  24 #include "connection.h"
  25 #include "scheduler.h"
  26 #include "epoll.h"
  27 #include "request.h"
  28 #include "socket.h"
  29 #include "plugin.h"
  30 #include "utils.h"
  31
  32 #include <string.h>
  33 #include <stdio.h>
  34
  35 int mk_conn_read(int socket)
  36 {
  37     int ret;
  38     struct client_request *cr;
  39     struct sched_list_node *sched;
  40
  41 #ifdef TRACE
  42     MK_TRACE("Connection Handler, read on FD %i", socket);
  43 #endif
  44
  45     /* Plugin hook */
  46     ret = mk_plugin_event_read(socket);
  47     if (ret != MK_PLUGIN_RET_EVENT_NOT_ME) {
  48         return ret;
  49     }
  50
  51     sched = mk_sched_get_thread_conf();
  52
  53     cr = mk_request_client_get(socket);
  54     if (!cr) {
  55         /* Note: Linux don't set TCP_NODELAY socket flag by default,
  56          */
  57         mk_socket_set_tcp_nodelay(socket);
  58
  59         /* Create client */
  60         cr = mk_request_client_create(socket);
  61     }
  62     else {
  63         /* If cr struct already exists, that could means that we
  64          * are facing a keepalive connection, need to verify, if it
  65          * applies we increase the thread status for active connections
  66          */
  67         if (cr->counter_connections > 1 && cr->body_length == 0) {
  68             /* FIXME: KA Connection */
  69         }
  70     }
  71
  72     /* Read incomming data */
  73     ret = mk_handler_read(socket, cr);
  74
  75     if (ret > 0) {
  76         if (mk_http_pending_request(cr) == 0) {
  77             mk_epoll_socket_change_mode(sched->epoll_fd,
  78                                         socket, MK_EPOLL_WRITE);
  79         }
  80         else if (cr->body_length + 1 >= MAX_REQUEST_BODY) {
  81             /* Request is incomplete and our buffer is full,
  82              * close connection
  83              */
  84             mk_request_client_remove(socket);
  85             return -1;
  86         }
  87     }
  88     return ret;
  89 }
  90
  91 int mk_conn_write(int socket)
  92 {
  93     int ret = -1, ka;
  94     struct client_request *cr;
  95     struct sched_list_node *sched;
  96
  97 #ifdef TRACE
  98     MK_TRACE("Connection Handler, write on FD %i", socket);
  99 #endif
 100
 101     /* Plugin hook */
 102     ret = mk_plugin_event_write(socket);
 103 #ifdef TRACE
 104     MK_TRACE("Check plugin hook | ret = %i", ret);
 105 #endif
 106     if (ret != MK_PLUGIN_RET_EVENT_NOT_ME) {
 107         return ret;
 108     }
 109
 110 #ifdef TRACE
 111     MK_TRACE("Normal connection write handling...");
 112 #endif
 113
 114     sched = mk_sched_get_thread_conf();
 115     mk_sched_update_conn_status(sched, socket, MK_SCHEDULER_CONN_PROCESS);
 116
 117     /* Get node from schedule list node which contains
 118      * the information regarding to the current client/socket
 119      */
 120     cr = mk_request_client_get(socket);
 121
 122     if (!cr) {
 123         return -1;
 124     }
 125
 126     ret = mk_handler_write(socket, cr);
 127     ka = mk_http_keepalive_check(socket, cr);
 128
 129     /* if ret < 0, means that some error
 130      * happened in the writer call, in the
 131      * other hand, 0 means a successful request
 132      * processed, if ret > 0 means that some data
 133      * still need to be send.
 134      */
 135     if (ret <= 0) {
 136         mk_request_free_list(cr);
 137
 138         /* We need to ask to http_keepalive if this
 139          * connection can continue working or we must
 140          * close it.
 141          */
 142         if (ka < 0 || ret < 0) {
 143             mk_request_client_remove(socket);
 144             return -1;
 145         }
 146         else {
 147             mk_request_ka_next(cr);
 148             mk_epoll_socket_change_mode(sched->epoll_fd,
 149                                         socket, MK_EPOLL_READ);
 150             return 0;
 151         }
 152     }
 153     else if (ret > 0) {
 154         return 0;
 155     }
 156
 157     /* avoid to make gcc cry :_( */
 158     return -1;
 159 }
 160
 161 int mk_conn_error(int socket)
 162 {
 163     int ret = -1;
 164     struct client_request *cr;
 165     struct sched_list_node *sched;
 166
 167 #ifdef TRACE
 168     MK_TRACE("Connection Handler, error on FD %i", socket);
 169 #endif
 170
 171     /* Plugin hook */
 172     ret = mk_plugin_event_error(socket);
 173     if (ret != MK_PLUGIN_RET_EVENT_NOT_ME) {
 174         return ret;
 175     }
 176
 177     sched = mk_sched_get_thread_conf();
 178     mk_sched_remove_client(NULL, socket);
 179     cr = mk_request_client_get(socket);
 180     if (cr) {
 181         mk_request_client_remove(socket);
 182     }
 183
 184     return 0;
 185 }
 186
 187 int mk_conn_close(int socket)
 188 {
 189     int ret = -1;
 190     struct sched_list_node *sched;
 191
 192 #ifdef TRACE
 193     MK_TRACE("Connection Handler, closed on FD %i", socket);
 194 #endif
 195
 196     /* Plugin hook */
 197     ret = mk_plugin_event_close(socket);
 198     if (ret != MK_PLUGIN_RET_EVENT_NOT_ME) {
 199         return ret;
 200     }
 201
 202     sched = mk_sched_get_thread_conf();
 203     mk_sched_remove_client(sched, socket);
 204
 205     return 0;
 206 }
 207
 208 int mk_conn_timeout(int socket)
 209 {
 210     int ret = -1;
 211     struct sched_list_node *sched;
 212
 213 #ifdef TRACE
 214     MK_TRACE("Connection Handler, timeout on FD %i", socket);
 215 #endif
 216
 217     /* Plugin hook */
 218     ret = mk_plugin_event_timeout(socket);
 219     if (ret != MK_PLUGIN_RET_EVENT_NOT_ME) {
 220         return ret;
 221     }
 222
 223     sched = mk_sched_get_thread_conf();
 224     mk_sched_check_timeouts(sched);
 225
 226     return 0;
 227 }