client.c

   1 /*
   2 Copyright (c) 2003-2006 by Juliusz Chroboczek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy
   5 of this software and associated documentation files (the "Software"), to deal
   6 in the Software without restriction, including without limitation the rights
   7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 copies of the Software, and to permit persons to whom the Software is
   9 furnished to do so, subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20 THE SOFTWARE.
  21 */
  22
  23 #include "polipo.h"
  24
  25 static int
  26 httpAcceptAgain(TimeEventHandlerPtr event)
  27 {
  28     FdEventHandlerPtr newevent;
  29     int fd = *(int*)event->data;
  30
  31     newevent = schedule_accept(fd, httpAccept, NULL);
  32     if(newevent == NULL) {
  33         free_chunk_arenas();
  34         newevent = schedule_accept(fd, httpAccept, NULL);
  35         if(newevent == NULL) {
  36             do_log(L_ERROR, "Couldn't schedule accept.\n");
  37             polipoExit();
  38         }
  39     }
  40     return 1;
  41 }
  42
  43 int
  44 httpAccept(int fd, FdEventHandlerPtr event, AcceptRequestPtr request)
  45 {
  46     int rc;
  47     HTTPConnectionPtr connection;
  48     TimeEventHandlerPtr timeout;
  49
  50     if(fd < 0) {
  51         if(-fd == EINTR || -fd == EAGAIN || -fd == EWOULDBLOCK)
  52             return 0;
  53         do_log_error(L_ERROR, -fd, "Couldn't establish listening socket");
  54         if(-fd == EMFILE || -fd == ENOMEM || -fd == ENOBUFS) {
  55             TimeEventHandlerPtr again = NULL;
  56             do_log(L_WARN, "Refusing client connections for one second.\n");
  57             free_chunk_arenas();
  58             again = scheduleTimeEvent(1, httpAcceptAgain,
  59                                       sizeof(request->fd), &request->fd);
  60             if(!again) {
  61                 do_log(L_ERROR, "Couldn't schedule accept -- sleeping.\n");
  62                 sleep(1);
  63                 again = scheduleTimeEvent(1, httpAcceptAgain,
  64                                           sizeof(request->fd), &request->fd);
  65                 if(!again) {
  66                     do_log(L_ERROR, "Couldn't schedule accept -- aborting.\n");
  67                     polipoExit();
  68                 }
  69             }
  70             return 1;
  71         } else {
  72             polipoExit();
  73             return 1;
  74         }
  75     }
  76
  77     if(allowedNets) {
  78         if(netAddressMatch(fd, allowedNets) != 1) {
  79             do_log(L_WARN, "Refusing connection from unauthorised net\n");
  80             CLOSE(fd);
  81             return 0;
  82         }
  83     }
  84
  85     rc = setNonblocking(fd, 1);
  86     if(rc < 0) {
  87         do_log_error(L_WARN, errno, "Couldn't set non blocking mode");
  88         CLOSE(fd);
  89         return 0;
  90     }
  91     rc = setNodelay(fd, 1);
  92     if(rc < 0)
  93         do_log_error(L_WARN, errno, "Couldn't disable Nagle's algorithm");
  94
  95     connection = httpMakeConnection();
  96
  97     timeout = scheduleTimeEvent(clientTimeout, httpTimeoutHandler,
  98                                 sizeof(connection), &connection);
  99     if(!timeout) {
 100         CLOSE(fd);
 101         free(connection);
 102         return 0;
 103     }
 104
 105     connection->fd = fd;
 106     connection->timeout = timeout;
 107
 108     do_log(D_CLIENT_CONN, "Accepted client connection 0x%lx\n",
 109            (unsigned long)connection);
 110
 111     connection->flags = CONN_READER;
 112
 113     do_stream_buf(IO_READ | IO_NOTNOW, connection->fd, 0,
 114                   &connection->reqbuf, CHUNK_SIZE,
 115                   httpClientHandler, connection);
 116     return 0;
 117 }
 118
 119 /* Abort a client connection.  It is only safe to abort the requests
 120    if we know the connection is closed. */
 121 void
 122 httpClientAbort(HTTPConnectionPtr connection, int closed)
 123 {
 124     HTTPRequestPtr request = connection->request;
 125
 126     pokeFdEvent(connection->fd, -EDOSHUTDOWN, POLLOUT);
 127     if(closed) {
 128         while(request) {
 129             if(request->chandler) {
 130                 request->error_code = 500;
 131                 request->error_message = internAtom("Connection finishing");
 132                 abortConditionHandler(request->chandler);
 133                 request->chandler = NULL;
 134             }
 135             request = request->next;
 136         }
 137     }
 138 }
 139
 140 /* s != 0 specifies that the connection must be shut down.  It is 1 in
 141    order to linger the connection, 2 to close it straight away. */
 142 void
 143 httpClientFinish(HTTPConnectionPtr connection, int s)
 144 {
 145     HTTPRequestPtr request = connection->request;
 146
 147     assert(!(request && request->request
 148              && request->request->request != request));
 149
 150     if(s == 0) {
 151         if(!request || !(request->flags & REQUEST_PERSISTENT))
 152             s = 1;
 153     }
 154
 155     httpConnectionDestroyBuf(connection);
 156
 157     connection->flags &= ~CONN_WRITER;
 158
 159     if(connection->flags & CONN_SIDE_READER) {
 160         /* We're in POST or PUT and the reader isn't done yet.
 161            Wait for the read side to close the connection. */
 162         assert(request && (connection->flags & CONN_READER));
 163         if(s >= 2) {
 164             pokeFdEvent(connection->fd, -EDOSHUTDOWN, POLLIN);
 165         } else {
 166             pokeFdEvent(connection->fd, -EDOGRACEFUL, POLLIN);
 167         }
 168         return;
 169     }
 170
 171     if(connection->timeout)
 172         cancelTimeEvent(connection->timeout);
 173     connection->timeout = NULL;
 174
 175     if(request) {
 176         HTTPRequestPtr requestee;
 177
 178         requestee = request->request;
 179         if(requestee) {
 180             request->request = NULL;
 181             requestee->request = NULL;
 182         }
 183         if(requestee)
 184             httpServerClientReset(requestee);
 185         if(request->chandler) {
 186             request->error_code = 500;
 187             request->error_message = internAtom("Connection finishing");
 188             abortConditionHandler(request->chandler);
 189             request->chandler = NULL;
 190         }
 191
 192         if(request->object) {
 193             if(request->object->requestor == request)
 194                 request->object->requestor = NULL;
 195             releaseObject(request->object);
 196             request->object = NULL;
 197         }
 198         httpDequeueRequest(connection);
 199         httpDestroyRequest(request);
 200         request = NULL;
 201
 202     }
 203
 204     connection->len = -1;
 205     connection->offset = 0;
 206     connection->te = TE_IDENTITY;
 207
 208     if(!s) {
 209         assert(connection->fd > 0);
 210         connection->serviced++;
 211         httpSetTimeout(connection, clientTimeout);
 212         if(!connection->flags & CONN_READER) {
 213             if(connection->reqlen == 0)
 214                 httpConnectionDestroyReqbuf(connection);
 215             else if((connection->flags & CONN_BIGREQBUF) &&
 216                     connection->reqlen < CHUNK_SIZE)
 217                 httpConnectionUnbigifyReqbuf(connection);
 218             connection->flags |= CONN_READER;
 219             httpSetTimeout(connection, clientTimeout);
 220             do_stream_buf(IO_READ | IO_NOTNOW |
 221                           (connection->reqlen ? IO_IMMEDIATE : 0),
 222                           connection->fd, connection->reqlen,
 223                           &connection->reqbuf,
 224                           (connection->flags & CONN_BIGREQBUF) ?
 225                           bigBufferSize : CHUNK_SIZE,
 226                           httpClientHandler, connection);
 227         }
 228         /* The request has already been validated when it first got
 229            into the queue */
 230         if(connection->request) {
 231             if(connection->request->object != NULL)
 232                 httpClientNoticeRequest(connection->request, 1);
 233             else
 234                 assert(connection->flags & CONN_READER);
 235         }
 236         return;
 237     }
 238
 239     do_log(D_CLIENT_CONN, "Closing client connection 0x%lx\n",
 240            (unsigned long)connection);
 241
 242     if(connection->flags & CONN_READER) {
 243         httpSetTimeout(connection, 10);
 244         if(connection->fd < 0) return;
 245         if(s >= 2) {
 246             pokeFdEvent(connection->fd, -EDOSHUTDOWN, POLLIN);
 247         } else {
 248             pokeFdEvent(connection->fd, -EDOGRACEFUL, POLLIN);
 249         }
 250         return;
 251     }
 252     while(1) {
 253         HTTPRequestPtr requestee;
 254         request = connection->request;
 255         if(!request)
 256             break;
 257         requestee = request->request;
 258         request->request = NULL;
 259         if(requestee) {
 260             requestee->request = NULL;
 261             httpServerClientReset(requestee);
 262         }
 263         if(request->chandler)
 264             abortConditionHandler(request->chandler);
 265         request->chandler = NULL;
 266         if(request->object && request->object->requestor == request)
 267             request->object->requestor = NULL;
 268         httpDequeueRequest(connection);
 269         httpDestroyRequest(request);
 270     }
 271     httpConnectionDestroyReqbuf(connection);
 272     if(connection->timeout)
 273         cancelTimeEvent(connection->timeout);
 274     connection->timeout = NULL;
 275     if(connection->fd >= 0) {
 276         if(s >= 2)
 277             CLOSE(connection->fd);
 278         else
 279             lingeringClose(connection->fd);
 280     }
 281     connection->fd = -1;
 282     free(connection);
 283 }
 284
 285 /* Extremely baroque implementation of close: we need to synchronise
 286    between the writer and the reader.  */
 287
 288 static char client_shutdown_buffer[17];
 289
 290 static int httpClientDelayedShutdownHandler(TimeEventHandlerPtr);
 291
 292 static int
 293 httpClientDelayedShutdown(HTTPConnectionPtr connection)
 294 {
 295     TimeEventHandlerPtr handler;
 296
 297     assert(connection->flags & CONN_READER);
 298     handler = scheduleTimeEvent(1, httpClientDelayedShutdownHandler,
 299                                 sizeof(connection), &connection);
 300     if(!handler) {
 301         do_log(L_ERROR,
 302                "Couldn't schedule delayed shutdown -- freeing memory.");
 303         free_chunk_arenas();
 304         handler = scheduleTimeEvent(1, httpClientDelayedShutdownHandler,
 305                                     sizeof(connection), &connection);
 306         if(!handler) {
 307             do_log(L_ERROR,
 308                    "Couldn't schedule delayed shutdown -- aborting.\n");
 309             polipoExit();
 310         }
 311     }
 312     return 1;
 313 }
 314
 315 static int
 316 httpClientShutdownHandler(int status,
 317                           FdEventHandlerPtr event, StreamRequestPtr request)
 318 {
 319     HTTPConnectionPtr connection = request->data;
 320
 321     assert(connection->flags & CONN_READER);
 322
 323     if(!(connection->flags & CONN_WRITER)) {
 324         connection->flags &= ~CONN_READER;
 325         connection->reqlen = 0;
 326         httpConnectionDestroyReqbuf(connection);
 327         if(status && status != -EDOGRACEFUL)
 328             httpClientFinish(connection, 2);
 329         else
 330             httpClientFinish(connection, 1);
 331         return 1;
 332     }
 333
 334     httpClientDelayedShutdown(connection);
 335     return 1;
 336 }
 337
 338 static int
 339 httpClientDelayedShutdownHandler(TimeEventHandlerPtr event)
 340 {
 341     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
 342     assert(connection->flags & CONN_READER);
 343
 344     if(!(connection->flags & CONN_WRITER)) {
 345         connection->flags &= ~CONN_READER;
 346         connection->reqlen = 0;
 347         httpConnectionDestroyReqbuf(connection);
 348         httpClientFinish(connection, 1);
 349         return 1;
 350     }
 351     do_stream(IO_READ | IO_NOTNOW, connection->fd,
 352               0, client_shutdown_buffer, 17,
 353               httpClientShutdownHandler, connection);
 354     return 1;
 355 }
 356
 357 int
 358 httpClientHandler(int status,
 359                   FdEventHandlerPtr event, StreamRequestPtr request)
 360 {
 361     HTTPConnectionPtr connection = request->data;
 362     int i, body;
 363     int bufsize =
 364         (connection->flags & CONN_BIGREQBUF) ? bigBufferSize : CHUNK_SIZE;
 365
 366     assert(connection->flags & CONN_READER);
 367
 368     /* There's no point trying to do something with this request if
 369        the client has shut the connection down -- HTTP doesn't do
 370        half-open connections. */
 371     if(status != 0) {
 372         connection->reqlen = 0;
 373         httpConnectionDestroyReqbuf(connection);
 374         if(!(connection->flags & CONN_WRITER)) {
 375             connection->flags &= ~CONN_READER;
 376             if(status > 0 || status == -ECONNRESET || status == -EDOSHUTDOWN)
 377                 httpClientFinish(connection, 2);
 378             else
 379                 httpClientFinish(connection, 1);
 380             return 1;
 381         }
 382         httpClientAbort(connection, status > 0 || status == -ECONNRESET);
 383         connection->flags &= ~CONN_READER;
 384         return 1;
 385     }
 386
 387     i = findEndOfHeaders(connection->reqbuf, 0, request->offset, &body);
 388     connection->reqlen = request->offset;
 389
 390     if(i >= 0) {
 391         connection->reqbegin = i;
 392         httpClientHandlerHeaders(event, request, connection);
 393         return 1;
 394     }
 395
 396     if(status) {
 397         if(connection->reqlen > 0) {
 398             if(connection->serviced <= 0)
 399                 do_log(L_ERROR, "Client dropped connection.\n");
 400             else
 401                 do_log(D_CLIENT_CONN, "Client dropped idle connection.\n");
 402         }
 403         connection->flags &= ~CONN_READER;
 404         if(!connection->request)
 405             httpClientFinish(connection, 2);
 406         else
 407             pokeFdEvent(connection->fd, -EDOGRACEFUL, POLLOUT);
 408         return 1;
 409     }
 410
 411     if(connection->reqlen >= bufsize) {
 412         int rc = 0;
 413         if(!(connection->flags & CONN_BIGREQBUF))
 414             rc = httpConnectionBigifyReqbuf(connection);
 415         if((connection->flags & CONN_BIGREQBUF) &&
 416            connection->reqlen < bigBufferSize) {
 417             do_stream(IO_READ, connection->fd, connection->reqlen,
 418                       connection->reqbuf, bigBufferSize,
 419                       httpClientHandler, connection);
 420             return 1;
 421         }
 422         connection->reqlen = 0;
 423         httpConnectionDestroyReqbuf(connection);
 424         if(rc < 0) {
 425             do_log(L_ERROR, "Couldn't allocate big buffer.\n");
 426             httpClientNewError(connection, METHOD_UNKNOWN, 0, 400,
 427                                internAtom("Couldn't allocate big buffer"));
 428         } else {
 429             do_log(L_ERROR, "Couldn't find end of client's headers.\n");
 430             httpClientNewError(connection, METHOD_UNKNOWN, 0, 400,
 431                                internAtom("Couldn't find end of headers"));
 432         }
 433         return 1;
 434     }
 435     httpSetTimeout(connection, clientTimeout);
 436     return 0;
 437 }
 438
 439 int
 440 httpClientRawErrorHeaders(HTTPConnectionPtr connection,
 441                           int code, AtomPtr message,
 442                           int close, AtomPtr headers)
 443 {
 444     int fd = connection->fd;
 445     int n;
 446     char *url; int url_len;
 447     char *etag;
 448
 449     assert(connection->flags & CONN_WRITER);
 450     assert(code != 0);
 451
 452     if(close >= 0) {
 453         if(connection->request)
 454             close =
 455                 close || !(connection->request->flags & REQUEST_PERSISTENT);
 456         else
 457             close = 1;
 458     }
 459     if(connection->request && connection->request->object) {
 460         url = connection->request->object->key;
 461         url_len = connection->request->object->key_size;
 462         etag = connection->request->object->etag;
 463     } else {
 464         url = NULL;
 465         url_len = 0;
 466         etag = NULL;
 467     }
 468
 469     if(connection->buf == NULL) {
 470         connection->buf = get_chunk();
 471         if(connection->buf == NULL) {
 472             httpClientFinish(connection, 1);
 473             return 1;
 474         }
 475     }
 476
 477     n = httpWriteErrorHeaders(connection->buf, CHUNK_SIZE, 0,
 478                               connection->request &&
 479                               connection->request->method != METHOD_HEAD,
 480                               code, message, close > 0, headers,
 481                               url, url_len, etag);
 482     if(n <= 0) {
 483         shutdown(connection->fd, 1);
 484         if(close >= 0)
 485             httpClientFinish(connection, 1);
 486         return 1;
 487     }
 488
 489     httpSetTimeout(connection, clientTimeout);
 490     do_stream(IO_WRITE, fd, 0, connection->buf, n,
 491               close > 0 ? httpErrorStreamHandler :
 492               close == 0 ? httpErrorNocloseStreamHandler :
 493               httpErrorNofinishStreamHandler,
 494               connection);
 495
 496     return 1;
 497 }
 498
 499 int
 500 httpClientRawError(HTTPConnectionPtr connection, int code, AtomPtr message,
 501                    int close)
 502 {
 503     return httpClientRawErrorHeaders(connection, code, message, close, NULL);
 504 }
 505
 506 int
 507 httpClientNoticeErrorHeaders(HTTPRequestPtr request, int code, AtomPtr message,
 508                              AtomPtr headers)
 509 {
 510     if(request->error_message)
 511         releaseAtom(request->error_message);
 512     if(request->error_headers)
 513         releaseAtom(request->error_headers);
 514     request->error_code = code;
 515     request->error_message = message;
 516     request->error_headers = headers;
 517     httpClientNoticeRequest(request, 0);
 518     return 1;
 519 }
 520
 521 int
 522 httpClientNoticeError(HTTPRequestPtr request, int code, AtomPtr message)
 523 {
 524     return httpClientNoticeErrorHeaders(request, code, message, NULL);
 525 }
 526
 527 int
 528 httpClientError(HTTPRequestPtr request, int code, AtomPtr message)
 529 {
 530     if(request->error_message)
 531         releaseAtom(request->error_message);
 532     request->error_code = code;
 533     request->error_message = message;
 534     if(request->chandler) {
 535         abortConditionHandler(request->chandler);
 536         request->chandler = NULL;
 537     } else if(request->object)
 538         notifyObject(request->object);
 539     return 1;
 540 }
 541
 542 /* This may be called from object handlers. */
 543 int
 544 httpClientLeanError(HTTPRequestPtr request, int code, AtomPtr message)
 545 {
 546     if(request->error_message)
 547         releaseAtom(request->error_message);
 548     request->error_code = code;
 549     request->error_message = message;
 550     return 1;
 551 }
 552
 553
 554 int
 555 httpClientNewError(HTTPConnectionPtr connection, int method, int persist,
 556                    int code, AtomPtr message)
 557 {
 558     HTTPRequestPtr request;
 559     request = httpMakeRequest();
 560     if(request == NULL) {
 561         do_log(L_ERROR, "Couldn't allocate error request.\n");
 562         httpClientFinish(connection, 1);
 563         return 1;
 564     }
 565     request->method = method;
 566     if(persist)
 567         request->flags |= REQUEST_PERSISTENT;
 568     else
 569         request->flags &= ~REQUEST_PERSISTENT;
 570     request->error_code = code;
 571     request->error_message = message;
 572
 573     httpQueueRequest(connection, request);
 574     httpClientNoticeRequest(request, 0);
 575     return 1;
 576 }
 577
 578 int
 579 httpErrorStreamHandler(int status,
 580                        FdEventHandlerPtr event,
 581                        StreamRequestPtr srequest)
 582 {
 583     HTTPConnectionPtr connection = srequest->data;
 584
 585     if(status == 0 && !streamRequestDone(srequest))
 586         return 0;
 587
 588     httpClientFinish(connection, 1);
 589     return 1;
 590 }
 591
 592 int
 593 httpErrorNocloseStreamHandler(int status,
 594                               FdEventHandlerPtr event,
 595                               StreamRequestPtr srequest)
 596 {
 597     HTTPConnectionPtr connection = srequest->data;
 598
 599     if(status == 0 && !streamRequestDone(srequest))
 600         return 0;
 601
 602     httpClientFinish(connection, 0);
 603     return 1;
 604 }
 605
 606 int
 607 httpErrorNofinishStreamHandler(int status,
 608                                FdEventHandlerPtr event,
 609                                StreamRequestPtr srequest)
 610 {
 611     if(status == 0 && !streamRequestDone(srequest))
 612         return 0;
 613
 614     return 1;
 615 }
 616
 617 int
 618 httpClientHandlerHeaders(FdEventHandlerPtr event, StreamRequestPtr srequest,
 619                          HTTPConnectionPtr connection)
 620 {
 621     HTTPRequestPtr request;
 622     int rc;
 623     int method, version;
 624     AtomPtr url = NULL;
 625     int start;
 626     int code;
 627     AtomPtr message;
 628
 629     start = 0;
 630     /* Work around clients working around NCSA lossage. */
 631     if(connection->reqbuf[0] == '\n')
 632         start = 1;
 633     else if(connection->reqbuf[0] == '\r' && connection->reqbuf[1] == '\n')
 634         start = 2;
 635
 636     httpSetTimeout(connection, -1);
 637     rc = httpParseClientFirstLine(connection->reqbuf, start,
 638                                   &method, &url, &version);
 639     if(rc <= 0) {
 640         do_log(L_ERROR, "Couldn't parse client's request line\n");
 641         code = 400;
 642         message =  internAtom("Error in request line");
 643         goto fail;
 644     }
 645
 646     do_log(D_CLIENT_REQ, "Client request: ");
 647     do_log_n(D_CLIENT_REQ, connection->reqbuf, rc - 1);
 648     do_log(D_CLIENT_REQ, "\n");
 649
 650     if(version != HTTP_10 && version != HTTP_11) {
 651         do_log(L_ERROR, "Unknown client HTTP version\n");
 652         code = 400;
 653         message = internAtom("Error in first request line");
 654         goto fail;
 655     }
 656
 657     if(method == METHOD_UNKNOWN) {
 658         code = 501;
 659         message =  internAtom("Method not implemented");
 660         goto fail;
 661     }
 662
 663     request = httpMakeRequest();
 664     if(request == NULL) {
 665         do_log(L_ERROR, "Couldn't allocate client request.\n");
 666         code = 500;
 667         message = internAtom("Couldn't allocate client request");
 668         goto fail;
 669     }
 670
 671     if(connection->version != HTTP_UNKNOWN && version != connection->version) {
 672         do_log(L_WARN, "Client version changed!\n");
 673     }
 674
 675     connection->version = version;
 676     request->flags = REQUEST_PERSISTENT;
 677     request->method = method;
 678     request->cache_control = no_cache_control;
 679     httpQueueRequest(connection, request);
 680     connection->reqbegin = rc;
 681     return httpClientRequest(request, url);
 682
 683  fail:
 684     if(url) releaseAtom(url);
 685     shutdown(connection->fd, 0);
 686     connection->reqlen = 0;
 687     connection->reqbegin = 0;
 688     httpConnectionDestroyReqbuf(connection);
 689     connection->flags &= ~CONN_READER;
 690     httpClientNewError(connection, METHOD_UNKNOWN, 0, code, message);
 691     return 1;
 692
 693 }
 694
 695 static int
 696 httpClientRequestDelayed(TimeEventHandlerPtr event)
 697 {
 698     HTTPRequestPtr request = *(HTTPRequestPtr*)event->data;
 699     AtomPtr url;
 700     url = internAtomN(request->object->key, request->object->key_size);
 701     if(url == NULL) {
 702         do_log(L_ERROR, "Couldn't allocate url.\n");
 703         abortObject(request->object, 503, internAtom("Couldn't allocate url"));
 704         return 1;
 705     }
 706     httpClientRequest(request, url);
 707     return 1;
 708 }
 709
 710 int
 711 delayedHttpClientRequest(HTTPRequestPtr request)
 712 {
 713     TimeEventHandlerPtr event;
 714     event = scheduleTimeEvent(-1, httpClientRequestDelayed,
 715                               sizeof(request), &request);
 716     if(!event)
 717         return -1;
 718     return 1;
 719 }
 720
 721 int
 722 httpClientRequest(HTTPRequestPtr request, AtomPtr url)
 723 {
 724     HTTPConnectionPtr connection = request->connection;
 725     int i, rc;
 726     int body_len, body_te;
 727     AtomPtr headers;
 728     CacheControlRec cache_control;
 729     AtomPtr via, expect, auth;
 730     HTTPConditionPtr condition;
 731     HTTPRangeRec range;
 732
 733     assert(!request->chandler);
 734     assert(connection->reqbuf);
 735
 736     i = httpParseHeaders(1, url,
 737                          connection->reqbuf, connection->reqbegin, request,
 738                          &headers, &body_len,
 739                          &cache_control, &condition, &body_te,
 740                          NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 741                          &expect, &range, NULL, NULL, &via, &auth);
 742     if(i < 0) {
 743         releaseAtom(url);
 744         do_log(L_ERROR, "Couldn't parse client headers.\n");
 745         shutdown(connection->fd, 0);
 746         request->flags &= ~REQUEST_PERSISTENT;
 747         connection->flags &= ~CONN_READER;
 748         httpClientNoticeError(request, 503,
 749                               internAtom("Couldn't parse client headers"));
 750         return 1;
 751     }
 752
 753     connection->reqbegin = i;
 754
 755     if(body_len < 0) {
 756         if(request->method == METHOD_GET || request->method == METHOD_HEAD)
 757             body_len = 0;
 758     }
 759     connection->bodylen = body_len;
 760     connection->reqte = body_te;
 761
 762     if(authRealm) {
 763         AtomPtr message = NULL;
 764         AtomPtr challenge = NULL;
 765         int code = checkClientAuth(auth, url, &message, &challenge);
 766         if(auth) {
 767             releaseAtom(auth);
 768             auth = NULL;
 769         }
 770         if(expect) {
 771             releaseAtom(expect);
 772             expect = NULL;
 773         }
 774         if(code) {
 775             request->flags |= REQUEST_FORCE_ERROR;
 776             httpClientDiscardBody(connection);
 777             httpClientNoticeErrorHeaders(request, code, message, challenge);
 778             return 1;
 779         }
 780     }
 781
 782     if(auth) {
 783         releaseAtom(auth);
 784         auth = NULL;
 785     }
 786
 787     if(expect) {
 788         if(expect == atom100Continue && REQUEST_SIDE(request)) {
 789             request->flags |= REQUEST_WAIT_CONTINUE;
 790         } else {
 791             httpClientDiscardBody(connection);
 792             httpClientNoticeError(request, 417,
 793                                   internAtom("Expectation failed"));
 794             releaseAtom(expect);
 795             return 1;
 796         }
 797         releaseAtom(expect);
 798     }
 799
 800     request->from = range.from < 0 ? 0 : range.from;
 801     request->to = range.to;
 802     request->cache_control = cache_control;
 803     request->via = via;
 804     request->headers = headers;
 805     request->condition = condition;
 806     request->object = NULL;
 807
 808     if(connection->serviced > 500)
 809         request->flags &= ~REQUEST_PERSISTENT;
 810
 811     if(request->method == METHOD_CONNECT) {
 812         if(connection->flags & CONN_WRITER) {
 813             /* For now */
 814             httpClientDiscardBody(connection);
 815             httpClientNoticeError(request, 500,
 816                                   internAtom("Pipelined CONNECT "
 817                                              "not supported"));
 818             return 1;
 819         }
 820         if(connection->flags & CONN_BIGREQBUF) {
 821             /* For now */
 822             httpClientDiscardBody(connection);
 823             httpClientNoticeError(request, 500,
 824                                   internAtom("CONNECT over big buffer "
 825                                              "not supported"));
 826             return 1;
 827         }
 828         connection->flags &= ~CONN_READER;
 829         do_tunnel(connection->fd, connection->reqbuf,
 830                   connection->reqbegin, connection->reqlen, url);
 831         connection->fd = -1;
 832         connection->reqbuf = NULL;
 833         connection->reqlen = 0;
 834         connection->reqbegin = 0;
 835         httpClientFinish(connection, 2);
 836         return 1;
 837     }
 838
 839     rc = urlForbidden(url, httpClientRequestContinue, request);
 840     if(rc < 0) {
 841         do_log(L_ERROR, "Couldn't schedule httpClientRequestContinue.\n");
 842         httpClientDiscardBody(connection);
 843         httpClientNoticeError(request, 500,
 844                               internAtom("Couldn't schedule "
 845                                          "httpClientRequestContinue"));
 846         return 1;
 847     }
 848     return 1;
 849 }
 850
 851 int
 852 httpClientRequestContinue(int forbidden_code, AtomPtr url,
 853                           AtomPtr forbidden_message, AtomPtr forbidden_headers,
 854                           void *closure)
 855 {
 856     HTTPRequestPtr request = (HTTPRequestPtr)closure;
 857     HTTPConnectionPtr connection = request->connection;
 858     RequestFunction requestfn;
 859     ObjectPtr object = NULL;
 860
 861     if(forbidden_code < 0) {
 862         releaseAtom(url);
 863         httpClientDiscardBody(connection);
 864         httpClientNoticeError(request, 500,
 865                               internAtomError(-forbidden_code,
 866                                               "Couldn't test for forbidden "
 867                                               "URL"));
 868         return 1;
 869     }
 870
 871     if(forbidden_code) {
 872         releaseAtom(url);
 873         httpClientDiscardBody(connection);
 874         httpClientNoticeErrorHeaders(request,
 875                                      forbidden_code, forbidden_message,
 876                                      forbidden_headers);
 877         return 1;
 878     }
 879
 880     requestfn =
 881         urlIsLocal(url->string, url->length) ?
 882         httpLocalRequest :
 883         httpServerRequest;
 884
 885     if(request->method == METHOD_POST || request->method == METHOD_PUT) {
 886         do {
 887             object = findObject(OBJECT_HTTP, url->string, url->length);
 888             if(object) {
 889                 privatiseObject(object, 0);
 890                 releaseObject(object);
 891             }
 892         } while(object);
 893         request->object = makeObject(OBJECT_HTTP, url->string, url->length,
 894                                      0, 0, requestfn, NULL);
 895         if(request->object == NULL) {
 896             httpClientDiscardBody(connection);
 897             httpClientNoticeError(request, 503,
 898                                   internAtom("Couldn't allocate object"));
 899             return 1;
 900         }
 901         if(requestfn == httpLocalRequest)
 902             request->object->flags |= OBJECT_LOCAL;
 903         return httpClientSideRequest(request);
 904     }
 905
 906     if(request->cache_control.flags & CACHE_AUTHORIZATION) {
 907         do {
 908             object = makeObject(OBJECT_HTTP, url->string, url->length, 0, 0,
 909                                 requestfn, NULL);
 910             if(object && object->flags != OBJECT_INITIAL) {
 911                 if(!(object->cache_control & CACHE_PUBLIC)) {
 912                     privatiseObject(object, 0);
 913                     releaseObject(object);
 914                     object = NULL;
 915                 } else
 916                     break;
 917             }
 918         } while(object == NULL);
 919         if(object)
 920             object->flags |= OBJECT_LINEAR;
 921     } else {
 922         object = findObject(OBJECT_HTTP, url->string, url->length);
 923         if(!object)
 924             object = makeObject(OBJECT_HTTP, url->string, url->length, 1, 1,
 925                                 requestfn, NULL);
 926     }
 927     releaseAtom(url);
 928     url = NULL;
 929
 930     if(!object) {
 931         do_log(L_ERROR, "Couldn't allocate object.\n");
 932         httpClientDiscardBody(connection);
 933         httpClientNoticeError(request, 503,
 934                               internAtom("Couldn't allocate object"));
 935         return 1;
 936     }
 937
 938     if(object->request == httpLocalRequest) {
 939         object->flags |= OBJECT_LOCAL;
 940     } else {
 941         if(disableProxy) {
 942             httpClientDiscardBody(connection);
 943             httpClientNoticeError(request, 403,
 944                                   internAtom("Proxying disabled"));
 945             releaseObject(object);
 946             return 1;
 947         }
 948
 949         if(!checkVia(proxyName, request->via)) {
 950             httpClientDiscardBody(connection);
 951             httpClientNoticeError(request, 504,
 952                                   internAtom("Proxy loop detected"));
 953             releaseObject(object);
 954             return 1;
 955         }
 956     }
 957
 958     request->object = object;
 959
 960     httpClientDiscardBody(connection);
 961     httpClientNoticeRequest(request, 0);
 962     return 1;
 963 }
 964
 965 static int httpClientDelayed(TimeEventHandlerPtr handler);
 966
 967 int
 968 httpClientDiscardBody(HTTPConnectionPtr connection)
 969 {
 970     TimeEventHandlerPtr handler;
 971
 972     assert(connection->reqoffset == 0);
 973     assert(connection->flags & CONN_READER);
 974
 975     if(connection->reqte != TE_IDENTITY)
 976         goto fail;
 977
 978     if(connection->bodylen < 0)
 979         goto fail;
 980
 981     if(connection->bodylen + connection->reqbegin < connection->reqlen) {
 982         connection->reqbegin += connection->bodylen;
 983         connection->bodylen = 0;
 984     } else {
 985         connection->bodylen -= connection->reqlen - connection->reqbegin;
 986         connection->reqbegin = 0;
 987         connection->reqlen = 0;
 988         httpConnectionDestroyReqbuf(connection);
 989     }
 990     connection->reqte = TE_UNKNOWN;
 991
 992     if(connection->bodylen > 0) {
 993         httpSetTimeout(connection, clientTimeout);
 994         do_stream_buf(IO_READ | IO_NOTNOW,
 995                       connection->fd, connection->reqlen,
 996                       &connection->reqbuf, CHUNK_SIZE,
 997                       httpClientDiscardHandler, connection);
 998         return 1;
 999     }
1000
1001     if(connection->reqlen > connection->reqbegin) {
1002         memmove(connection->reqbuf, connection->reqbuf + connection->reqbegin,
1003                 connection->reqlen - connection->reqbegin);
1004         connection->reqlen -= connection->reqbegin;
1005         connection->reqbegin = 0;
1006     } else {
1007         connection->reqlen = 0;
1008         connection->reqbegin = 0;
1009     }
1010
1011     httpSetTimeout(connection, clientTimeout);
1012     /* We need to delay in order to make sure the previous request
1013        gets queued on the server side.  IO_NOTNOW isn't strong enough
1014        for that due to IO_IMMEDIATE. */
1015     handler = scheduleTimeEvent(-1, httpClientDelayed,
1016                                 sizeof(connection), &connection);
1017     if(handler == NULL) {
1018         do_log(L_ERROR, "Couldn't schedule reading from client.");
1019         goto fail;
1020     }
1021     return 1;
1022
1023  fail:
1024     connection->reqlen = 0;
1025     connection->reqbegin = 0;
1026     connection->bodylen = 0;
1027     connection->reqte = TE_UNKNOWN;
1028     shutdown(connection->fd, 2);
1029     handler = scheduleTimeEvent(-1, httpClientDelayed,
1030                                 sizeof(connection), &connection);
1031     if(handler == NULL) {
1032         do_log(L_ERROR, "Couldn't schedule reading from client.");
1033         connection->flags &= ~CONN_READER;
1034     }
1035     return 1;
1036 }
1037
1038 static int
1039 httpClientDelayed(TimeEventHandlerPtr event)
1040 {
1041      HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1042
1043      /* IO_NOTNOW is unfortunate, but needed to avoid starvation if a
1044         client is pipelining a lot of requests. */
1045      if(connection->reqlen > 0) {
1046          int bufsize;
1047          if((connection->flags & CONN_BIGREQBUF) &&
1048             connection->reqlen < CHUNK_SIZE)
1049              httpConnectionUnbigifyReqbuf(connection);
1050          /* Don't read new requests if buffer is big. */
1051          bufsize = (connection->flags & CONN_BIGREQBUF) ?
1052              connection->reqlen : CHUNK_SIZE;
1053          do_stream(IO_READ | IO_IMMEDIATE | IO_NOTNOW,
1054                    connection->fd, connection->reqlen,
1055                    connection->reqbuf, bufsize,
1056                    httpClientHandler, connection);
1057      } else {
1058          httpConnectionDestroyReqbuf(connection);
1059          do_stream_buf(IO_READ | IO_NOTNOW,
1060                        connection->fd, 0,
1061                        &connection->reqbuf, CHUNK_SIZE,
1062                        httpClientHandler, connection);
1063      }
1064      return 1;
1065 }
1066
1067 int
1068 httpClientDiscardHandler(int status,
1069                          FdEventHandlerPtr event, StreamRequestPtr request)
1070 {
1071     HTTPConnectionPtr connection = request->data;
1072
1073     assert(connection->flags & CONN_READER);
1074     if(status) {
1075         if(status < 0 && status != -EPIPE)
1076             do_log_error(L_ERROR, -status, "Couldn't read from client");
1077         connection->bodylen = -1;
1078         return httpClientDiscardBody(connection);
1079     }
1080
1081     assert(request->offset > connection->reqlen);
1082     connection->reqlen = request->offset;
1083
1084     httpClientDiscardBody(connection);
1085     return 1;
1086 }
1087
1088 int
1089 httpClientNoticeRequest(HTTPRequestPtr request, int novalidate)
1090 {
1091     HTTPConnectionPtr connection = request->connection;
1092     ObjectPtr object = request->object;
1093     int serveNow = (request == connection->request);
1094     int validate = 0;
1095     int conditional = 0;
1096     int local, haveData;
1097     int rc;
1098
1099     assert(!request->chandler);
1100
1101     if(request->error_code) {
1102         if((request->flags & REQUEST_FORCE_ERROR) || REQUEST_SIDE(request) ||
1103            request->object == NULL ||
1104            (request->object->flags & OBJECT_LOCAL) ||
1105            (request->object->flags & OBJECT_ABORTED) ||
1106            (relaxTransparency < 1 && !proxyOffline)) {
1107             if(serveNow) {
1108                 connection->flags |= CONN_WRITER;
1109                 return httpClientRawErrorHeaders(connection,
1110                                                  request->error_code,
1111                                                  retainAtom(request->
1112                                                             error_message),
1113                                                  0, request->error_headers);
1114             } else {
1115                 return 1;
1116             }
1117         }
1118     }
1119
1120     if(REQUEST_SIDE(request)) {
1121         assert(!(request->flags & REQUEST_REQUESTED));
1122         if(serveNow) {
1123             assert(!request->chandler);
1124             request->chandler =
1125                 conditionWait(&request->object->condition,
1126                               httpClientGetHandler,
1127                               sizeof(request), &request);
1128             if(request->chandler == NULL) {
1129                 do_log(L_ERROR, "Couldn't register condition handler.\n");
1130                 connection->flags |= CONN_WRITER;
1131                 httpClientRawError(connection, 500,
1132                                    internAtom("Couldn't register "
1133                                               "condition handler"),
1134                                    0);
1135                 return 1;
1136             }
1137             connection->flags |= CONN_WRITER;
1138             rc = object->request(request->object,
1139                                  request->method,
1140                                  request->from, request->to,
1141                                  request,
1142                                  request->object->request_closure);
1143         }
1144         return 1;
1145     }
1146
1147     local = urlIsLocal(object->key, object->key_size);
1148     objectFillFromDisk(object, request->from,
1149                        request->method == METHOD_HEAD ? 0 : 1);
1150
1151     if(request->condition && request->condition->ifrange) {
1152         if(!object->etag ||
1153            strcmp(object->etag, request->condition->ifrange) != 0) {
1154             request->from = 0;
1155             request->to = -1;
1156         }
1157     }
1158
1159     if(object->flags & OBJECT_DYNAMIC) {
1160         request->from = 0;
1161         request->to = -1;
1162     }
1163
1164     if(request->method == METHOD_HEAD)
1165         haveData = !(request->object->flags & OBJECT_INITIAL);
1166     else
1167         haveData =
1168             (request->object->length >= 0 &&
1169              request->object->length <= request->from) ||
1170             (objectHoleSize(request->object, request->from) == 0);
1171
1172     if(request->flags & REQUEST_REQUESTED)
1173         validate = 0;
1174     else if(novalidate || (!local && proxyOffline))
1175         validate = 0;
1176     else if(local)
1177         validate =
1178             objectMustRevalidate(request->object, &request->cache_control);
1179     else if(request->cache_control.flags & CACHE_ONLY_IF_CACHED)
1180         validate = 0;
1181     else if((request->object->flags & OBJECT_FAILED) &&
1182             !(object->flags & OBJECT_INPROGRESS) &&
1183             !relaxTransparency)
1184         validate = 1;
1185     else if(request->method != METHOD_HEAD &&
1186             !objectHasData(object, request->from, request->to) &&
1187             !(object->flags & OBJECT_INPROGRESS))
1188         validate = 1;
1189     else if(objectMustRevalidate((relaxTransparency <= 1 ?
1190                                   request->object : NULL),
1191                                  &request->cache_control))
1192         validate = 1;
1193     else
1194         validate = 0;
1195
1196     if(request->cache_control.flags & CACHE_ONLY_IF_CACHED) {
1197         validate = 0;
1198         if(!haveData) {
1199             if(serveNow) {
1200                 connection->flags |= CONN_WRITER;
1201                 return httpClientRawError(connection, 504,
1202                                           internAtom("Object not in cache"),
1203                                           0);
1204             } else
1205                 return 1;
1206         }
1207     }
1208
1209     if(!(request->object->flags & OBJECT_VALIDATING) &&
1210        ((!validate && haveData) ||
1211         (request->object->flags & OBJECT_FAILED))) {
1212         if(serveNow) {
1213             connection->flags |= CONN_WRITER;
1214             lockChunk(request->object, request->from / CHUNK_SIZE);
1215             return httpServeObject(connection);
1216         } else {
1217             return 1;
1218         }
1219     }
1220
1221     if((request->flags & REQUEST_REQUESTED) &&
1222        !(request->object->flags & OBJECT_INPROGRESS)) {
1223         /* This can happen either because the server side ran out of
1224            memory, or because it is using HEAD validation.  We mark
1225            the object to be fetched again. */
1226         request->flags &= ~REQUEST_REQUESTED;
1227     }
1228
1229     if(serveNow) {
1230         connection->flags |= CONN_WRITER;
1231         if(!local && proxyOffline)
1232             return httpClientRawError(connection, 502,
1233                                       internAtom("Disconnected operation "
1234                                                  "and object not in cache"),
1235                                       0);
1236         request->chandler =
1237             conditionWait(&request->object->condition, httpClientGetHandler,
1238                           sizeof(request), &request);
1239         if(request->chandler == NULL) {
1240             do_log(L_ERROR, "Couldn't register condition handler.\n");
1241             return httpClientRawError(connection, 503,
1242                                       internAtom("Couldn't register "
1243                                                  "condition handler"), 0);
1244         }
1245     }
1246
1247     if(request->object->flags & OBJECT_VALIDATING)
1248         return 1;
1249
1250     conditional = (haveData && request->method == METHOD_GET);
1251     if(!mindlesslyCacheVary && (request->object->cache_control & CACHE_VARY))
1252         conditional = conditional && (request->object->etag != NULL);
1253
1254     conditional =
1255         conditional && !(request->object->cache_control & CACHE_MISMATCH);
1256
1257     request->object->flags |= OBJECT_VALIDATING;
1258     rc = request->object->request(request->object,
1259                                   conditional ? METHOD_CONDITIONAL_GET :
1260                                   request->method,
1261                                   request->from, request->to, request,
1262                                   request->object->request_closure);
1263     if(rc < 0) {
1264         if(request->chandler)
1265             unregisterConditionHandler(request->chandler);
1266         request->chandler = NULL;
1267         request->object->flags &= ~OBJECT_VALIDATING;
1268         request->object->flags |= OBJECT_FAILED;
1269         if(request->error_message)
1270             releaseAtom(request->error_message);
1271         request->error_code = 503;
1272         request->error_message = internAtom("Couldn't schedule get");
1273     }
1274     return 1;
1275 }
1276
1277 static int
1278 httpClientNoticeRequestDelayed(TimeEventHandlerPtr event)
1279 {
1280     HTTPRequestPtr request = *(HTTPRequestPtr*)event->data;
1281     httpClientNoticeRequest(request, 0);
1282     return 1;
1283 }
1284
1285 int
1286 delayedHttpClientNoticeRequest(HTTPRequestPtr request)
1287 {
1288     TimeEventHandlerPtr event;
1289     event = scheduleTimeEvent(-1, httpClientNoticeRequestDelayed,
1290                               sizeof(request), &request);
1291     if(!event)
1292         return -1;
1293     return 1;
1294 }
1295
1296 int
1297 httpClientContinueDelayed(TimeEventHandlerPtr event)
1298 {
1299     static char httpContinue[] = "HTTP/1.1 100 Continue\r\n\r\n";
1300     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1301
1302     do_stream(IO_WRITE, connection->fd, 0, httpContinue, 25,
1303               httpErrorNofinishStreamHandler, connection);
1304     return 1;
1305 }
1306
1307 int
1308 delayedHttpClientContinue(HTTPConnectionPtr connection)
1309 {
1310     TimeEventHandlerPtr event;
1311     event = scheduleTimeEvent(-1, httpClientContinueDelayed,
1312                               sizeof(connection), &connection);
1313     if(!event)
1314         return -1;
1315     return 1;
1316 }
1317
1318 int
1319 httpClientGetHandler(int status, ConditionHandlerPtr chandler)
1320 {
1321     HTTPRequestPtr request = *(HTTPRequestPtr*)chandler->data;
1322     HTTPConnectionPtr connection = request->connection;
1323     ObjectPtr object = request->object;
1324     int rc;
1325
1326     assert(request == connection->request);
1327
1328     if(request->request) {
1329         assert(request->object->flags & OBJECT_INPROGRESS);
1330         assert(!request->request->object ||
1331                request->request->object == request->object);
1332     }
1333
1334     if(status < 0) {
1335         object->flags &= ~OBJECT_VALIDATING; /* for now */
1336         if(request->request && request->request->request == request)
1337             httpServerClientReset(request->request);
1338         lockChunk(object, request->from / CHUNK_SIZE);
1339         request->chandler = NULL;
1340         rc = delayedHttpServeObject(connection);
1341         if(rc < 0) {
1342             unlockChunk(object, request->from / CHUNK_SIZE);
1343             do_log(L_ERROR, "Couldn't schedule serving.\n");
1344             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1345         }
1346         return 1;
1347     }
1348
1349     if(object->flags & OBJECT_VALIDATING)
1350         return 0;
1351
1352     if(request->error_code) {
1353         lockChunk(object, request->from / CHUNK_SIZE);
1354         request->chandler = NULL;
1355         rc = delayedHttpServeObject(connection);
1356         if(rc < 0) {
1357             unlockChunk(object, request->from / CHUNK_SIZE);
1358             do_log(L_ERROR, "Couldn't schedule serving.\n");
1359             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1360         }
1361         return 1;
1362     }
1363
1364     if(request->flags & REQUEST_WAIT_CONTINUE) {
1365         if(request->request &&
1366            !(request->request->flags & REQUEST_WAIT_CONTINUE)) {
1367             request->flags &= ~REQUEST_WAIT_CONTINUE;
1368             delayedHttpClientContinue(connection);
1369         }
1370         return 0;
1371     }
1372
1373     /* See httpServerHandlerHeaders */
1374     if((object->flags & OBJECT_SUPERSEDED) &&
1375        request->request && request->request->can_mutate) {
1376         ObjectPtr new_object = retainObject(request->request->can_mutate);
1377         if(object->requestor == request) {
1378             if(new_object->requestor == NULL)
1379                 new_object->requestor = request;
1380             object->requestor = NULL;
1381         }
1382         request->chandler = NULL;
1383         releaseObject(object);
1384         request->object = new_object;
1385         request->request->object = new_object;
1386         /* We're handling the wrong object now.  It's simpler to
1387            rebuild the whole data structure from scratch rather than
1388            trying to compensate. */
1389         rc = delayedHttpClientNoticeRequest(request);
1390         if(rc < 0) {
1391             do_log(L_ERROR, "Couldn't schedule noticing of request.");
1392             abortObject(object, 500,
1393                         internAtom("Couldn't schedule "
1394                                    "noticing of request"));
1395             /* We're probably out of memory.  What can we do? */
1396             shutdown(connection->fd, 1);
1397         }
1398         return 1;
1399     }
1400
1401     if(object->requestor != request && !(object->flags & OBJECT_ABORTED)) {
1402         /* Make sure we don't serve an object that is stale for us
1403            unless we're the requestor. */
1404         if((object->flags & (OBJECT_LINEAR | OBJECT_MUTATING)) ||
1405            objectMustRevalidate(object, &request->cache_control)) {
1406            if(object->flags & OBJECT_INPROGRESS)
1407                return 0;
1408            rc = delayedHttpClientNoticeRequest(request);
1409            if(rc < 0) {
1410                do_log(L_ERROR, "Couldn't schedule noticing of request.");
1411                abortObject(object, 500,
1412                            internAtom("Couldn't schedule "
1413                                       "noticing of request"));
1414            } else {
1415                request->chandler = NULL;
1416                return 1;
1417            }
1418         }
1419     }
1420
1421     if(object->flags & (OBJECT_INITIAL | OBJECT_VALIDATING)) {
1422         if(object->flags & (OBJECT_INPROGRESS | OBJECT_VALIDATING)) {
1423             return 0;
1424         } else if(object->flags & OBJECT_FAILED) {
1425             if(request->error_code)
1426                 abortObject(object,
1427                             request->error_code,
1428                             retainAtom(request->error_message));
1429             else {
1430                 abortObject(object, 500,
1431                             internAtom("Error message lost in transit"));
1432             }
1433         } else {
1434             /* The request was pruned by httpServerDiscardRequests */
1435             if(chandler == request->chandler) {
1436                 int rc;
1437                 request->chandler = NULL;
1438                 rc = delayedHttpClientNoticeRequest(request);
1439                 if(rc < 0)
1440                     abortObject(object, 500,
1441                                 internAtom("Couldn't allocate "
1442                                            "delayed notice request"));
1443                 else
1444                     return 1;
1445             } else {
1446                 abortObject(object, 500,
1447                             internAtom("Wrong request pruned -- "
1448                                        "this shouldn't happen"));
1449             }
1450         }
1451     }
1452
1453     if(request->object->flags & OBJECT_DYNAMIC) {
1454         if(objectHoleSize(request->object, 0) == 0) {
1455             request->from = 0;
1456             request->to = -1;
1457         } else {
1458             /* We really should request again if that is not the case */
1459         }
1460     }
1461
1462     lockChunk(object, request->from / CHUNK_SIZE);
1463     request->chandler = NULL;
1464     rc = delayedHttpServeObject(connection);
1465     if(rc < 0) {
1466         unlockChunk(object, request->from / CHUNK_SIZE);
1467         do_log(L_ERROR, "Couldn't schedule serving.\n");
1468         abortObject(object, 503, internAtom("Couldn't schedule serving"));
1469     }
1470     return 1;
1471 }
1472
1473 int
1474 httpClientSideRequest(HTTPRequestPtr request)
1475 {
1476     HTTPConnectionPtr connection = request->connection;
1477
1478     if(request->from < 0 || request->to >= 0) {
1479         httpClientNoticeError(request, 501,
1480                               internAtom("Partial requests not implemented"));
1481         httpClientDiscardBody(connection);
1482         return 1;
1483     }
1484     if(connection->reqte != TE_IDENTITY) {
1485         httpClientNoticeError(request, 501,
1486                               internAtom("Chunked requests not implemented"));
1487         httpClientDiscardBody(connection);
1488         return 1;
1489     }
1490     if(connection->bodylen < 0) {
1491         httpClientNoticeError(request, 502,
1492                               internAtom("POST or PUT without "
1493                                          "Content-Length"));
1494         httpClientDiscardBody(connection);
1495         return 1;
1496     }
1497     if(connection->reqlen < 0) {
1498         httpClientNoticeError(request, 502,
1499                               internAtom("Incomplete POST or PUT"));
1500         httpClientDiscardBody(connection);
1501         return 1;
1502     }
1503
1504     return httpClientNoticeRequest(request, 0);
1505 }
1506
1507 int
1508 httpClientSideHandler(int status,
1509                       FdEventHandlerPtr event,
1510                       StreamRequestPtr srequest)
1511 {
1512     HTTPConnectionPtr connection = srequest->data;
1513     HTTPRequestPtr request = connection->request;
1514     HTTPRequestPtr requestee;
1515     HTTPConnectionPtr server;
1516     int push;
1517     int code;
1518     AtomPtr message = NULL;
1519
1520     assert(connection->flags & CONN_SIDE_READER);
1521
1522     if((request->object->flags & OBJECT_ABORTED) ||
1523        !(request->object->flags & OBJECT_INPROGRESS)) {
1524         code = request->object->code;
1525         message = retainAtom(request->object->message);
1526         goto fail;
1527     }
1528
1529     if(status < 0) {
1530         do_log_error(L_ERROR, -status, "Reading from client");
1531         code = 502;
1532         message = internAtomError(-status, "Couldn't read from client");
1533         goto fail;
1534     }
1535
1536     requestee = request->request;
1537     server = requestee->connection;
1538
1539     push = MIN(srequest->offset - connection->reqlen,
1540                connection->bodylen - connection->reqoffset);
1541     if(push > 0) {
1542         connection->reqlen += push;
1543         httpServerDoSide(server);
1544         return 1;
1545     }
1546
1547     if(server->reqoffset >= connection->bodylen) {
1548         connection->flags &= ~(CONN_READER | CONN_SIDE_READER);
1549         return 1;
1550     }
1551
1552     assert(status);
1553     do_log(L_ERROR, "Incomplete client request.\n");
1554     code = 502;
1555     message = internAtom("Incomplete client request");
1556
1557  fail:
1558     request->error_code = code;
1559     if(request->error_message)
1560         releaseAtom(request->error_message);
1561     request->error_message = message;
1562     if(request->error_headers)
1563         releaseAtom(request->error_headers);
1564     request->error_headers = NULL;
1565
1566     if(request->request) {
1567         shutdown(request->request->connection->fd, 2);
1568         pokeFdEvent(request->request->connection->fd, -ESHUTDOWN, POLLOUT);
1569     }
1570     notifyObject(request->object);
1571     connection->flags &= ~CONN_SIDE_READER;
1572     httpClientDiscardBody(connection);
1573     return 1;
1574 }
1575
1576 int
1577 httpServeObject(HTTPConnectionPtr connection)
1578 {
1579     HTTPRequestPtr request = connection->request;
1580     ObjectPtr object = request->object;
1581     int i = request->from / CHUNK_SIZE;
1582     int j = request->from % CHUNK_SIZE;
1583     int n, len, rc;
1584     int bufsize = CHUNK_SIZE;
1585     int condition_result;
1586
1587     object->atime = current_time.tv_sec;
1588     objectMetadataChanged(object, 0);
1589
1590     httpSetTimeout(connection, -1);
1591
1592     if((request->error_code && relaxTransparency <= 0) ||
1593        object->flags & OBJECT_INITIAL) {
1594         object->flags &= ~OBJECT_FAILED;
1595         unlockChunk(object, i);
1596         if(request->error_code)
1597             return httpClientRawError(connection,
1598                                       request->error_code,
1599                                       retainAtom(request->error_message), 0);
1600         else
1601             return httpClientRawError(connection,
1602                                       500, internAtom("Object vanished."), 0);
1603     }
1604
1605     if(!(object->flags & OBJECT_INPROGRESS) && object->code == 0) {
1606         if(object->flags & OBJECT_INITIAL) {
1607             unlockChunk(object, i);
1608             return httpClientRawError(connection, 503,
1609                                       internAtom("Error message lost"), 0);
1610
1611         } else {
1612             unlockChunk(object, i);
1613             do_log(L_ERROR, "Internal proxy error: object has no code.\n");
1614             return httpClientRawError(connection, 500,
1615                                       internAtom("Internal proxy error: "
1616                                                  "object has no code"), 0);
1617         }
1618     }
1619
1620     condition_result = httpCondition(object, request->condition);
1621
1622     if(condition_result == CONDITION_FAILED) {
1623         unlockChunk(object, i);
1624         return httpClientRawError(connection, 412,
1625                                   internAtom("Precondition failed"), 0);
1626     } else if(condition_result == CONDITION_NOT_MODIFIED) {
1627         unlockChunk(object, i);
1628         return httpClientRawError(connection, 304,
1629                                   internAtom("Not modified"), 0);
1630     }
1631
1632     objectFillFromDisk(object, request->from,
1633                        (request->method == METHOD_HEAD ||
1634                         condition_result != CONDITION_MATCH) ? 0 : 1);
1635
1636     if(((object->flags & OBJECT_LINEAR) &&
1637         (object->requestor != connection->request)) ||
1638        ((object->flags & OBJECT_SUPERSEDED) &&
1639         !(object->flags & OBJECT_LINEAR))) {
1640         if(request->request) {
1641             request->request->request = NULL;
1642             request->request = NULL;
1643             request->object->requestor = NULL;
1644         }
1645         object = makeObject(OBJECT_HTTP,
1646                             object->key, object->key_size, 1, 0,
1647                             object->request, NULL);
1648         if(request->object->requestor == request)
1649             request->object->requestor = NULL;
1650         unlockChunk(request->object, i);
1651         releaseObject(request->object);
1652         request->object = NULL;
1653         if(object == NULL) {
1654             do_log(L_ERROR, "Couldn't allocate object.");
1655             return httpClientRawError(connection, 501,
1656                                       internAtom("Couldn't allocate object"),
1657                                       1);
1658         }
1659         if(urlIsLocal(object->key, object->key_size)) {
1660             object->flags |= OBJECT_LOCAL;
1661             object->request = httpLocalRequest;
1662         }
1663         request->object = object;
1664         connection->flags &= ~CONN_WRITER;
1665         return httpClientNoticeRequest(request, 1);
1666     }
1667
1668     if(object->flags & OBJECT_ABORTED) {
1669         unlockChunk(object, i);
1670         return httpClientNoticeError(request, object->code,
1671                                      retainAtom(object->message));
1672     }
1673
1674     if(connection->buf == NULL)
1675         connection->buf = get_chunk();
1676     if(connection->buf == NULL) {
1677         unlockChunk(object, i);
1678         do_log(L_ERROR, "Couldn't allocate client buffer.\n");
1679         connection->flags &= ~CONN_WRITER;
1680         httpClientFinish(connection, 1);
1681         return 1;
1682     }
1683
1684     if(object->length >= 0 && request->to >= object->length)
1685         request->to = -1;
1686
1687     if(request->from > 0 || request->to >= 0) {
1688         if(request->method == METHOD_HEAD) {
1689             request->to = request->from;
1690         } else if(request->to < 0) {
1691             if(object->length >= 0)
1692                 request->to = object->length;
1693         }
1694     }
1695
1696  again:
1697
1698     connection->len = 0;
1699
1700     if((request->from <= 0 && request->to < 0) ||
1701        request->method == METHOD_HEAD) {
1702         n = snnprintf(connection->buf, 0, bufsize,
1703                       "HTTP/1.1 %d %s",
1704                       object->code, atomString(object->message));
1705     } else {
1706         if(request->from > request->to) {
1707             unlockChunk(object, i);
1708             return httpClientRawError(connection, 416,
1709                                       internAtom("Requested range "
1710                                                  "not satisfiable"),
1711                                       0);
1712         } else {
1713             n = snnprintf(connection->buf, 0, bufsize,
1714                           "HTTP/1.1 206 Partial content");
1715         }
1716     }
1717
1718     n = httpWriteObjectHeaders(connection->buf, n, bufsize,
1719                                object, request->from, request->to);
1720     if(n < 0)
1721         goto fail;
1722
1723     if(request->method != METHOD_HEAD &&
1724        condition_result != CONDITION_NOT_MODIFIED &&
1725        request->to < 0 && object->length < 0) {
1726         if(connection->version == HTTP_11) {
1727             connection->te = TE_CHUNKED;
1728             n = snnprintf(connection->buf, n, bufsize,
1729                           "\r\nTransfer-Encoding: chunked");
1730         } else {
1731             request->flags &= ~REQUEST_PERSISTENT;
1732         }
1733     }
1734
1735     if(object->age < current_time.tv_sec) {
1736         n = snnprintf(connection->buf, n, bufsize,
1737                       "\r\nAge: %d",
1738                       (int)(current_time.tv_sec - object->age));
1739     }
1740     n = snnprintf(connection->buf, n, bufsize,
1741                   "\r\nConnection: %s",
1742                   (request->flags & REQUEST_PERSISTENT) ?
1743                   "keep-alive" : "close");
1744
1745     if(!(object->flags & OBJECT_LOCAL)) {
1746         if((object->flags & OBJECT_FAILED) && !proxyOffline) {
1747             n = snnprintf(connection->buf, n, bufsize,
1748                           "\r\nWarning: 111 %s:%d Revalidation failed",
1749                           proxyName->string, proxyPort);
1750             if(request->error_code)
1751                 n = snnprintf(connection->buf, n, bufsize,
1752                               " (%d %s)",
1753                               request->error_code,
1754                               atomString(request->error_message));
1755             object->flags &= ~OBJECT_FAILED;
1756         } else if(proxyOffline &&
1757                   objectMustRevalidate(object, &request->cache_control)) {
1758             n = snnprintf(connection->buf, n, bufsize,
1759                           "\r\nWarning: 112 %s:%d Disconnected operation",
1760                           proxyName->string, proxyPort);
1761         } else if(objectIsStale(object, &request->cache_control)) {
1762             n = snnprintf(connection->buf, n, bufsize,
1763                           "\r\nWarning: 110 %s:%d Object is stale",
1764                           proxyName->string, proxyPort);
1765         } else if(object->expires < 0 && object->max_age < 0 &&
1766                   object->age < current_time.tv_sec - 24 * 3600) {
1767             n = snnprintf(connection->buf, n, bufsize,
1768                           "\r\nWarning: 113 %s:%d Heuristic expiration",
1769                           proxyName->string, proxyPort);
1770         }
1771     }
1772
1773     n = snnprintf(connection->buf, n, bufsize, "\r\n\r\n");
1774
1775     if(n < 0)
1776         goto fail;
1777
1778     connection->offset = request->from;
1779
1780     if(request->method == METHOD_HEAD ||
1781        condition_result == CONDITION_NOT_MODIFIED ||
1782        (object->flags & OBJECT_ABORTED)) {
1783         len = 0;
1784     } else {
1785         if(i < object->numchunks) {
1786             if(object->chunks[i].size <= j)
1787                 len = 0;
1788             else
1789                 len = object->chunks[i].size - j;
1790         } else {
1791             len = 0;
1792         }
1793         if(request->to >= 0)
1794             len = MIN(len, request->to - request->from);
1795     }
1796
1797     connection->offset = request->from;
1798     httpSetTimeout(connection, clientTimeout);
1799     do_log(D_CLIENT_DATA, "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1800            (unsigned long)connection, (unsigned long)object,
1801            connection->offset, len);
1802     do_stream_h(IO_WRITE |
1803                 (connection->te == TE_CHUNKED && len > 0 ? IO_CHUNKED : 0),
1804                 connection->fd, 0,
1805                 connection->buf, n,
1806                 object->chunks[i].data + j, len,
1807                 httpServeObjectStreamHandler, connection);
1808     return 1;
1809
1810  fail:
1811     rc = 0;
1812     connection->len = 0;
1813     if(!(connection->flags & CONN_BIGBUF))
1814         rc = httpConnectionBigify(connection);
1815     if(rc > 0) {
1816         bufsize = bigBufferSize;
1817         goto again;
1818     }
1819     unlockChunk(object, i);
1820     return httpClientRawError(connection, 500,
1821                               rc == 0 ?
1822                               internAtom("No space for headers") :
1823                               internAtom("Couldn't allocate big buffer"), 0);
1824 }
1825
1826 static int
1827 httpServeObjectDelayed(TimeEventHandlerPtr event)
1828 {
1829     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1830     httpServeObject(connection);
1831     return 1;
1832 }
1833
1834 int
1835 delayedHttpServeObject(HTTPConnectionPtr connection)
1836 {
1837     TimeEventHandlerPtr event;
1838
1839     assert(connection->request->object->chunks[connection->request->from /
1840                                                CHUNK_SIZE].locked > 0);
1841
1842     event = scheduleTimeEvent(-1, httpServeObjectDelayed,
1843                               sizeof(connection), &connection);
1844     if(!event) return -1;
1845     return 1;
1846 }
1847
1848 static int
1849 httpServeObjectFinishHandler(int status,
1850                              FdEventHandlerPtr event,
1851                              StreamRequestPtr srequest)
1852 {
1853     HTTPConnectionPtr connection = srequest->data;
1854     HTTPRequestPtr request = connection->request;
1855
1856     (void)request;
1857     assert(!request->chandler);
1858
1859     if(status == 0 && !streamRequestDone(srequest))
1860         return 0;
1861
1862     httpSetTimeout(connection, -1);
1863
1864     if(status < 0) {
1865         do_log(L_ERROR, "Couldn't terminate chunked reply\n");
1866         httpClientFinish(connection, 1);
1867     } else {
1868         httpClientFinish(connection, 0);
1869     }
1870     return 1;
1871 }
1872
1873 int
1874 httpServeChunk(HTTPConnectionPtr connection)
1875 {
1876     HTTPRequestPtr request = connection->request;
1877     ObjectPtr object = request->object;
1878     int i = connection->offset / CHUNK_SIZE;
1879     int j = connection->offset - (i * CHUNK_SIZE);
1880     int to, len, len2, end;
1881     int rc;
1882
1883     if(object->flags & OBJECT_ABORTED)
1884         goto fail_no_unlock;
1885
1886     if(object->length >= 0 && request->to >= 0)
1887         to = MIN(request->to, object->length);
1888     else if(object->length >= 0)
1889         to = object->length;
1890     else if(request->to >= 0)
1891         to = request->to;
1892     else
1893         to = -1;
1894
1895     lockChunk(object, i);
1896     len = 0;
1897     if(i < object->numchunks)
1898         len = object->chunks[i].size - j;
1899
1900     if(request->method != METHOD_HEAD &&
1901        len < CHUNK_SIZE && connection->offset + len < to) {
1902         objectFillFromDisk(object, connection->offset + len, 2);
1903         len = object->chunks[i].size - j;
1904     }
1905
1906     if(to >= 0)
1907         len = MIN(len, to - connection->offset);
1908
1909     if(len <= 0) {
1910         if(to >= 0 && connection->offset >= to) {
1911             if(request->chandler) {
1912                 unregisterConditionHandler(request->chandler);
1913                 request->chandler = NULL;
1914             }
1915             unlockChunk(object, i);
1916             if(connection->te == TE_CHUNKED) {
1917                 httpSetTimeout(connection, clientTimeout);
1918                 do_stream(IO_WRITE | IO_CHUNKED | IO_END,
1919                           connection->fd, 0, NULL, 0,
1920                           httpServeObjectFinishHandler, connection);
1921             } else {
1922                 httpClientFinish(connection,
1923                                  !(object->length >= 0 &&
1924                                    connection->offset >= object->length));
1925             }
1926             return 1;
1927         } else {
1928             if(!request->chandler) {
1929                 request->chandler =
1930                     conditionWait(&object->condition,
1931                                   httpServeObjectHandler,
1932                                   sizeof(connection), &connection);
1933                 if(!request->chandler) {
1934                     do_log(L_ERROR, "Couldn't register condition handler\n");
1935                     goto fail;
1936                 }
1937             }
1938             if(!(object->flags & OBJECT_INPROGRESS)) {
1939                 if(object->flags & OBJECT_SUPERSEDED) {
1940                     goto fail;
1941                 }
1942                 if(REQUEST_SIDE(request)) goto fail;
1943                 rc = object->request(object, request->method,
1944                                      connection->offset, -1, request,
1945                                      object->request_closure);
1946                 if(rc <= 0) goto fail;
1947             }
1948             return 1;
1949         }
1950     } else {
1951         /* len > 0 */
1952         if(request->method != METHOD_HEAD)
1953             objectFillFromDisk(object, (i + 1) * CHUNK_SIZE, 1);
1954         if(request->chandler) {
1955             unregisterConditionHandler(request->chandler);
1956             request->chandler = NULL;
1957         }
1958         len2 = 0;
1959         if(j + len == CHUNK_SIZE && object->numchunks > i + 1) {
1960             len2 = object->chunks[i + 1].size;
1961             if(to >= 0)
1962                 len2 = MIN(len2, to - (i + 1) * CHUNK_SIZE);
1963         }
1964         /* Lock early -- httpServerRequest may get_chunk */
1965         if(len2 > 0)
1966             lockChunk(object, i + 1);
1967         if(object->length >= 0 &&
1968            connection->offset + len + len2 == object->length)
1969             end = 1;
1970         else
1971             end = 0;
1972         /* Prefetch */
1973         if(!(object->flags & OBJECT_INPROGRESS) && !REQUEST_SIDE(request)) {
1974             if(object->chunks[i].size < CHUNK_SIZE &&
1975                to >= 0 && connection->offset + len + 1 < to)
1976                 object->request(object, request->method,
1977                                 connection->offset + len, -1, request,
1978                                 object->request_closure);
1979             else if(i + 1 < object->numchunks &&
1980                     object->chunks[i + 1].size == 0 &&
1981                     to >= 0 && (i + 1) * CHUNK_SIZE + 1 < to)
1982                 object->request(object, request->method,
1983                                 (i + 1) * CHUNK_SIZE, -1, request,
1984                                 object->request_closure);
1985         }
1986         if(len2 == 0) {
1987             httpSetTimeout(connection, clientTimeout);
1988             do_log(D_CLIENT_DATA,
1989                    "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1990                    (unsigned long)connection, (unsigned long)object,
1991                    connection->offset, len);
1992             /* IO_NOTNOW in order to give other clients a chance to run. */
1993             do_stream(IO_WRITE | IO_NOTNOW |
1994                       (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
1995                       (end ? IO_END : 0),
1996                       connection->fd, 0,
1997                       object->chunks[i].data + j, len,
1998                       httpServeObjectStreamHandler, connection);
1999         } else {
2000             httpSetTimeout(connection, clientTimeout);
2001             do_log(D_CLIENT_DATA,
2002                    "Serving on 0x%lx for 0x%lx: offset %d len %d + %d\n",
2003                    (unsigned long)connection, (unsigned long)object,
2004                    connection->offset, len, len2);
2005             do_stream_2(IO_WRITE | IO_NOTNOW |
2006                         (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
2007                         (end ? IO_END : 0),
2008                         connection->fd, 0,
2009                         object->chunks[i].data + j, len,
2010                         object->chunks[i + 1].data, len2,
2011                         httpServeObjectStreamHandler2, connection);
2012         }
2013         return 1;
2014     }
2015
2016     abort();
2017
2018  fail:
2019     unlockChunk(object, i);
2020  fail_no_unlock:
2021     if(request->chandler)
2022         unregisterConditionHandler(request->chandler);
2023     request->chandler = NULL;
2024     httpClientFinish(connection, 1);
2025     return 1;
2026 }
2027
2028 static int
2029 httpServeChunkDelayed(TimeEventHandlerPtr event)
2030 {
2031     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
2032     httpServeChunk(connection);
2033     return 1;
2034 }
2035
2036 int
2037 delayedHttpServeChunk(HTTPConnectionPtr connection)
2038 {
2039     TimeEventHandlerPtr event;
2040     event = scheduleTimeEvent(-1, httpServeChunkDelayed,
2041                               sizeof(connection), &connection);
2042     if(!event) return -1;
2043     return 1;
2044 }
2045
2046 int
2047 httpServeObjectHandler(int status, ConditionHandlerPtr chandler)
2048 {
2049     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)chandler->data;
2050     HTTPRequestPtr request = connection->request;
2051     int rc;
2052
2053     unlockChunk(request->object, connection->offset / CHUNK_SIZE);
2054
2055     if((request->object->flags & OBJECT_ABORTED) || status < 0) {
2056         shutdown(connection->fd, 1);
2057         httpSetTimeout(connection, 10);
2058         /* httpServeChunk will take care of the error. */
2059     }
2060
2061     httpSetTimeout(connection, -1);
2062
2063     request->chandler = NULL;
2064     rc = delayedHttpServeChunk(connection);
2065     if(rc < 0) {
2066         do_log(L_ERROR, "Couldn't schedule serving.\n");
2067         abortObject(request->object, 503,
2068                     internAtom("Couldn't schedule serving"));
2069     }
2070     return 1;
2071 }
2072
2073 static int
2074 httpServeObjectStreamHandlerCommon(int kind, int status,
2075                                    FdEventHandlerPtr event,
2076                                    StreamRequestPtr srequest)
2077 {
2078     HTTPConnectionPtr connection = srequest->data;
2079     HTTPRequestPtr request = connection->request;
2080     int condition_result = httpCondition(request->object, request->condition);
2081     int i = connection->offset / CHUNK_SIZE;
2082
2083     assert(!request->chandler);
2084
2085     if(status == 0 && !streamRequestDone(srequest)) {
2086         httpSetTimeout(connection, clientTimeout);
2087         return 0;
2088     }
2089
2090     httpSetTimeout(connection, -1);
2091
2092     unlockChunk(request->object, i);
2093     if(kind == 2)
2094         unlockChunk(request->object, i + 1);
2095
2096     if(status) {
2097         if(status < 0) {
2098             do_log_error(status == -ECONNRESET ? D_IO : L_ERROR,
2099                          -status, "Couldn't write to client");
2100             if(status == -EIO || status == -ESHUTDOWN)
2101                 httpClientFinish(connection, 2);
2102             else
2103                 httpClientFinish(connection, 1);
2104         } else {
2105             do_log(D_IO, "Couldn't write to client: short write.\n");
2106             httpClientFinish(connection, 2);
2107         }
2108         return 1;
2109     }
2110
2111     if(srequest->operation & IO_CHUNKED) {
2112         assert(srequest->offset > 2);
2113         connection->offset += srequest->offset - 2;
2114     } else {
2115         connection->offset += srequest->offset;
2116     }
2117     request->flags &= ~REQUEST_REQUESTED;
2118
2119     if(request->object->flags & OBJECT_ABORTED) {
2120         httpClientFinish(connection, 1);
2121         return 1;
2122     }
2123
2124     if(connection->request->method == METHOD_HEAD ||
2125        condition_result == CONDITION_NOT_MODIFIED) {
2126         httpClientFinish(connection, 0);
2127         return 1;
2128     }
2129
2130     if(srequest->operation & IO_END)
2131         httpClientFinish(connection, 0);
2132     else {
2133         httpConnectionDestroyBuf(connection);
2134         httpServeChunk(connection);
2135     }
2136     return 1;
2137 }
2138
2139 int
2140 httpServeObjectStreamHandler(int status,
2141                              FdEventHandlerPtr event,
2142                              StreamRequestPtr srequest)
2143 {
2144     return httpServeObjectStreamHandlerCommon(1, status, event, srequest);
2145 }
2146
2147 int
2148 httpServeObjectStreamHandler2(int status,
2149                               FdEventHandlerPtr event,
2150                               StreamRequestPtr srequest)
2151 {
2152     return httpServeObjectStreamHandlerCommon(2, status, event, srequest);
2153 }