src/response.c

   1 #include "first.h"
   2
   3 #include "response.h"
   4 #include "fdevent.h"
   5 #include "keyvalue.h"
   6 #include "log.h"
   7 #include "stat_cache.h"
   8 #include "chunk.h"
   9
  10 #include "configfile.h"
  11
  12 #include "plugin.h"
  13
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16
  17 #include <limits.h>
  18 #include <errno.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <time.h>
  22
  23 int http_response_write_header(server *srv, connection *con) {
  24         buffer *b;
  25         size_t i;
  26         int have_date = 0;
  27         int have_server = 0;
  28
  29         b = buffer_init();
  30
  31         if (con->request.http_version == HTTP_VERSION_1_1) {
  32                 buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.1 "));
  33         } else {
  34                 buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.0 "));
  35         }
  36         buffer_append_int(b, con->http_status);
  37         buffer_append_string_len(b, CONST_STR_LEN(" "));
  38         buffer_append_string(b, get_http_status_name(con->http_status));
  39
  40         /* disable keep-alive if requested */
  41         if (con->request_count > con->conf.max_keep_alive_requests || 0 == con->conf.max_keep_alive_idle) {
  42                 con->keep_alive = 0;
  43         } else {
  44                 con->keep_alive_idle = con->conf.max_keep_alive_idle;
  45         }
  46
  47         if ((con->parsed_response & HTTP_UPGRADE) && con->request.http_version == HTTP_VERSION_1_1) {
  48                 response_header_overwrite(srv, con, CONST_STR_LEN("Connection"), CONST_STR_LEN("upgrade"));
  49         } else if (0 == con->keep_alive) {
  50                 response_header_overwrite(srv, con, CONST_STR_LEN("Connection"), CONST_STR_LEN("close"));
  51         } else if (con->request.http_version == HTTP_VERSION_1_0) {/*(&& con->keep_alive != 0)*/
  52                 response_header_overwrite(srv, con, CONST_STR_LEN("Connection"), CONST_STR_LEN("keep-alive"));
  53         }
  54
  55         /* add all headers */
  56         for (i = 0; i < con->response.headers->used; i++) {
  57                 data_string *ds;
  58
  59                 ds = (data_string *)con->response.headers->data[i];
  60
  61                 if (buffer_string_is_empty(ds->value) || buffer_string_is_empty(ds->key)) continue;
  62                 if (0 == strncasecmp(ds->key->ptr, CONST_STR_LEN("X-Sendfile"))) continue;
  63                 if (0 == strncasecmp(ds->key->ptr, CONST_STR_LEN("X-LIGHTTPD-"))) {
  64                         if (0 == strncasecmp(ds->key->ptr+sizeof("X-LIGHTTPD-")-1, CONST_STR_LEN("KBytes-per-second"))) {
  65                                 /* "X-LIGHTTPD-KBytes-per-second" */
  66                                 long limit = strtol(ds->value->ptr, NULL, 10);
  67                                 if (limit > 0
  68                                     && (limit < con->conf.kbytes_per_second
  69                                         || 0 == con->conf.kbytes_per_second)) {
  70                                         if (limit > USHRT_MAX) limit= USHRT_MAX;
  71                                         con->conf.kbytes_per_second = limit;
  72                                 }
  73                         }
  74                         continue;
  75                 } else {
  76                         if (0 == strcasecmp(ds->key->ptr, "Date")) have_date = 1;
  77                         if (0 == strcasecmp(ds->key->ptr, "Server")) have_server = 1;
  78                         if (0 == strcasecmp(ds->key->ptr, "Content-Encoding") && 304 == con->http_status) continue;
  79
  80                         buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
  81                         buffer_append_string_buffer(b, ds->key);
  82                         buffer_append_string_len(b, CONST_STR_LEN(": "));
  83 #if 0
  84                         /**
  85                          * the value might contain newlines, encode them with at least one white-space
  86                          */
  87                         buffer_append_string_encoded(b, CONST_BUF_LEN(ds->value), ENCODING_HTTP_HEADER);
  88 #else
  89                         buffer_append_string_buffer(b, ds->value);
  90 #endif
  91                 }
  92         }
  93
  94         if (!have_date) {
  95                 /* HTTP/1.1 requires a Date: header */
  96                 buffer_append_string_len(b, CONST_STR_LEN("\r\nDate: "));
  97
  98                 /* cache the generated timestamp */
  99                 if (srv->cur_ts != srv->last_generated_date_ts) {
 100                         buffer_string_prepare_copy(srv->ts_date_str, 255);
 101
 102                         buffer_append_strftime(srv->ts_date_str, "%a, %d %b %Y %H:%M:%S GMT", gmtime(&(srv->cur_ts)));
 103
 104                         srv->last_generated_date_ts = srv->cur_ts;
 105                 }
 106
 107                 buffer_append_string_buffer(b, srv->ts_date_str);
 108         }
 109
 110         if (!have_server) {
 111                 if (!buffer_string_is_empty(con->conf.server_tag)) {
 112                         buffer_append_string_len(b, CONST_STR_LEN("\r\nServer: "));
 113                         buffer_append_string_encoded(b, CONST_BUF_LEN(con->conf.server_tag), ENCODING_HTTP_HEADER);
 114                 }
 115         }
 116
 117         buffer_append_string_len(b, CONST_STR_LEN("\r\n\r\n"));
 118
 119         con->bytes_header = buffer_string_length(b);
 120
 121         if (con->conf.log_response_header) {
 122                 log_error_write(srv, __FILE__, __LINE__, "sSb", "Response-Header:", "\n", b);
 123         }
 124
 125         chunkqueue_prepend_buffer(con->write_queue, b);
 126         buffer_free(b);
 127
 128         return 0;
 129 }
 130
 131 handler_t http_response_prepare(server *srv, connection *con) {
 132         handler_t r;
 133
 134         /* looks like someone has already done a decision */
 135         if (con->mode == DIRECT &&
 136             (con->http_status != 0 && con->http_status != 200)) {
 137                 /* remove a packets in the queue */
 138                 if (con->file_finished == 0) {
 139                         chunkqueue_reset(con->write_queue);
 140                 }
 141
 142                 return HANDLER_FINISHED;
 143         }
 144
 145         /* no decision yet, build conf->filename */
 146         if (con->mode == DIRECT && buffer_is_empty(con->physical.path)) {
 147                 char *qstr;
 148
 149                 /* we only come here when we have the parse the full request again
 150                  *
 151                  * a HANDLER_COMEBACK from mod_rewrite and mod_fastcgi might be a
 152                  * problem here as mod_setenv might get called multiple times
 153                  *
 154                  * fastcgi-auth might lead to a COMEBACK too
 155                  * fastcgi again dead server too
 156                  *
 157                  * mod_compress might add headers twice too
 158                  *
 159                  *  */
 160
 161                 config_cond_cache_reset(srv, con);
 162                 config_setup_connection(srv, con); /* Perhaps this could be removed at other places. */
 163
 164                 if (con->conf.log_condition_handling) {
 165                         log_error_write(srv, __FILE__, __LINE__,  "s",  "run condition");
 166                 }
 167
 168                 /**
 169                  * prepare strings
 170                  *
 171                  * - uri.path_raw
 172                  * - uri.path (secure)
 173                  * - uri.query
 174                  *
 175                  */
 176
 177                 /**
 178                  * Name according to RFC 2396
 179                  *
 180                  * - scheme
 181                  * - authority
 182                  * - path
 183                  * - query
 184                  *
 185                  * (scheme)://(authority)(path)?(query)#fragment
 186                  *
 187                  *
 188                  */
 189
 190                 /* take initial scheme value from connection-level state
 191                  * (request con->uri.scheme can be overwritten for later,
 192                  *  for example by mod_extforward or mod_magnet) */
 193                 buffer_copy_buffer(con->uri.scheme, con->proto);
 194                 buffer_copy_buffer(con->uri.authority, con->request.http_host);
 195                 buffer_to_lower(con->uri.authority);
 196
 197                 /** their might be a fragment which has to be cut away */
 198                 if (NULL != (qstr = strchr(con->request.uri->ptr, '#'))) {
 199                         buffer_string_set_length(con->request.uri, qstr - con->request.uri->ptr);
 200                 }
 201
 202                 /** extract query string from request.uri */
 203                 if (NULL != (qstr = strchr(con->request.uri->ptr, '?'))) {
 204                         buffer_copy_string    (con->uri.query, qstr + 1);
 205                         buffer_copy_string_len(con->uri.path_raw, con->request.uri->ptr, qstr - con->request.uri->ptr);
 206                 } else {
 207                         buffer_reset     (con->uri.query);
 208                         buffer_copy_buffer(con->uri.path_raw, con->request.uri);
 209                 }
 210
 211                 /* decode url to path
 212                  *
 213                  * - decode url-encodings  (e.g. %20 -> ' ')
 214                  * - remove path-modifiers (e.g. /../)
 215                  */
 216
 217                 if (con->request.http_method == HTTP_METHOD_OPTIONS &&
 218                     con->uri.path_raw->ptr[0] == '*' && con->uri.path_raw->ptr[1] == '\0') {
 219                         /* OPTIONS * ... */
 220                         buffer_copy_buffer(con->uri.path, con->uri.path_raw);
 221                 } else {
 222                         buffer_copy_buffer(srv->tmp_buf, con->uri.path_raw);
 223                         buffer_urldecode_path(srv->tmp_buf);
 224                         buffer_path_simplify(con->uri.path, srv->tmp_buf);
 225                 }
 226
 227                 con->conditional_is_valid[COMP_SERVER_SOCKET] = 1;       /* SERVERsocket */
 228                 con->conditional_is_valid[COMP_HTTP_SCHEME] = 1;         /* Scheme:      */
 229                 con->conditional_is_valid[COMP_HTTP_HOST] = 1;           /* Host:        */
 230                 con->conditional_is_valid[COMP_HTTP_REMOTE_IP] = 1;      /* Client-IP */
 231                 con->conditional_is_valid[COMP_HTTP_REQUEST_METHOD] = 1; /* REQUEST_METHOD */
 232                 con->conditional_is_valid[COMP_HTTP_URL] = 1;            /* HTTPurl */
 233                 con->conditional_is_valid[COMP_HTTP_QUERY_STRING] = 1;   /* HTTPqs */
 234                 con->conditional_is_valid[COMP_HTTP_REQUEST_HEADER] = 1; /* HTTP request header */
 235                 config_patch_connection(srv, con);
 236
 237                 /* do we have to downgrade to 1.0 ? */
 238                 if (!con->conf.allow_http11) {
 239                         con->request.http_version = HTTP_VERSION_1_0;
 240                 }
 241
 242                 if (con->conf.log_request_handling) {
 243                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- splitting Request-URI");
 244                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Request-URI     : ", con->request.uri);
 245                         log_error_write(srv, __FILE__, __LINE__,  "sb", "URI-scheme      : ", con->uri.scheme);
 246                         log_error_write(srv, __FILE__, __LINE__,  "sb", "URI-authority   : ", con->uri.authority);
 247                         log_error_write(srv, __FILE__, __LINE__,  "sb", "URI-path (raw)  : ", con->uri.path_raw);
 248                         log_error_write(srv, __FILE__, __LINE__,  "sb", "URI-path (clean): ", con->uri.path);
 249                         log_error_write(srv, __FILE__, __LINE__,  "sb", "URI-query       : ", con->uri.query);
 250                 }
 251
 252                 /* con->conf.max_request_size is in kBytes */
 253                 if (0 != con->conf.max_request_size &&
 254                     (off_t)con->request.content_length > ((off_t)con->conf.max_request_size << 10)) {
 255                         log_error_write(srv, __FILE__, __LINE__, "sos",
 256                                         "request-size too long:", (off_t) con->request.content_length, "-> 413");
 257                         con->keep_alive = 0;
 258                         con->http_status = 413;
 259                         con->file_finished = 1;
 260
 261                         return HANDLER_FINISHED;
 262                 }
 263
 264
 265                 /**
 266                  *
 267                  * call plugins
 268                  *
 269                  * - based on the raw URL
 270                  *
 271                  */
 272
 273                 switch(r = plugins_call_handle_uri_raw(srv, con)) {
 274                 case HANDLER_GO_ON:
 275                         break;
 276                 case HANDLER_FINISHED:
 277                 case HANDLER_COMEBACK:
 278                 case HANDLER_WAIT_FOR_EVENT:
 279                 case HANDLER_ERROR:
 280                         return r;
 281                 default:
 282                         log_error_write(srv, __FILE__, __LINE__, "sd", "handle_uri_raw: unknown return value", r);
 283                         break;
 284                 }
 285
 286                 /**
 287                  *
 288                  * call plugins
 289                  *
 290                  * - based on the clean URL
 291                  *
 292                  */
 293
 294                 switch(r = plugins_call_handle_uri_clean(srv, con)) {
 295                 case HANDLER_GO_ON:
 296                         break;
 297                 case HANDLER_FINISHED:
 298                 case HANDLER_COMEBACK:
 299                 case HANDLER_WAIT_FOR_EVENT:
 300                 case HANDLER_ERROR:
 301                         return r;
 302                 default:
 303                         log_error_write(srv, __FILE__, __LINE__, "");
 304                         break;
 305                 }
 306
 307                 if (con->request.http_method == HTTP_METHOD_OPTIONS &&
 308                     con->uri.path->ptr[0] == '*' && con->uri.path_raw->ptr[1] == '\0') {
 309                         /* option requests are handled directly without checking of the path */
 310
 311                         response_header_insert(srv, con, CONST_STR_LEN("Allow"), CONST_STR_LEN("OPTIONS, GET, HEAD, POST"));
 312
 313                         con->http_status = 200;
 314                         con->file_finished = 1;
 315
 316                         return HANDLER_FINISHED;
 317                 }
 318
 319                 /***
 320                  *
 321                  * border
 322                  *
 323                  * logical filename (URI) becomes a physical filename here
 324                  *
 325                  *
 326                  *
 327                  */
 328
 329
 330
 331
 332                 /* 1. stat()
 333                  * ... ISREG() -> ok, go on
 334                  * ... ISDIR() -> index-file -> redirect
 335                  *
 336                  * 2. pathinfo()
 337                  * ... ISREG()
 338                  *
 339                  * 3. -> 404
 340                  *
 341                  */
 342
 343                 /*
 344                  * SEARCH DOCUMENT ROOT
 345                  */
 346
 347                 /* set a default */
 348
 349                 buffer_copy_buffer(con->physical.doc_root, con->conf.document_root);
 350                 buffer_copy_buffer(con->physical.rel_path, con->uri.path);
 351
 352 #if defined(__WIN32) || defined(__CYGWIN__)
 353                 /* strip dots from the end and spaces
 354                  *
 355                  * windows/dos handle those filenames as the same file
 356                  *
 357                  * foo == foo. == foo..... == "foo...   " == "foo..  ./"
 358                  *
 359                  * This will affect in some cases PATHINFO
 360                  *
 361                  * on native windows we could prepend the filename with \\?\ to circumvent
 362                  * this behaviour. I have no idea how to push this through cygwin
 363                  *
 364                  * */
 365
 366                 if (con->physical.rel_path->used > 1) {
 367                         buffer *b = con->physical.rel_path;
 368                         size_t len = buffer_string_length(b);
 369
 370                         /* strip trailing " /" or "./" once */
 371                         if (len > 1 &&
 372                             b->ptr[len - 1] == '/' &&
 373                             (b->ptr[len - 2] == ' ' || b->ptr[len - 2] == '.')) {
 374                                 len -= 2;
 375                         }
 376                         /* strip all trailing " " and "." */
 377                         while (len > 0 &&  ( ' ' == b->ptr[len-1] || '.' == b->ptr[len-1] ) ) --len;
 378                         buffer_string_set_length(b, len);
 379                 }
 380 #endif
 381
 382                 if (con->conf.log_request_handling) {
 383                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- before doc_root");
 384                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Doc-Root     :", con->physical.doc_root);
 385                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Rel-Path     :", con->physical.rel_path);
 386                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 387                 }
 388                 /* the docroot plugin should set the doc_root and might also set the physical.path
 389                  * for us (all vhost-plugins are supposed to set the doc_root)
 390                  * */
 391                 switch(r = plugins_call_handle_docroot(srv, con)) {
 392                 case HANDLER_GO_ON:
 393                         break;
 394                 case HANDLER_FINISHED:
 395                 case HANDLER_COMEBACK:
 396                 case HANDLER_WAIT_FOR_EVENT:
 397                 case HANDLER_ERROR:
 398                         return r;
 399                 default:
 400                         log_error_write(srv, __FILE__, __LINE__, "");
 401                         break;
 402                 }
 403
 404                 /* MacOS X and Windows can't distiguish between upper and lower-case
 405                  *
 406                  * convert to lower-case
 407                  */
 408                 if (con->conf.force_lowercase_filenames) {
 409                         buffer_to_lower(con->physical.rel_path);
 410                 }
 411
 412                 /* the docroot plugins might set the servername, if they don't we take http-host */
 413                 if (buffer_string_is_empty(con->server_name)) {
 414                         buffer_copy_buffer(con->server_name, con->uri.authority);
 415                 }
 416
 417                 /**
 418                  * create physical filename
 419                  * -> physical.path = docroot + rel_path
 420                  *
 421                  */
 422
 423                 buffer_copy_buffer(con->physical.basedir, con->physical.doc_root);
 424                 buffer_copy_buffer(con->physical.path, con->physical.doc_root);
 425                 buffer_append_slash(con->physical.path);
 426                 if (!buffer_string_is_empty(con->physical.rel_path) &&
 427                     con->physical.rel_path->ptr[0] == '/') {
 428                       #ifdef __COVERITY__
 429                         if (buffer_string_length(con->physical.rel_path) < 1) return HANDLER_ERROR;
 430                       #endif
 431                         /* coverity[overflow_sink : FALSE] */
 432                         buffer_append_string_len(con->physical.path, con->physical.rel_path->ptr + 1, buffer_string_length(con->physical.rel_path) - 1);
 433                 } else {
 434                         buffer_append_string_buffer(con->physical.path, con->physical.rel_path);
 435                 }
 436
 437                 if (con->conf.log_request_handling) {
 438                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- after doc_root");
 439                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Doc-Root     :", con->physical.doc_root);
 440                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Rel-Path     :", con->physical.rel_path);
 441                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 442                 }
 443
 444                 switch(r = plugins_call_handle_physical(srv, con)) {
 445                 case HANDLER_GO_ON:
 446                         break;
 447                 case HANDLER_FINISHED:
 448                 case HANDLER_COMEBACK:
 449                 case HANDLER_WAIT_FOR_EVENT:
 450                 case HANDLER_ERROR:
 451                         return r;
 452                 default:
 453                         log_error_write(srv, __FILE__, __LINE__, "");
 454                         break;
 455                 }
 456
 457                 if (con->conf.log_request_handling) {
 458                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- logical -> physical");
 459                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Doc-Root     :", con->physical.doc_root);
 460                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Basedir      :", con->physical.basedir);
 461                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Rel-Path     :", con->physical.rel_path);
 462                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 463                 }
 464         }
 465
 466         /*
 467          * Noone catched away the file from normal path of execution yet (like mod_access)
 468          *
 469          * Go on and check of the file exists at all
 470          */
 471
 472         if (con->mode == DIRECT) {
 473                 char *slash = NULL;
 474                 char *pathinfo = NULL;
 475                 int found = 0;
 476                 stat_cache_entry *sce = NULL;
 477
 478                 if (con->conf.log_request_handling) {
 479                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- handling physical path");
 480                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 481                 }
 482
 483                 if (HANDLER_ERROR != stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
 484                         /* file exists */
 485
 486                         if (con->conf.log_request_handling) {
 487                                 log_error_write(srv, __FILE__, __LINE__,  "s",  "-- file found");
 488                                 log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 489                         }
 490 #ifdef HAVE_LSTAT
 491                         if ((sce->is_symlink != 0) && !con->conf.follow_symlink) {
 492                                 con->http_status = 403;
 493
 494                                 if (con->conf.log_request_handling) {
 495                                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- access denied due symlink restriction");
 496                                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 497                                 }
 498
 499                                 buffer_reset(con->physical.path);
 500                                 return HANDLER_FINISHED;
 501                         };
 502 #endif
 503                         if (S_ISDIR(sce->st.st_mode)) {
 504                                 if (con->uri.path->ptr[buffer_string_length(con->uri.path) - 1] != '/') {
 505                                         /* redirect to .../ */
 506
 507                                         http_response_redirect_to_directory(srv, con);
 508
 509                                         return HANDLER_FINISHED;
 510                                 }
 511 #ifdef HAVE_LSTAT
 512                         } else if (!S_ISREG(sce->st.st_mode) && !sce->is_symlink) {
 513 #else
 514                         } else if (!S_ISREG(sce->st.st_mode)) {
 515 #endif
 516                                 /* any special handling of non-reg files ?*/
 517
 518
 519                         }
 520                 } else {
 521                         switch (errno) {
 522                         case EACCES:
 523                                 con->http_status = 403;
 524
 525                                 if (con->conf.log_request_handling) {
 526                                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- access denied");
 527                                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 528                                 }
 529
 530                                 buffer_reset(con->physical.path);
 531                                 return HANDLER_FINISHED;
 532                         case ENAMETOOLONG:
 533                                 /* file name to be read was too long. return 404 */
 534                         case ENOENT:
 535                                 con->http_status = 404;
 536
 537                                 if (con->conf.log_request_handling) {
 538                                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- file not found");
 539                                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 540                                 }
 541
 542                                 buffer_reset(con->physical.path);
 543                                 return HANDLER_FINISHED;
 544                         case ENOTDIR:
 545                                 /* PATH_INFO ! :) */
 546                                 break;
 547                         default:
 548                                 /* we have no idea what happend. let's tell the user so. */
 549                                 con->http_status = 500;
 550                                 buffer_reset(con->physical.path);
 551
 552                                 log_error_write(srv, __FILE__, __LINE__, "ssbsb",
 553                                                 "file not found ... or so: ", strerror(errno),
 554                                                 con->uri.path,
 555                                                 "->", con->physical.path);
 556
 557                                 return HANDLER_FINISHED;
 558                         }
 559
 560                         /* not found, perhaps PATHINFO */
 561
 562                         buffer_copy_buffer(srv->tmp_buf, con->physical.path);
 563
 564                         do {
 565                                 if (slash) {
 566                                         buffer_copy_string_len(con->physical.path, srv->tmp_buf->ptr, slash - srv->tmp_buf->ptr);
 567                                 } else {
 568                                         buffer_copy_buffer(con->physical.path, srv->tmp_buf);
 569                                 }
 570
 571                                 if (HANDLER_ERROR != stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
 572                                         found = S_ISREG(sce->st.st_mode);
 573                                         break;
 574                                 }
 575
 576                                 if (pathinfo != NULL) {
 577                                         *pathinfo = '\0';
 578                                 }
 579                                 slash = strrchr(srv->tmp_buf->ptr, '/');
 580
 581                                 if (pathinfo != NULL) {
 582                                         /* restore '/' */
 583                                         *pathinfo = '/';
 584                                 }
 585
 586                                 if (slash) pathinfo = slash;
 587                         } while ((found == 0) && (slash != NULL) && ((size_t)(slash - srv->tmp_buf->ptr) > (buffer_string_length(con->physical.basedir) - 1)));
 588
 589                         if (found == 0) {
 590                                 /* no it really doesn't exists */
 591                                 con->http_status = 404;
 592
 593                                 if (con->conf.log_file_not_found) {
 594                                         log_error_write(srv, __FILE__, __LINE__, "sbsb",
 595                                                         "file not found:", con->uri.path,
 596                                                         "->", con->physical.path);
 597                                 }
 598
 599                                 buffer_reset(con->physical.path);
 600
 601                                 return HANDLER_FINISHED;
 602                         }
 603
 604 #ifdef HAVE_LSTAT
 605                         if ((sce->is_symlink != 0) && !con->conf.follow_symlink) {
 606                                 con->http_status = 403;
 607
 608                                 if (con->conf.log_request_handling) {
 609                                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- access denied due symlink restriction");
 610                                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 611                                 }
 612
 613                                 buffer_reset(con->physical.path);
 614                                 return HANDLER_FINISHED;
 615                         };
 616 #endif
 617
 618                         /* we have a PATHINFO */
 619                         if (pathinfo) {
 620                                 size_t len = strlen(pathinfo), reqlen;
 621                                 if (con->conf.force_lowercase_filenames
 622                                     && len <= (reqlen = buffer_string_length(con->request.uri))
 623                                     && 0 == strncasecmp(con->request.uri->ptr + reqlen - len, pathinfo, len)) {
 624                                         /* attempt to preserve case-insensitive PATH_INFO
 625                                          * (works in common case where mod_alias, mod_magnet, and other modules
 626                                          *  have not modified the PATH_INFO portion of request URI, or did so
 627                                          *  with exactly the PATH_INFO desired) */
 628                                         buffer_copy_string_len(con->request.pathinfo, con->request.uri->ptr + reqlen - len, len);
 629                                 } else {
 630                                         buffer_copy_string_len(con->request.pathinfo, pathinfo, len);
 631                                 }
 632
 633                                 /*
 634                                  * shorten uri.path
 635                                  */
 636
 637                                 buffer_string_set_length(con->uri.path, buffer_string_length(con->uri.path) - len);
 638                         }
 639
 640                         if (con->conf.log_request_handling) {
 641                                 log_error_write(srv, __FILE__, __LINE__,  "s",  "-- after pathinfo check");
 642                                 log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 643                                 log_error_write(srv, __FILE__, __LINE__,  "sb", "URI          :", con->uri.path);
 644                                 log_error_write(srv, __FILE__, __LINE__,  "sb", "Pathinfo     :", con->request.pathinfo);
 645                         }
 646                 }
 647
 648                 if (con->conf.log_request_handling) {
 649                         log_error_write(srv, __FILE__, __LINE__,  "s",  "-- handling subrequest");
 650                         log_error_write(srv, __FILE__, __LINE__,  "sb", "Path         :", con->physical.path);
 651                 }
 652
 653                 /* call the handlers */
 654                 switch(r = plugins_call_handle_subrequest_start(srv, con)) {
 655                 case HANDLER_GO_ON:
 656                         /* request was not handled */
 657                         break;
 658                 case HANDLER_FINISHED:
 659                 default:
 660                         if (con->conf.log_request_handling) {
 661                                 log_error_write(srv, __FILE__, __LINE__,  "s",  "-- subrequest finished");
 662                         }
 663
 664                         /* something strange happend */
 665                         return r;
 666                 }
 667
 668                 /* if we are still here, no one wanted the file, status 403 is ok I think */
 669
 670                 if (con->mode == DIRECT && con->http_status == 0) {
 671                         switch (con->request.http_method) {
 672                         case HTTP_METHOD_OPTIONS:
 673                                 con->http_status = 200;
 674                                 break;
 675                         default:
 676                                 con->http_status = 403;
 677                         }
 678
 679                         return HANDLER_FINISHED;
 680                 }
 681
 682         }
 683
 684         switch(r = plugins_call_handle_subrequest(srv, con)) {
 685         case HANDLER_GO_ON:
 686                 /* request was not handled, looks like we are done */
 687                 return HANDLER_FINISHED;
 688         case HANDLER_FINISHED:
 689                 /* request is finished */
 690         default:
 691                 /* something strange happend */
 692                 return r;
 693         }
 694
 695         /* can't happen */
 696         return HANDLER_COMEBACK;
 697 }
 698
 699
 700