src/connections-glue.c

   1 #include "first.h"
   2
   3 #include "base.h"
   4 #include "connections.h"
   5 #include "joblist.h"
   6 #include "log.h"
   7
   8 #include <errno.h>
   9
  10 #ifdef USE_OPENSSL
  11 # include <openssl/ssl.h>
  12 # include <openssl/err.h>
  13 #endif
  14
  15 const char *connection_get_state(connection_state_t state) {
  16         switch (state) {
  17         case CON_STATE_CONNECT: return "connect";
  18         case CON_STATE_READ: return "read";
  19         case CON_STATE_READ_POST: return "readpost";
  20         case CON_STATE_WRITE: return "write";
  21         case CON_STATE_CLOSE: return "close";
  22         case CON_STATE_ERROR: return "error";
  23         case CON_STATE_HANDLE_REQUEST: return "handle-req";
  24         case CON_STATE_REQUEST_START: return "req-start";
  25         case CON_STATE_REQUEST_END: return "req-end";
  26         case CON_STATE_RESPONSE_START: return "resp-start";
  27         case CON_STATE_RESPONSE_END: return "resp-end";
  28         default: return "(unknown)";
  29         }
  30 }
  31
  32 const char *connection_get_short_state(connection_state_t state) {
  33         switch (state) {
  34         case CON_STATE_CONNECT: return ".";
  35         case CON_STATE_READ: return "r";
  36         case CON_STATE_READ_POST: return "R";
  37         case CON_STATE_WRITE: return "W";
  38         case CON_STATE_CLOSE: return "C";
  39         case CON_STATE_ERROR: return "E";
  40         case CON_STATE_HANDLE_REQUEST: return "h";
  41         case CON_STATE_REQUEST_START: return "q";
  42         case CON_STATE_REQUEST_END: return "Q";
  43         case CON_STATE_RESPONSE_START: return "s";
  44         case CON_STATE_RESPONSE_END: return "S";
  45         default: return "x";
  46         }
  47 }
  48
  49 int connection_set_state(server *srv, connection *con, connection_state_t state) {
  50         UNUSED(srv);
  51
  52         con->state = state;
  53
  54         return 0;
  55 }
  56
  57 #if 0
  58 static void dump_packet(const unsigned char *data, size_t len) {
  59         size_t i, j;
  60
  61         if (len == 0) return;
  62
  63         for (i = 0; i < len; i++) {
  64                 if (i % 16 == 0) fprintf(stderr, "  ");
  65
  66                 fprintf(stderr, "%02x ", data[i]);
  67
  68                 if ((i + 1) % 16 == 0) {
  69                         fprintf(stderr, "  ");
  70                         for (j = 0; j <= i % 16; j++) {
  71                                 unsigned char c;
  72
  73                                 if (i-15+j >= len) break;
  74
  75                                 c = data[i-15+j];
  76
  77                                 fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
  78                         }
  79
  80                         fprintf(stderr, "\n");
  81                 }
  82         }
  83
  84         if (len % 16 != 0) {
  85                 for (j = i % 16; j < 16; j++) {
  86                         fprintf(stderr, "   ");
  87                 }
  88
  89                 fprintf(stderr, "  ");
  90                 for (j = i & ~0xf; j < len; j++) {
  91                         unsigned char c;
  92
  93                         c = data[j];
  94                         fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
  95                 }
  96                 fprintf(stderr, "\n");
  97         }
  98 }
  99 #endif
 100
 101 static int connection_handle_read_ssl(server *srv, connection *con) {
 102 #ifdef USE_OPENSSL
 103         int r, ssl_err, len;
 104         char *mem = NULL;
 105         size_t mem_len = 0;
 106
 107         if (!con->srv_socket->is_ssl) return -1;
 108
 109         ERR_clear_error();
 110         do {
 111                 chunkqueue_get_memory(con->read_queue, &mem, &mem_len, 0, SSL_pending(con->ssl));
 112 #if 0
 113                 /* overwrite everything with 0 */
 114                 memset(mem, 0, mem_len);
 115 #endif
 116
 117                 len = SSL_read(con->ssl, mem, mem_len);
 118                 if (len > 0) {
 119                         chunkqueue_use_memory(con->read_queue, len);
 120                         con->bytes_read += len;
 121                 } else {
 122                         chunkqueue_use_memory(con->read_queue, 0);
 123                 }
 124
 125                 if (con->renegotiations > 1 && con->conf.ssl_disable_client_renegotiation) {
 126                         log_error_write(srv, __FILE__, __LINE__, "s", "SSL: renegotiation initiated by client, killing connection");
 127                         connection_set_state(srv, con, CON_STATE_ERROR);
 128                         return -1;
 129                 }
 130         } while (len > 0);
 131
 132         if (len < 0) {
 133                 int oerrno = errno;
 134                 switch ((r = SSL_get_error(con->ssl, len))) {
 135                 case SSL_ERROR_WANT_WRITE:
 136                         con->is_writable = -1;
 137                 case SSL_ERROR_WANT_READ:
 138                         con->is_readable = 0;
 139
 140                         /* the manual says we have to call SSL_read with the same arguments next time.
 141                          * we ignore this restriction; no one has complained about it in 1.5 yet, so it probably works anyway.
 142                          */
 143
 144                         return 0;
 145                 case SSL_ERROR_SYSCALL:
 146                         /**
 147                          * man SSL_get_error()
 148                          *
 149                          * SSL_ERROR_SYSCALL
 150                          *   Some I/O error occurred.  The OpenSSL error queue may contain more
 151                          *   information on the error.  If the error queue is empty (i.e.
 152                          *   ERR_get_error() returns 0), ret can be used to find out more about
 153                          *   the error: If ret == 0, an EOF was observed that violates the
 154                          *   protocol.  If ret == -1, the underlying BIO reported an I/O error
 155                          *   (for socket I/O on Unix systems, consult errno for details).
 156                          *
 157                          */
 158                         while((ssl_err = ERR_get_error())) {
 159                                 /* get all errors from the error-queue */
 160                                 log_error_write(srv, __FILE__, __LINE__, "sds", "SSL:",
 161                                                 r, ERR_error_string(ssl_err, NULL));
 162                         }
 163
 164                         switch(oerrno) {
 165                         default:
 166                                 log_error_write(srv, __FILE__, __LINE__, "sddds", "SSL:",
 167                                                 len, r, oerrno,
 168                                                 strerror(oerrno));
 169                                 break;
 170                         }
 171
 172                         break;
 173                 case SSL_ERROR_ZERO_RETURN:
 174                         /* clean shutdown on the remote side */
 175
 176                         if (r == 0) {
 177                                 /* FIXME: later */
 178                         }
 179
 180                         /* fall thourgh */
 181                 default:
 182                         while((ssl_err = ERR_get_error())) {
 183                                 switch (ERR_GET_REASON(ssl_err)) {
 184                                 case SSL_R_SSL_HANDSHAKE_FAILURE:
 185                               #ifdef SSL_R_TLSV1_ALERT_UNKNOWN_CA
 186                                 case SSL_R_TLSV1_ALERT_UNKNOWN_CA:
 187                               #endif
 188                               #ifdef SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN
 189                                 case SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN:
 190                               #endif
 191                               #ifdef SSL_R_SSLV3_ALERT_BAD_CERTIFICATE
 192                                 case SSL_R_SSLV3_ALERT_BAD_CERTIFICATE:
 193                               #endif
 194                                         if (!con->conf.log_ssl_noise) continue;
 195                                         break;
 196                                 default:
 197                                         break;
 198                                 }
 199                                 /* get all errors from the error-queue */
 200                                 log_error_write(srv, __FILE__, __LINE__, "sds", "SSL:",
 201                                                 r, ERR_error_string(ssl_err, NULL));
 202                         }
 203                         break;
 204                 }
 205
 206                 connection_set_state(srv, con, CON_STATE_ERROR);
 207
 208                 return -1;
 209         } else { /*(len == 0)*/
 210                 con->is_readable = 0;
 211                 /* the other end close the connection -> KEEP-ALIVE */
 212
 213                 return -2;
 214         }
 215 #else
 216         UNUSED(srv);
 217         UNUSED(con);
 218         return -1;
 219 #endif
 220 }
 221
 222 /* 0: everything ok, -1: error, -2: con closed */
 223 int connection_handle_read(server *srv, connection *con) {
 224         int len;
 225         char *mem = NULL;
 226         size_t mem_len = 0;
 227         int toread;
 228
 229         if (con->srv_socket->is_ssl) {
 230                 return connection_handle_read_ssl(srv, con);
 231         }
 232
 233         /* default size for chunks is 4kb; only use bigger chunks if FIONREAD tells
 234          *  us more than 4kb is available
 235          * if FIONREAD doesn't signal a big chunk we fill the previous buffer
 236          *  if it has >= 1kb free
 237          */
 238 #if defined(__WIN32)
 239         chunkqueue_get_memory(con->read_queue, &mem, &mem_len, 0, 4096);
 240
 241         len = recv(con->fd, mem, mem_len, 0);
 242 #else /* __WIN32 */
 243         if (ioctl(con->fd, FIONREAD, &toread) || toread <= 4*1024) {
 244                 toread = 4096;
 245         }
 246         else if (toread > MAX_READ_LIMIT) {
 247                 toread = MAX_READ_LIMIT;
 248         }
 249         chunkqueue_get_memory(con->read_queue, &mem, &mem_len, 0, toread);
 250
 251         len = read(con->fd, mem, mem_len);
 252 #endif /* __WIN32 */
 253
 254         chunkqueue_use_memory(con->read_queue, len > 0 ? len : 0);
 255
 256         if (len < 0) {
 257                 con->is_readable = 0;
 258
 259 #if defined(__WIN32)
 260                 {
 261                         int lastError = WSAGetLastError();
 262                         switch (lastError) {
 263                         case EAGAIN:
 264                                 return 0;
 265                         case EINTR:
 266                                 /* we have been interrupted before we could read */
 267                                 con->is_readable = 1;
 268                                 return 0;
 269                         case ECONNRESET:
 270                                 /* suppress logging for this error, expected for keep-alive */
 271                                 break;
 272                         default:
 273                                 log_error_write(srv, __FILE__, __LINE__, "sd", "connection closed - recv failed: ", lastError);
 274                                 break;
 275                         }
 276                 }
 277 #else /* __WIN32 */
 278                 switch (errno) {
 279                 case EAGAIN:
 280                         return 0;
 281                 case EINTR:
 282                         /* we have been interrupted before we could read */
 283                         con->is_readable = 1;
 284                         return 0;
 285                 case ECONNRESET:
 286                         /* suppress logging for this error, expected for keep-alive */
 287                         break;
 288                 default:
 289                         log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
 290                         break;
 291                 }
 292 #endif /* __WIN32 */
 293
 294                 connection_set_state(srv, con, CON_STATE_ERROR);
 295
 296                 return -1;
 297         } else if (len == 0) {
 298                 con->is_readable = 0;
 299                 /* the other end close the connection -> KEEP-ALIVE */
 300
 301                 /* pipelining */
 302
 303                 return -2;
 304         } else if (len != (ssize_t) mem_len) {
 305                 /* we got less then expected, wait for the next fd-event */
 306
 307                 con->is_readable = 0;
 308         }
 309
 310         con->bytes_read += len;
 311 #if 0
 312         dump_packet(b->ptr, len);
 313 #endif
 314
 315         return 0;
 316 }
 317
 318 handler_t connection_handle_read_post_state(server *srv, connection *con) {
 319         chunkqueue *cq = con->read_queue;
 320         chunkqueue *dst_cq = con->request_content_queue;
 321
 322         int is_closed = 0;
 323
 324         if (con->is_readable) {
 325                 con->read_idle_ts = srv->cur_ts;
 326
 327                 switch(connection_handle_read(srv, con)) {
 328                 case -1:
 329                         return HANDLER_ERROR;
 330                 case -2:
 331                         is_closed = 1;
 332                         break;
 333                 default:
 334                         break;
 335                 }
 336         }
 337
 338         chunkqueue_remove_finished_chunks(cq);
 339
 340         if (con->request.content_length <= 64*1024) {
 341                 /* don't buffer request bodies <= 64k on disk */
 342                 chunkqueue_steal(dst_cq, cq, (off_t)con->request.content_length - dst_cq->bytes_in);
 343         }
 344         else if (0 != chunkqueue_steal_with_tempfiles(srv, dst_cq, cq, (off_t)con->request.content_length - dst_cq->bytes_in)) {
 345                 /* writing to temp file failed */
 346                 con->http_status = 500; /* Internal Server Error */
 347                 con->keep_alive = 0;
 348                 con->mode = DIRECT;
 349                 chunkqueue_reset(con->write_queue);
 350
 351                 return HANDLER_FINISHED;
 352         }
 353
 354         chunkqueue_remove_finished_chunks(cq);
 355
 356         if (dst_cq->bytes_in == (off_t)con->request.content_length) {
 357                 /* Content is ready */
 358                 con->conf.stream_request_body &= ~FDEVENT_STREAM_REQUEST_POLLIN;
 359                 if (con->state == CON_STATE_READ_POST) {
 360                         connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
 361                 }
 362                 return HANDLER_GO_ON;
 363         } else if (is_closed) {
 364               #if 0
 365                 con->http_status = 400; /* Bad Request */
 366                 con->keep_alive = 0;
 367                 con->mode = DIRECT;
 368                 chunkqueue_reset(con->write_queue);
 369
 370                 return HANDLER_FINISHED;
 371               #endif
 372                 return HANDLER_ERROR;
 373         } else {
 374                 con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_POLLIN;
 375                 return (con->conf.stream_request_body & FDEVENT_STREAM_REQUEST)
 376                   ? HANDLER_GO_ON
 377                   : HANDLER_WAIT_FOR_EVENT;
 378         }
 379 }
 380
 381 void connection_response_reset(server *srv, connection *con) {
 382         UNUSED(srv);
 383
 384         con->http_status = 0;
 385         con->is_writable = 1;
 386         con->file_finished = 0;
 387         con->file_started = 0;
 388         con->got_response = 0;
 389         con->parsed_response = 0;
 390         con->response.keep_alive = 0;
 391         con->response.content_length = -1;
 392         con->response.transfer_encoding = 0;
 393         buffer_reset(con->physical.path);
 394         array_reset(con->response.headers);
 395         chunkqueue_reset(con->write_queue);
 396 }