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) ? connection->reqlen : 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(rc > 0) {
 416             do_stream(IO_READ, connection->fd, connection->reqlen,
 417                       connection->reqbuf, bigBufferSize,
 418                       httpClientHandler, connection);
 419             return 1;
 420         }
 421         connection->reqlen = 0;
 422         httpConnectionDestroyReqbuf(connection);
 423         if(rc < 0) {
 424             do_log(L_ERROR, "Couldn't allocate big buffer.\n");
 425             httpClientNewError(connection, METHOD_UNKNOWN, 0, 400,
 426                                internAtom("Couldn't allocate big buffer"));
 427         } else {
 428             do_log(L_ERROR, "Couldn't find end of client's headers.\n");
 429             httpClientNewError(connection, METHOD_UNKNOWN, 0, 400,
 430                                internAtom("Couldn't find end of headers"));
 431         }
 432         return 1;
 433     }
 434     httpSetTimeout(connection, clientTimeout);
 435     return 0;
 436 }
 437
 438 int
 439 httpClientRawErrorHeaders(HTTPConnectionPtr connection,
 440                           int code, AtomPtr message,
 441                           int close, AtomPtr headers)
 442 {
 443     int fd = connection->fd;
 444     int n;
 445     char *url; int url_len;
 446     char *etag;
 447
 448     assert(connection->flags & CONN_WRITER);
 449     assert(code != 0);
 450
 451     if(close >= 0) {
 452         if(connection->request)
 453             close =
 454                 close || !(connection->request->flags & REQUEST_PERSISTENT);
 455         else
 456             close = 1;
 457     }
 458     if(connection->request && connection->request->object) {
 459         url = connection->request->object->key;
 460         url_len = connection->request->object->key_size;
 461         etag = connection->request->object->etag;
 462     } else {
 463         url = NULL;
 464         url_len = 0;
 465         etag = NULL;
 466     }
 467
 468     if(connection->buf == NULL) {
 469         connection->buf = get_chunk();
 470         if(connection->buf == NULL) {
 471             httpClientFinish(connection, 1);
 472             return 1;
 473         }
 474     }
 475
 476     n = httpWriteErrorHeaders(connection->buf, CHUNK_SIZE, 0,
 477                               connection->request &&
 478                               connection->request->method != METHOD_HEAD,
 479                               code, message, close > 0, headers,
 480                               url, url_len, etag);
 481     if(n <= 0) {
 482         shutdown(connection->fd, 1);
 483         if(close >= 0)
 484             httpClientFinish(connection, 1);
 485         return 1;
 486     }
 487
 488     httpSetTimeout(connection, clientTimeout);
 489     do_stream(IO_WRITE, fd, 0, connection->buf, n,
 490               close > 0 ? httpErrorStreamHandler :
 491               close == 0 ? httpErrorNocloseStreamHandler :
 492               httpErrorNofinishStreamHandler,
 493               connection);
 494
 495     return 1;
 496 }
 497
 498 int
 499 httpClientRawError(HTTPConnectionPtr connection, int code, AtomPtr message,
 500                    int close)
 501 {
 502     return httpClientRawErrorHeaders(connection, code, message, close, NULL);
 503 }
 504
 505 int
 506 httpClientNoticeErrorHeaders(HTTPRequestPtr request, int code, AtomPtr message,
 507                              AtomPtr headers)
 508 {
 509     if(request->error_message)
 510         releaseAtom(request->error_message);
 511     if(request->error_headers)
 512         releaseAtom(request->error_headers);
 513     request->error_code = code;
 514     request->error_message = message;
 515     request->error_headers = headers;
 516     httpClientNoticeRequest(request, 0);
 517     return 1;
 518 }
 519
 520 int
 521 httpClientNoticeError(HTTPRequestPtr request, int code, AtomPtr message)
 522 {
 523     return httpClientNoticeErrorHeaders(request, code, message, NULL);
 524 }
 525
 526 int
 527 httpClientError(HTTPRequestPtr request, int code, AtomPtr message)
 528 {
 529     if(request->error_message)
 530         releaseAtom(request->error_message);
 531     request->error_code = code;
 532     request->error_message = message;
 533     if(request->chandler) {
 534         abortConditionHandler(request->chandler);
 535         request->chandler = NULL;
 536     } else if(request->object)
 537         notifyObject(request->object);
 538     return 1;
 539 }
 540
 541 /* This may be called from object handlers. */
 542 int
 543 httpClientLeanError(HTTPRequestPtr request, int code, AtomPtr message)
 544 {
 545     if(request->error_message)
 546         releaseAtom(request->error_message);
 547     request->error_code = code;
 548     request->error_message = message;
 549     return 1;
 550 }
 551
 552
 553 int
 554 httpClientNewError(HTTPConnectionPtr connection, int method, int persist,
 555                    int code, AtomPtr message)
 556 {
 557     HTTPRequestPtr request;
 558     request = httpMakeRequest();
 559     if(request == NULL) {
 560         do_log(L_ERROR, "Couldn't allocate error request.\n");
 561         httpClientFinish(connection, 1);
 562         return 1;
 563     }
 564     request->method = method;
 565     if(persist)
 566         request->flags |= REQUEST_PERSISTENT;
 567     else
 568         request->flags &= ~REQUEST_PERSISTENT;
 569     request->error_code = code;
 570     request->error_message = message;
 571
 572     httpQueueRequest(connection, request);
 573     httpClientNoticeRequest(request, 0);
 574     return 1;
 575 }
 576
 577 int
 578 httpErrorStreamHandler(int status,
 579                        FdEventHandlerPtr event,
 580                        StreamRequestPtr srequest)
 581 {
 582     HTTPConnectionPtr connection = srequest->data;
 583
 584     if(status == 0 && !streamRequestDone(srequest))
 585         return 0;
 586
 587     httpClientFinish(connection, 1);
 588     return 1;
 589 }
 590
 591 int
 592 httpErrorNocloseStreamHandler(int status,
 593                               FdEventHandlerPtr event,
 594                               StreamRequestPtr srequest)
 595 {
 596     HTTPConnectionPtr connection = srequest->data;
 597
 598     if(status == 0 && !streamRequestDone(srequest))
 599         return 0;
 600
 601     httpClientFinish(connection, 0);
 602     return 1;
 603 }
 604
 605 int
 606 httpErrorNofinishStreamHandler(int status,
 607                                FdEventHandlerPtr event,
 608                                StreamRequestPtr srequest)
 609 {
 610     if(status == 0 && !streamRequestDone(srequest))
 611         return 0;
 612
 613     return 1;
 614 }
 615
 616 int
 617 httpClientHandlerHeaders(FdEventHandlerPtr event, StreamRequestPtr srequest,
 618                          HTTPConnectionPtr connection)
 619 {
 620     HTTPRequestPtr request;
 621     int rc;
 622     int method, version;
 623     AtomPtr url = NULL;
 624     int start;
 625     int code;
 626     AtomPtr message;
 627
 628     start = 0;
 629     /* Work around clients working around NCSA lossage. */
 630     if(connection->reqbuf[0] == '\n')
 631         start = 1;
 632     else if(connection->reqbuf[0] == '\r' && connection->reqbuf[1] == '\n')
 633         start = 2;
 634
 635     httpSetTimeout(connection, -1);
 636     rc = httpParseClientFirstLine(connection->reqbuf, start,
 637                                   &method, &url, &version);
 638     if(rc <= 0) {
 639         do_log(L_ERROR, "Couldn't parse client's request line\n");
 640         code = 400;
 641         message =  internAtom("Error in request line");
 642         goto fail;
 643     }
 644
 645     do_log(D_CLIENT_REQ, "Client request: ");
 646     do_log_n(D_CLIENT_REQ, connection->reqbuf, rc - 1);
 647     do_log(D_CLIENT_REQ, "\n");
 648
 649     if(version != HTTP_10 && version != HTTP_11) {
 650         do_log(L_ERROR, "Unknown client HTTP version\n");
 651         code = 400;
 652         message = internAtom("Error in first request line");
 653         goto fail;
 654     }
 655
 656     if(method == METHOD_UNKNOWN) {
 657         code = 501;
 658         message =  internAtom("Method not implemented");
 659         goto fail;
 660     }
 661
 662     request = httpMakeRequest();
 663     if(request == NULL) {
 664         do_log(L_ERROR, "Couldn't allocate client request.\n");
 665         code = 500;
 666         message = internAtom("Couldn't allocate client request");
 667         goto fail;
 668     }
 669
 670     if(connection->version != HTTP_UNKNOWN && version != connection->version) {
 671         do_log(L_WARN, "Client version changed!\n");
 672     }
 673
 674     connection->version = version;
 675     request->flags = REQUEST_PERSISTENT;
 676     request->method = method;
 677     request->cache_control = no_cache_control;
 678     httpQueueRequest(connection, request);
 679     connection->reqbegin = rc;
 680     return httpClientRequest(request, url);
 681
 682  fail:
 683     if(url) releaseAtom(url);
 684     shutdown(connection->fd, 0);
 685     connection->reqlen = 0;
 686     connection->reqbegin = 0;
 687     httpConnectionDestroyReqbuf(connection);
 688     connection->flags &= ~CONN_READER;
 689     httpClientNewError(connection, METHOD_UNKNOWN, 0, code, message);
 690     return 1;
 691
 692 }
 693
 694 static int
 695 httpClientRequestDelayed(TimeEventHandlerPtr event)
 696 {
 697     HTTPRequestPtr request = *(HTTPRequestPtr*)event->data;
 698     AtomPtr url;
 699     url = internAtomN(request->object->key, request->object->key_size);
 700     if(url == NULL) {
 701         do_log(L_ERROR, "Couldn't allocate url.\n");
 702         abortObject(request->object, 503, internAtom("Couldn't allocate url"));
 703         return 1;
 704     }
 705     httpClientRequest(request, url);
 706     return 1;
 707 }
 708
 709 int
 710 delayedHttpClientRequest(HTTPRequestPtr request)
 711 {
 712     TimeEventHandlerPtr event;
 713     event = scheduleTimeEvent(-1, httpClientRequestDelayed,
 714                               sizeof(request), &request);
 715     if(!event)
 716         return -1;
 717     return 1;
 718 }
 719
 720 int
 721 httpClientRequest(HTTPRequestPtr request, AtomPtr url)
 722 {
 723     HTTPConnectionPtr connection = request->connection;
 724     int i, rc;
 725     int body_len, body_te;
 726     AtomPtr headers;
 727     CacheControlRec cache_control;
 728     AtomPtr via, expect, auth;
 729     HTTPConditionPtr condition;
 730     HTTPRangeRec range;
 731
 732     assert(!request->chandler);
 733     assert(connection->reqbuf);
 734
 735     i = httpParseHeaders(1, url,
 736                          connection->reqbuf, connection->reqbegin, request,
 737                          &headers, &body_len,
 738                          &cache_control, &condition, &body_te,
 739                          NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 740                          &expect, &range, NULL, NULL, &via, &auth);
 741     if(i < 0) {
 742         releaseAtom(url);
 743         do_log(L_ERROR, "Couldn't parse client headers.\n");
 744         shutdown(connection->fd, 0);
 745         request->flags &= ~REQUEST_PERSISTENT;
 746         connection->flags &= ~CONN_READER;
 747         httpClientNoticeError(request, 503,
 748                               internAtom("Couldn't parse client headers"));
 749         return 1;
 750     }
 751
 752     connection->reqbegin = i;
 753
 754     if(body_len < 0) {
 755         if(request->method == METHOD_GET || request->method == METHOD_HEAD)
 756             body_len = 0;
 757     }
 758     connection->bodylen = body_len;
 759     connection->reqte = body_te;
 760
 761     if(authRealm) {
 762         AtomPtr message = NULL;
 763         AtomPtr challenge = NULL;
 764         int code = checkClientAuth(auth, url, &message, &challenge);
 765         if(auth) {
 766             releaseAtom(auth);
 767             auth = NULL;
 768         }
 769         if(expect) {
 770             releaseAtom(expect);
 771             expect = NULL;
 772         }
 773         if(code) {
 774             request->flags |= REQUEST_FORCE_ERROR;
 775             httpClientDiscardBody(connection);
 776             httpClientNoticeErrorHeaders(request, code, message, challenge);
 777             return 1;
 778         }
 779     }
 780
 781     if(auth) {
 782         releaseAtom(auth);
 783         auth = NULL;
 784     }
 785
 786     if(expect) {
 787         if(expect == atom100Continue && REQUEST_SIDE(request)) {
 788             request->flags |= REQUEST_WAIT_CONTINUE;
 789         } else {
 790             httpClientDiscardBody(connection);
 791             httpClientNoticeError(request, 417,
 792                                   internAtom("Expectation failed"));
 793             releaseAtom(expect);
 794             return 1;
 795         }
 796         releaseAtom(expect);
 797     }
 798
 799     request->from = range.from < 0 ? 0 : range.from;
 800     request->to = range.to;
 801     request->cache_control = cache_control;
 802     request->via = via;
 803     request->headers = headers;
 804     request->condition = condition;
 805     request->object = NULL;
 806
 807     if(connection->serviced > 500)
 808         request->flags &= ~REQUEST_PERSISTENT;
 809
 810     if(request->method == METHOD_CONNECT) {
 811         if(connection->flags & CONN_WRITER) {
 812             /* For now */
 813             httpClientDiscardBody(connection);
 814             httpClientNoticeError(request, 500,
 815                                   internAtom("Pipelined CONNECT "
 816                                              "not supported"));
 817             return 1;
 818         }
 819         if(connection->flags & CONN_BIGREQBUF) {
 820             /* For now */
 821             httpClientDiscardBody(connection);
 822             httpClientNoticeError(request, 500,
 823                                   internAtom("CONNECT over big buffer "
 824                                              "not supported"));
 825             return 1;
 826         }
 827         connection->flags &= ~CONN_READER;
 828         do_tunnel(connection->fd, connection->reqbuf,
 829                   connection->reqbegin, connection->reqlen, url);
 830         connection->fd = -1;
 831         connection->reqbuf = NULL;
 832         connection->reqlen = 0;
 833         connection->reqbegin = 0;
 834         httpClientFinish(connection, 2);
 835         return 1;
 836     }
 837
 838     rc = urlForbidden(url, httpClientRequestContinue, request);
 839     if(rc < 0) {
 840         do_log(L_ERROR, "Couldn't schedule httpClientRequestContinue.\n");
 841         httpClientDiscardBody(connection);
 842         httpClientNoticeError(request, 500,
 843                               internAtom("Couldn't schedule "
 844                                          "httpClientRequestContinue"));
 845         return 1;
 846     }
 847     return 1;
 848 }
 849
 850 int
 851 httpClientRequestContinue(int forbidden_code, AtomPtr url,
 852                           AtomPtr forbidden_message, AtomPtr forbidden_headers,
 853                           void *closure)
 854 {
 855     HTTPRequestPtr request = (HTTPRequestPtr)closure;
 856     HTTPConnectionPtr connection = request->connection;
 857     RequestFunction requestfn;
 858     ObjectPtr object = NULL;
 859
 860     if(forbidden_code < 0) {
 861         releaseAtom(url);
 862         httpClientDiscardBody(connection);
 863         httpClientNoticeError(request, 500,
 864                               internAtomError(-forbidden_code,
 865                                               "Couldn't test for forbidden "
 866                                               "URL"));
 867         return 1;
 868     }
 869
 870     if(forbidden_code) {
 871         releaseAtom(url);
 872         httpClientDiscardBody(connection);
 873         httpClientNoticeErrorHeaders(request,
 874                                      forbidden_code, forbidden_message,
 875                                      forbidden_headers);
 876         return 1;
 877     }
 878
 879     requestfn =
 880         urlIsLocal(url->string, url->length) ?
 881         httpLocalRequest :
 882         httpServerRequest;
 883
 884     if(request->method == METHOD_POST || request->method == METHOD_PUT) {
 885         do {
 886             object = findObject(OBJECT_HTTP, url->string, url->length);
 887             if(object) {
 888                 privatiseObject(object, 0);
 889                 releaseObject(object);
 890             }
 891         } while(object);
 892         request->object = makeObject(OBJECT_HTTP, url->string, url->length,
 893                                      0, 0, requestfn, NULL);
 894         if(request->object == NULL) {
 895             httpClientDiscardBody(connection);
 896             httpClientNoticeError(request, 503,
 897                                   internAtom("Couldn't allocate object"));
 898             return 1;
 899         }
 900         if(requestfn == httpLocalRequest)
 901             request->object->flags |= OBJECT_LOCAL;
 902         return httpClientSideRequest(request);
 903     }
 904
 905     if(request->cache_control.flags & CACHE_AUTHORIZATION) {
 906         do {
 907             object = makeObject(OBJECT_HTTP, url->string, url->length, 0, 0,
 908                                 requestfn, NULL);
 909             if(object && object->flags != OBJECT_INITIAL) {
 910                 if(!(object->cache_control & CACHE_PUBLIC)) {
 911                     privatiseObject(object, 0);
 912                     releaseObject(object);
 913                     object = NULL;
 914                 } else
 915                     break;
 916             }
 917         } while(object == NULL);
 918         if(object)
 919             object->flags |= OBJECT_LINEAR;
 920     } else {
 921         object = findObject(OBJECT_HTTP, url->string, url->length);
 922         if(!object)
 923             object = makeObject(OBJECT_HTTP, url->string, url->length, 1, 1,
 924                                 requestfn, NULL);
 925     }
 926     releaseAtom(url);
 927     url = NULL;
 928
 929     if(!object) {
 930         do_log(L_ERROR, "Couldn't allocate object.\n");
 931         httpClientDiscardBody(connection);
 932         httpClientNoticeError(request, 503,
 933                               internAtom("Couldn't allocate object"));
 934         return 1;
 935     }
 936
 937     if(object->request == httpLocalRequest) {
 938         object->flags |= OBJECT_LOCAL;
 939     } else {
 940         if(disableProxy) {
 941             httpClientDiscardBody(connection);
 942             httpClientNoticeError(request, 403,
 943                                   internAtom("Proxying disabled"));
 944             releaseObject(object);
 945             return 1;
 946         }
 947
 948         if(!checkVia(proxyName, request->via)) {
 949             httpClientDiscardBody(connection);
 950             httpClientNoticeError(request, 504,
 951                                   internAtom("Proxy loop detected"));
 952             releaseObject(object);
 953             return 1;
 954         }
 955     }
 956
 957     request->object = object;
 958
 959     httpClientDiscardBody(connection);
 960     httpClientNoticeRequest(request, 0);
 961     return 1;
 962 }
 963
 964 static int httpClientDelayed(TimeEventHandlerPtr handler);
 965
 966 int
 967 httpClientDiscardBody(HTTPConnectionPtr connection)
 968 {
 969     TimeEventHandlerPtr handler;
 970
 971     assert(connection->reqoffset == 0);
 972     assert(connection->flags & CONN_READER);
 973
 974     if(connection->reqte != TE_IDENTITY)
 975         goto fail;
 976
 977     if(connection->bodylen < 0)
 978         goto fail;
 979
 980     if(connection->bodylen + connection->reqbegin < connection->reqlen) {
 981         connection->reqbegin += connection->bodylen;
 982         connection->bodylen = 0;
 983     } else {
 984         connection->bodylen -= connection->reqlen - connection->reqbegin;
 985         connection->reqbegin = 0;
 986         connection->reqlen = 0;
 987         httpConnectionDestroyReqbuf(connection);
 988     }
 989     connection->reqte = TE_UNKNOWN;
 990
 991     if(connection->bodylen > 0) {
 992         httpSetTimeout(connection, clientTimeout);
 993         do_stream_buf(IO_READ | IO_NOTNOW,
 994                       connection->fd, connection->reqlen,
 995                       &connection->reqbuf, CHUNK_SIZE,
 996                       httpClientDiscardHandler, connection);
 997         return 1;
 998     }
 999
1000     if(connection->reqlen > connection->reqbegin) {
1001         memmove(connection->reqbuf, connection->reqbuf + connection->reqbegin,
1002                 connection->reqlen - connection->reqbegin);
1003         connection->reqlen -= connection->reqbegin;
1004         connection->reqbegin = 0;
1005     } else {
1006         connection->reqlen = 0;
1007         connection->reqbegin = 0;
1008     }
1009
1010     httpSetTimeout(connection, clientTimeout);
1011     /* We need to delay in order to make sure the previous request
1012        gets queued on the server side.  IO_NOTNOW isn't strong enough
1013        for that due to IO_IMMEDIATE. */
1014     handler = scheduleTimeEvent(-1, httpClientDelayed,
1015                                 sizeof(connection), &connection);
1016     if(handler == NULL) {
1017         do_log(L_ERROR, "Couldn't schedule reading from client.");
1018         goto fail;
1019     }
1020     return 1;
1021
1022  fail:
1023     connection->reqlen = 0;
1024     connection->reqbegin = 0;
1025     connection->bodylen = 0;
1026     connection->reqte = TE_UNKNOWN;
1027     shutdown(connection->fd, 2);
1028     handler = scheduleTimeEvent(-1, httpClientDelayed,
1029                                 sizeof(connection), &connection);
1030     if(handler == NULL) {
1031         do_log(L_ERROR, "Couldn't schedule reading from client.");
1032         connection->flags &= ~CONN_READER;
1033     }
1034     return 1;
1035 }
1036
1037 static int
1038 httpClientDelayed(TimeEventHandlerPtr event)
1039 {
1040      HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1041
1042      /* IO_NOTNOW is unfortunate, but needed to avoid starvation if a
1043         client is pipelining a lot of requests. */
1044      if(connection->reqlen > 0) {
1045          int bufsize;
1046          if((connection->flags & CONN_BIGREQBUF) &&
1047             connection->reqlen < CHUNK_SIZE)
1048              httpConnectionUnbigifyReqbuf(connection);
1049          /* Don't read new requests if buffer is big. */
1050          bufsize = (connection->flags & CONN_BIGREQBUF) ?
1051              connection->reqlen : CHUNK_SIZE;
1052          do_stream(IO_READ | IO_IMMEDIATE | IO_NOTNOW,
1053                    connection->fd, connection->reqlen,
1054                    connection->reqbuf, bufsize,
1055                    httpClientHandler, connection);
1056      } else {
1057          httpConnectionDestroyReqbuf(connection);
1058          do_stream_buf(IO_READ | IO_NOTNOW,
1059                        connection->fd, 0,
1060                        &connection->reqbuf, CHUNK_SIZE,
1061                        httpClientHandler, connection);
1062      }
1063      return 1;
1064 }
1065
1066 int
1067 httpClientDiscardHandler(int status,
1068                          FdEventHandlerPtr event, StreamRequestPtr request)
1069 {
1070     HTTPConnectionPtr connection = request->data;
1071
1072     assert(connection->flags & CONN_READER);
1073     if(status) {
1074         if(status < 0 && status != -EPIPE)
1075             do_log_error(L_ERROR, -status, "Couldn't read from client");
1076         connection->bodylen = -1;
1077         return httpClientDiscardBody(connection);
1078     }
1079
1080     assert(request->offset > connection->reqlen);
1081     connection->reqlen = request->offset;
1082
1083     httpClientDiscardBody(connection);
1084     return 1;
1085 }
1086
1087 int
1088 httpClientNoticeRequest(HTTPRequestPtr request, int novalidate)
1089 {
1090     HTTPConnectionPtr connection = request->connection;
1091     ObjectPtr object = request->object;
1092     int serveNow = (request == connection->request);
1093     int validate = 0;
1094     int conditional = 0;
1095     int local, haveData;
1096     int rc;
1097
1098     assert(!request->chandler);
1099
1100     if(request->error_code) {
1101         if((request->flags & REQUEST_FORCE_ERROR) || REQUEST_SIDE(request) ||
1102            request->object == NULL ||
1103            (request->object->flags & OBJECT_LOCAL) ||
1104            (request->object->flags & OBJECT_ABORTED) ||
1105            (relaxTransparency < 1 && !proxyOffline)) {
1106             if(serveNow) {
1107                 connection->flags |= CONN_WRITER;
1108                 return httpClientRawErrorHeaders(connection,
1109                                                  request->error_code,
1110                                                  retainAtom(request->
1111                                                             error_message),
1112                                                  0, request->error_headers);
1113             } else {
1114                 return 1;
1115             }
1116         }
1117     }
1118
1119     if(REQUEST_SIDE(request)) {
1120         assert(!(request->flags & REQUEST_REQUESTED));
1121         if(serveNow) {
1122             assert(!request->chandler);
1123             request->chandler =
1124                 conditionWait(&request->object->condition,
1125                               httpClientGetHandler,
1126                               sizeof(request), &request);
1127             if(request->chandler == NULL) {
1128                 do_log(L_ERROR, "Couldn't register condition handler.\n");
1129                 connection->flags |= CONN_WRITER;
1130                 httpClientRawError(connection, 500,
1131                                    internAtom("Couldn't register "
1132                                               "condition handler"),
1133                                    0);
1134                 return 1;
1135             }
1136             connection->flags |= CONN_WRITER;
1137             rc = object->request(request->object,
1138                                  request->method,
1139                                  request->from, request->to,
1140                                  request,
1141                                  request->object->request_closure);
1142         }
1143         return 1;
1144     }
1145
1146     local = urlIsLocal(object->key, object->key_size);
1147     objectFillFromDisk(object, request->from,
1148                        request->method == METHOD_HEAD ? 0 : 1);
1149
1150     if(request->condition && request->condition->ifrange) {
1151         if(!object->etag ||
1152            strcmp(object->etag, request->condition->ifrange) != 0) {
1153             request->from = 0;
1154             request->to = -1;
1155         }
1156     }
1157
1158     if(object->flags & OBJECT_DYNAMIC) {
1159         request->from = 0;
1160         request->to = -1;
1161     }
1162
1163     if(request->method == METHOD_HEAD)
1164         haveData = !(request->object->flags & OBJECT_INITIAL);
1165     else
1166         haveData =
1167             (request->object->length >= 0 &&
1168              request->object->length <= request->from) ||
1169             (objectHoleSize(request->object, request->from) == 0);
1170
1171     if(request->flags & REQUEST_REQUESTED)
1172         validate = 0;
1173     else if(novalidate || (!local && proxyOffline))
1174         validate = 0;
1175     else if(local)
1176         validate =
1177             objectMustRevalidate(request->object, &request->cache_control);
1178     else if(request->cache_control.flags & CACHE_ONLY_IF_CACHED)
1179         validate = 0;
1180     else if((request->object->flags & OBJECT_FAILED) &&
1181             !(object->flags & OBJECT_INPROGRESS) &&
1182             !relaxTransparency)
1183         validate = 1;
1184     else if(request->method != METHOD_HEAD &&
1185             !objectHasData(object, request->from, request->to) &&
1186             !(object->flags & OBJECT_INPROGRESS))
1187         validate = 1;
1188     else if(objectMustRevalidate((relaxTransparency <= 1 ?
1189                                   request->object : NULL),
1190                                  &request->cache_control))
1191         validate = 1;
1192     else
1193         validate = 0;
1194
1195     if(request->cache_control.flags & CACHE_ONLY_IF_CACHED) {
1196         validate = 0;
1197         if(!haveData) {
1198             if(serveNow) {
1199                 connection->flags |= CONN_WRITER;
1200                 return httpClientRawError(connection, 504,
1201                                           internAtom("Object not in cache"),
1202                                           0);
1203             } else
1204                 return 1;
1205         }
1206     }
1207
1208     if(!(request->object->flags & OBJECT_VALIDATING) &&
1209        ((!validate && haveData) ||
1210         (request->object->flags & OBJECT_FAILED))) {
1211         if(serveNow) {
1212             connection->flags |= CONN_WRITER;
1213             lockChunk(request->object, request->from / CHUNK_SIZE);
1214             return httpServeObject(connection);
1215         } else {
1216             return 1;
1217         }
1218     }
1219
1220     if((request->flags & REQUEST_REQUESTED) &&
1221        !(request->object->flags & OBJECT_INPROGRESS)) {
1222         /* This can happen either because the server side ran out of
1223            memory, or because it is using HEAD validation.  We mark
1224            the object to be fetched again. */
1225         request->flags &= ~REQUEST_REQUESTED;
1226     }
1227
1228     if(serveNow) {
1229         connection->flags |= CONN_WRITER;
1230         if(!local && proxyOffline)
1231             return httpClientRawError(connection, 502,
1232                                       internAtom("Disconnected operation "
1233                                                  "and object not in cache"),
1234                                       0);
1235         request->chandler =
1236             conditionWait(&request->object->condition, httpClientGetHandler,
1237                           sizeof(request), &request);
1238         if(request->chandler == NULL) {
1239             do_log(L_ERROR, "Couldn't register condition handler.\n");
1240             return httpClientRawError(connection, 503,
1241                                       internAtom("Couldn't register "
1242                                                  "condition handler"), 0);
1243         }
1244     }
1245
1246     if(request->object->flags & OBJECT_VALIDATING)
1247         return 1;
1248
1249     conditional = (haveData && request->method == METHOD_GET);
1250     if(!mindlesslyCacheVary && (request->object->cache_control & CACHE_VARY))
1251         conditional = conditional && (request->object->etag != NULL);
1252
1253     conditional =
1254         conditional && !(request->object->cache_control & CACHE_MISMATCH);
1255
1256     request->object->flags |= OBJECT_VALIDATING;
1257     rc = request->object->request(request->object,
1258                                   conditional ? METHOD_CONDITIONAL_GET :
1259                                   request->method,
1260                                   request->from, request->to, request,
1261                                   request->object->request_closure);
1262     if(rc < 0) {
1263         if(request->chandler)
1264             unregisterConditionHandler(request->chandler);
1265         request->chandler = NULL;
1266         request->object->flags &= ~OBJECT_VALIDATING;
1267         request->object->flags |= OBJECT_FAILED;
1268         if(request->error_message)
1269             releaseAtom(request->error_message);
1270         request->error_code = 503;
1271         request->error_message = internAtom("Couldn't schedule get");
1272     }
1273     return 1;
1274 }
1275
1276 static int
1277 httpClientNoticeRequestDelayed(TimeEventHandlerPtr event)
1278 {
1279     HTTPRequestPtr request = *(HTTPRequestPtr*)event->data;
1280     httpClientNoticeRequest(request, 0);
1281     return 1;
1282 }
1283
1284 int
1285 delayedHttpClientNoticeRequest(HTTPRequestPtr request)
1286 {
1287     TimeEventHandlerPtr event;
1288     event = scheduleTimeEvent(-1, httpClientNoticeRequestDelayed,
1289                               sizeof(request), &request);
1290     if(!event)
1291         return -1;
1292     return 1;
1293 }
1294
1295 int
1296 httpClientContinueDelayed(TimeEventHandlerPtr event)
1297 {
1298     static char httpContinue[] = "HTTP/1.1 100 Continue\r\n\r\n";
1299     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1300
1301     do_stream(IO_WRITE, connection->fd, 0, httpContinue, 25,
1302               httpErrorNofinishStreamHandler, connection);
1303     return 1;
1304 }
1305
1306 int
1307 delayedHttpClientContinue(HTTPConnectionPtr connection)
1308 {
1309     TimeEventHandlerPtr event;
1310     event = scheduleTimeEvent(-1, httpClientContinueDelayed,
1311                               sizeof(connection), &connection);
1312     if(!event)
1313         return -1;
1314     return 1;
1315 }
1316
1317 int
1318 httpClientGetHandler(int status, ConditionHandlerPtr chandler)
1319 {
1320     HTTPRequestPtr request = *(HTTPRequestPtr*)chandler->data;
1321     HTTPConnectionPtr connection = request->connection;
1322     ObjectPtr object = request->object;
1323     int rc;
1324
1325     assert(request == connection->request);
1326
1327     if(request->request) {
1328         assert(request->object->flags & OBJECT_INPROGRESS);
1329         assert(!request->request->object ||
1330                request->request->object == request->object);
1331     }
1332
1333     if(status < 0) {
1334         object->flags &= ~OBJECT_VALIDATING; /* for now */
1335         if(request->request && request->request->request == request)
1336             httpServerClientReset(request->request);
1337         lockChunk(object, request->from / CHUNK_SIZE);
1338         request->chandler = NULL;
1339         rc = delayedHttpServeObject(connection);
1340         if(rc < 0) {
1341             unlockChunk(object, request->from / CHUNK_SIZE);
1342             do_log(L_ERROR, "Couldn't schedule serving.\n");
1343             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1344         }
1345         return 1;
1346     }
1347
1348     if(object->flags & OBJECT_VALIDATING)
1349         return 0;
1350
1351     if(request->error_code) {
1352         lockChunk(object, request->from / CHUNK_SIZE);
1353         request->chandler = NULL;
1354         rc = delayedHttpServeObject(connection);
1355         if(rc < 0) {
1356             unlockChunk(object, request->from / CHUNK_SIZE);
1357             do_log(L_ERROR, "Couldn't schedule serving.\n");
1358             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1359         }
1360         return 1;
1361     }
1362
1363     if(request->flags & REQUEST_WAIT_CONTINUE) {
1364         if(request->request &&
1365            !(request->request->flags & REQUEST_WAIT_CONTINUE)) {
1366             request->flags &= ~REQUEST_WAIT_CONTINUE;
1367             delayedHttpClientContinue(connection);
1368         }
1369         return 0;
1370     }
1371
1372     /* See httpServerHandlerHeaders */
1373     if((object->flags & OBJECT_SUPERSEDED) &&
1374        request->request && request->request->can_mutate) {
1375         ObjectPtr new_object = retainObject(request->request->can_mutate);
1376         if(object->requestor == request) {
1377             if(new_object->requestor == NULL)
1378                 new_object->requestor = request;
1379             object->requestor = NULL;
1380         }
1381         request->chandler = NULL;
1382         releaseObject(object);
1383         request->object = new_object;
1384         request->request->object = new_object;
1385         /* We're handling the wrong object now.  It's simpler to
1386            rebuild the whole data structure from scratch rather than
1387            trying to compensate. */
1388         rc = delayedHttpClientNoticeRequest(request);
1389         if(rc < 0) {
1390             do_log(L_ERROR, "Couldn't schedule noticing of request.");
1391             abortObject(object, 500,
1392                         internAtom("Couldn't schedule "
1393                                    "noticing of request"));
1394             /* We're probably out of memory.  What can we do? */
1395             shutdown(connection->fd, 1);
1396         }
1397         return 1;
1398     }
1399
1400     if(object->requestor != request && !(object->flags & OBJECT_ABORTED)) {
1401         /* Make sure we don't serve an object that is stale for us
1402            unless we're the requestor. */
1403         if((object->flags & (OBJECT_LINEAR | OBJECT_MUTATING)) ||
1404            objectMustRevalidate(object, &request->cache_control)) {
1405            if(object->flags & OBJECT_INPROGRESS)
1406                return 0;
1407            rc = delayedHttpClientNoticeRequest(request);
1408            if(rc < 0) {
1409                do_log(L_ERROR, "Couldn't schedule noticing of request.");
1410                abortObject(object, 500,
1411                            internAtom("Couldn't schedule "
1412                                       "noticing of request"));
1413            } else {
1414                request->chandler = NULL;
1415                return 1;
1416            }
1417         }
1418     }
1419
1420     if(object->flags & (OBJECT_INITIAL | OBJECT_VALIDATING)) {
1421         if(object->flags & (OBJECT_INPROGRESS | OBJECT_VALIDATING)) {
1422             return 0;
1423         } else if(object->flags & OBJECT_FAILED) {
1424             if(request->error_code)
1425                 abortObject(object,
1426                             request->error_code,
1427                             retainAtom(request->error_message));
1428             else {
1429                 abortObject(object, 500,
1430                             internAtom("Error message lost in transit"));
1431             }
1432         } else {
1433             /* The request was pruned by httpServerDiscardRequests */
1434             if(chandler == request->chandler) {
1435                 int rc;
1436                 request->chandler = NULL;
1437                 rc = delayedHttpClientNoticeRequest(request);
1438                 if(rc < 0)
1439                     abortObject(object, 500,
1440                                 internAtom("Couldn't allocate "
1441                                            "delayed notice request"));
1442                 else
1443                     return 1;
1444             } else {
1445                 abortObject(object, 500,
1446                             internAtom("Wrong request pruned -- "
1447                                        "this shouldn't happen"));
1448             }
1449         }
1450     }
1451
1452     if(request->object->flags & OBJECT_DYNAMIC) {
1453         if(objectHoleSize(request->object, 0) == 0) {
1454             request->from = 0;
1455             request->to = -1;
1456         } else {
1457             /* We really should request again if that is not the case */
1458         }
1459     }
1460
1461     lockChunk(object, request->from / CHUNK_SIZE);
1462     request->chandler = NULL;
1463     rc = delayedHttpServeObject(connection);
1464     if(rc < 0) {
1465         unlockChunk(object, request->from / CHUNK_SIZE);
1466         do_log(L_ERROR, "Couldn't schedule serving.\n");
1467         abortObject(object, 503, internAtom("Couldn't schedule serving"));
1468     }
1469     return 1;
1470 }
1471
1472 int
1473 httpClientSideRequest(HTTPRequestPtr request)
1474 {
1475     HTTPConnectionPtr connection = request->connection;
1476
1477     if(request->from < 0 || request->to >= 0) {
1478         httpClientNoticeError(request, 501,
1479                               internAtom("Partial requests not implemented"));
1480         httpClientDiscardBody(connection);
1481         return 1;
1482     }
1483     if(connection->reqte != TE_IDENTITY) {
1484         httpClientNoticeError(request, 501,
1485                               internAtom("Chunked requests not implemented"));
1486         httpClientDiscardBody(connection);
1487         return 1;
1488     }
1489     if(connection->bodylen < 0) {
1490         httpClientNoticeError(request, 502,
1491                               internAtom("POST or PUT without "
1492                                          "Content-Length"));
1493         httpClientDiscardBody(connection);
1494         return 1;
1495     }
1496     if(connection->reqlen < 0) {
1497         httpClientNoticeError(request, 502,
1498                               internAtom("Incomplete POST or PUT"));
1499         httpClientDiscardBody(connection);
1500         return 1;
1501     }
1502
1503     return httpClientNoticeRequest(request, 0);
1504 }
1505
1506 int
1507 httpClientSideHandler(int status,
1508                       FdEventHandlerPtr event,
1509                       StreamRequestPtr srequest)
1510 {
1511     HTTPConnectionPtr connection = srequest->data;
1512     HTTPRequestPtr request = connection->request;
1513     HTTPRequestPtr requestee;
1514     HTTPConnectionPtr server;
1515     int push;
1516     int code;
1517     AtomPtr message = NULL;
1518
1519     assert(connection->flags & CONN_SIDE_READER);
1520
1521     if((request->object->flags & OBJECT_ABORTED) ||
1522        !(request->object->flags & OBJECT_INPROGRESS)) {
1523         code = request->object->code;
1524         message = retainAtom(request->object->message);
1525         goto fail;
1526     }
1527
1528     if(status < 0) {
1529         do_log_error(L_ERROR, -status, "Reading from client");
1530         code = 502;
1531         message = internAtomError(-status, "Couldn't read from client");
1532         goto fail;
1533     }
1534
1535     requestee = request->request;
1536     server = requestee->connection;
1537
1538     push = MIN(srequest->offset - connection->reqlen,
1539                connection->bodylen - connection->reqoffset);
1540     if(push > 0) {
1541         connection->reqlen += push;
1542         httpServerDoSide(server);
1543         return 1;
1544     }
1545
1546     if(server->reqoffset >= connection->bodylen) {
1547         connection->flags &= ~(CONN_READER | CONN_SIDE_READER);
1548         return 1;
1549     }
1550
1551     assert(status);
1552     do_log(L_ERROR, "Incomplete client request.\n");
1553     code = 502;
1554     message = internAtom("Incomplete client request");
1555
1556  fail:
1557     request->error_code = code;
1558     if(request->error_message)
1559         releaseAtom(request->error_message);
1560     request->error_message = message;
1561     if(request->error_headers)
1562         releaseAtom(request->error_headers);
1563     request->error_headers = NULL;
1564
1565     if(request->request) {
1566         shutdown(request->request->connection->fd, 2);
1567         pokeFdEvent(request->request->connection->fd, -ESHUTDOWN, POLLOUT);
1568     }
1569     notifyObject(request->object);
1570     connection->flags &= ~CONN_SIDE_READER;
1571     httpClientDiscardBody(connection);
1572     return 1;
1573 }
1574
1575 int
1576 httpServeObject(HTTPConnectionPtr connection)
1577 {
1578     HTTPRequestPtr request = connection->request;
1579     ObjectPtr object = request->object;
1580     int i = request->from / CHUNK_SIZE;
1581     int j = request->from % CHUNK_SIZE;
1582     int n, len, rc;
1583     int bufsize = CHUNK_SIZE;
1584     int condition_result;
1585
1586     object->atime = current_time.tv_sec;
1587     objectMetadataChanged(object, 0);
1588
1589     httpSetTimeout(connection, -1);
1590
1591     if((request->error_code && relaxTransparency <= 0) ||
1592        object->flags & OBJECT_INITIAL) {
1593         object->flags &= ~OBJECT_FAILED;
1594         unlockChunk(object, i);
1595         if(request->error_code)
1596             return httpClientRawError(connection,
1597                                       request->error_code,
1598                                       retainAtom(request->error_message), 0);
1599         else
1600             return httpClientRawError(connection,
1601                                       500, internAtom("Object vanished."), 0);
1602     }
1603
1604     if(!(object->flags & OBJECT_INPROGRESS) && object->code == 0) {
1605         if(object->flags & OBJECT_INITIAL) {
1606             unlockChunk(object, i);
1607             return httpClientRawError(connection, 503,
1608                                       internAtom("Error message lost"), 0);
1609
1610         } else {
1611             unlockChunk(object, i);
1612             do_log(L_ERROR, "Internal proxy error: object has no code.\n");
1613             return httpClientRawError(connection, 500,
1614                                       internAtom("Internal proxy error: "
1615                                                  "object has no code"), 0);
1616         }
1617     }
1618
1619     condition_result = httpCondition(object, request->condition);
1620
1621     if(condition_result == CONDITION_FAILED) {
1622         unlockChunk(object, i);
1623         return httpClientRawError(connection, 412,
1624                                   internAtom("Precondition failed"), 0);
1625     } else if(condition_result == CONDITION_NOT_MODIFIED) {
1626         unlockChunk(object, i);
1627         return httpClientRawError(connection, 304,
1628                                   internAtom("Not modified"), 0);
1629     }
1630
1631     objectFillFromDisk(object, request->from,
1632                        (request->method == METHOD_HEAD ||
1633                         condition_result != CONDITION_MATCH) ? 0 : 1);
1634
1635     if(((object->flags & OBJECT_LINEAR) &&
1636         (object->requestor != connection->request)) ||
1637        ((object->flags & OBJECT_SUPERSEDED) &&
1638         !(object->flags & OBJECT_LINEAR))) {
1639         if(request->request) {
1640             request->request->request = NULL;
1641             request->request = NULL;
1642             request->object->requestor = NULL;
1643         }
1644         object = makeObject(OBJECT_HTTP,
1645                             object->key, object->key_size, 1, 0,
1646                             object->request, NULL);
1647         if(request->object->requestor == request)
1648             request->object->requestor = NULL;
1649         unlockChunk(request->object, i);
1650         releaseObject(request->object);
1651         request->object = NULL;
1652         if(object == NULL) {
1653             do_log(L_ERROR, "Couldn't allocate object.");
1654             return httpClientRawError(connection, 501,
1655                                       internAtom("Couldn't allocate object"),
1656                                       1);
1657         }
1658         if(urlIsLocal(object->key, object->key_size)) {
1659             object->flags |= OBJECT_LOCAL;
1660             object->request = httpLocalRequest;
1661         }
1662         request->object = object;
1663         connection->flags &= ~CONN_WRITER;
1664         return httpClientNoticeRequest(request, 1);
1665     }
1666
1667     if(object->flags & OBJECT_ABORTED) {
1668         unlockChunk(object, i);
1669         return httpClientNoticeError(request, object->code,
1670                                      retainAtom(object->message));
1671     }
1672
1673     if(connection->buf == NULL)
1674         connection->buf = get_chunk();
1675     if(connection->buf == NULL) {
1676         unlockChunk(object, i);
1677         do_log(L_ERROR, "Couldn't allocate client buffer.\n");
1678         connection->flags &= ~CONN_WRITER;
1679         httpClientFinish(connection, 1);
1680         return 1;
1681     }
1682
1683     if(object->length >= 0 && request->to >= object->length)
1684         request->to = -1;
1685
1686     if(request->from > 0 || request->to >= 0) {
1687         if(request->method == METHOD_HEAD) {
1688             request->to = request->from;
1689         } else if(request->to < 0) {
1690             if(object->length >= 0)
1691                 request->to = object->length;
1692         }
1693     }
1694
1695  again:
1696
1697     connection->len = 0;
1698
1699     if((request->from <= 0 && request->to < 0) ||
1700        request->method == METHOD_HEAD) {
1701         n = snnprintf(connection->buf, 0, bufsize,
1702                       "HTTP/1.1 %d %s",
1703                       object->code, atomString(object->message));
1704     } else {
1705         if(request->from > request->to) {
1706             unlockChunk(object, i);
1707             return httpClientRawError(connection, 416,
1708                                       internAtom("Requested range "
1709                                                  "not satisfiable"),
1710                                       0);
1711         } else {
1712             n = snnprintf(connection->buf, 0, bufsize,
1713                           "HTTP/1.1 206 Partial content");
1714         }
1715     }
1716
1717     n = httpWriteObjectHeaders(connection->buf, n, bufsize,
1718                                object, request->from, request->to);
1719     if(n < 0)
1720         goto fail;
1721
1722     if(request->method != METHOD_HEAD &&
1723        condition_result != CONDITION_NOT_MODIFIED &&
1724        request->to < 0 && object->length < 0) {
1725         if(connection->version == HTTP_11) {
1726             connection->te = TE_CHUNKED;
1727             n = snnprintf(connection->buf, n, bufsize,
1728                           "\r\nTransfer-Encoding: chunked");
1729         } else {
1730             request->flags &= ~REQUEST_PERSISTENT;
1731         }
1732     }
1733
1734     if(object->age < current_time.tv_sec) {
1735         n = snnprintf(connection->buf, n, bufsize,
1736                       "\r\nAge: %d",
1737                       (int)(current_time.tv_sec - object->age));
1738     }
1739     n = snnprintf(connection->buf, n, bufsize,
1740                   "\r\nConnection: %s",
1741                   (request->flags & REQUEST_PERSISTENT) ?
1742                   "keep-alive" : "close");
1743
1744     if(!(object->flags & OBJECT_LOCAL)) {
1745         if((object->flags & OBJECT_FAILED) && !proxyOffline) {
1746             n = snnprintf(connection->buf, n, bufsize,
1747                           "\r\nWarning: 111 %s:%d Revalidation failed",
1748                           proxyName->string, proxyPort);
1749             if(request->error_code)
1750                 n = snnprintf(connection->buf, n, bufsize,
1751                               " (%d %s)",
1752                               request->error_code,
1753                               atomString(request->error_message));
1754             object->flags &= ~OBJECT_FAILED;
1755         } else if(proxyOffline &&
1756                   objectMustRevalidate(object, &request->cache_control)) {
1757             n = snnprintf(connection->buf, n, bufsize,
1758                           "\r\nWarning: 112 %s:%d Disconnected operation",
1759                           proxyName->string, proxyPort);
1760         } else if(objectIsStale(object, &request->cache_control)) {
1761             n = snnprintf(connection->buf, n, bufsize,
1762                           "\r\nWarning: 110 %s:%d Object is stale",
1763                           proxyName->string, proxyPort);
1764         } else if(object->expires < 0 && object->max_age < 0 &&
1765                   object->age < current_time.tv_sec - 24 * 3600) {
1766             n = snnprintf(connection->buf, n, bufsize,
1767                           "\r\nWarning: 113 %s:%d Heuristic expiration",
1768                           proxyName->string, proxyPort);
1769         }
1770     }
1771
1772     n = snnprintf(connection->buf, n, bufsize, "\r\n\r\n");
1773
1774     if(n < 0)
1775         goto fail;
1776
1777     connection->offset = request->from;
1778
1779     if(request->method == METHOD_HEAD ||
1780        condition_result == CONDITION_NOT_MODIFIED ||
1781        (object->flags & OBJECT_ABORTED)) {
1782         len = 0;
1783     } else {
1784         if(i < object->numchunks) {
1785             if(object->chunks[i].size <= j)
1786                 len = 0;
1787             else
1788                 len = object->chunks[i].size - j;
1789         } else {
1790             len = 0;
1791         }
1792         if(request->to >= 0)
1793             len = MIN(len, request->to - request->from);
1794     }
1795
1796     connection->offset = request->from;
1797     httpSetTimeout(connection, clientTimeout);
1798     do_log(D_CLIENT_DATA, "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1799            (unsigned long)connection, (unsigned long)object,
1800            connection->offset, len);
1801     do_stream_h(IO_WRITE |
1802                 (connection->te == TE_CHUNKED && len > 0 ? IO_CHUNKED : 0),
1803                 connection->fd, 0,
1804                 connection->buf, n,
1805                 object->chunks[i].data + j, len,
1806                 httpServeObjectStreamHandler, connection);
1807     return 1;
1808
1809  fail:
1810     rc = 0;
1811     connection->len = 0;
1812     if(!(connection->flags & CONN_BIGBUF))
1813         rc = httpConnectionBigify(connection);
1814     if(rc > 0) {
1815         bufsize = bigBufferSize;
1816         goto again;
1817     }
1818     unlockChunk(object, i);
1819     return httpClientRawError(connection, 500,
1820                               rc == 0 ?
1821                               internAtom("No space for headers") :
1822                               internAtom("Couldn't allocate big buffer"), 0);
1823 }
1824
1825 static int
1826 httpServeObjectDelayed(TimeEventHandlerPtr event)
1827 {
1828     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1829     httpServeObject(connection);
1830     return 1;
1831 }
1832
1833 int
1834 delayedHttpServeObject(HTTPConnectionPtr connection)
1835 {
1836     TimeEventHandlerPtr event;
1837
1838     assert(connection->request->object->chunks[connection->request->from /
1839                                                CHUNK_SIZE].locked > 0);
1840
1841     event = scheduleTimeEvent(-1, httpServeObjectDelayed,
1842                               sizeof(connection), &connection);
1843     if(!event) return -1;
1844     return 1;
1845 }
1846
1847 static int
1848 httpServeObjectFinishHandler(int status,
1849                              FdEventHandlerPtr event,
1850                              StreamRequestPtr srequest)
1851 {
1852     HTTPConnectionPtr connection = srequest->data;
1853     HTTPRequestPtr request = connection->request;
1854
1855     (void)request;
1856     assert(!request->chandler);
1857
1858     if(status == 0 && !streamRequestDone(srequest))
1859         return 0;
1860
1861     httpSetTimeout(connection, -1);
1862
1863     if(status < 0) {
1864         do_log(L_ERROR, "Couldn't terminate chunked reply\n");
1865         httpClientFinish(connection, 1);
1866     } else {
1867         httpClientFinish(connection, 0);
1868     }
1869     return 1;
1870 }
1871
1872 int
1873 httpServeChunk(HTTPConnectionPtr connection)
1874 {
1875     HTTPRequestPtr request = connection->request;
1876     ObjectPtr object = request->object;
1877     int i = connection->offset / CHUNK_SIZE;
1878     int j = connection->offset - (i * CHUNK_SIZE);
1879     int to, len, len2, end;
1880     int rc;
1881
1882     if(object->flags & OBJECT_ABORTED)
1883         goto fail_no_unlock;
1884
1885     if(object->length >= 0 && request->to >= 0)
1886         to = MIN(request->to, object->length);
1887     else if(object->length >= 0)
1888         to = object->length;
1889     else if(request->to >= 0)
1890         to = request->to;
1891     else
1892         to = -1;
1893
1894     lockChunk(object, i);
1895     len = 0;
1896     if(i < object->numchunks)
1897         len = object->chunks[i].size - j;
1898
1899     if(request->method != METHOD_HEAD &&
1900        len < CHUNK_SIZE && connection->offset + len < to) {
1901         objectFillFromDisk(object, connection->offset + len, 2);
1902         len = object->chunks[i].size - j;
1903     }
1904
1905     if(to >= 0)
1906         len = MIN(len, to - connection->offset);
1907
1908     if(len <= 0) {
1909         if(to >= 0 && connection->offset >= to) {
1910             if(request->chandler) {
1911                 unregisterConditionHandler(request->chandler);
1912                 request->chandler = NULL;
1913             }
1914             unlockChunk(object, i);
1915             if(connection->te == TE_CHUNKED) {
1916                 httpSetTimeout(connection, clientTimeout);
1917                 do_stream(IO_WRITE | IO_CHUNKED | IO_END,
1918                           connection->fd, 0, NULL, 0,
1919                           httpServeObjectFinishHandler, connection);
1920             } else {
1921                 httpClientFinish(connection,
1922                                  !(object->length >= 0 &&
1923                                    connection->offset >= object->length));
1924             }
1925             return 1;
1926         } else {
1927             if(!request->chandler) {
1928                 request->chandler =
1929                     conditionWait(&object->condition,
1930                                   httpServeObjectHandler,
1931                                   sizeof(connection), &connection);
1932                 if(!request->chandler) {
1933                     do_log(L_ERROR, "Couldn't register condition handler\n");
1934                     goto fail;
1935                 }
1936             }
1937             if(!(object->flags & OBJECT_INPROGRESS)) {
1938                 if(object->flags & OBJECT_SUPERSEDED) {
1939                     goto fail;
1940                 }
1941                 if(REQUEST_SIDE(request)) goto fail;
1942                 rc = object->request(object, request->method,
1943                                      connection->offset, -1, request,
1944                                      object->request_closure);
1945                 if(rc <= 0) goto fail;
1946             }
1947             return 1;
1948         }
1949     } else {
1950         /* len > 0 */
1951         if(request->method != METHOD_HEAD)
1952             objectFillFromDisk(object, (i + 1) * CHUNK_SIZE, 1);
1953         if(request->chandler) {
1954             unregisterConditionHandler(request->chandler);
1955             request->chandler = NULL;
1956         }
1957         len2 = 0;
1958         if(j + len == CHUNK_SIZE && object->numchunks > i + 1) {
1959             len2 = object->chunks[i + 1].size;
1960             if(to >= 0)
1961                 len2 = MIN(len2, to - (i + 1) * CHUNK_SIZE);
1962         }
1963         /* Lock early -- httpServerRequest may get_chunk */
1964         if(len2 > 0)
1965             lockChunk(object, i + 1);
1966         if(object->length >= 0 &&
1967            connection->offset + len + len2 == object->length)
1968             end = 1;
1969         else
1970             end = 0;
1971         /* Prefetch */
1972         if(!(object->flags & OBJECT_INPROGRESS) && !REQUEST_SIDE(request)) {
1973             if(object->chunks[i].size < CHUNK_SIZE &&
1974                to >= 0 && connection->offset + len + 1 < to)
1975                 object->request(object, request->method,
1976                                 connection->offset + len, -1, request,
1977                                 object->request_closure);
1978             else if(i + 1 < object->numchunks &&
1979                     object->chunks[i + 1].size == 0 &&
1980                     to >= 0 && (i + 1) * CHUNK_SIZE + 1 < to)
1981                 object->request(object, request->method,
1982                                 (i + 1) * CHUNK_SIZE, -1, request,
1983                                 object->request_closure);
1984         }
1985         if(len2 == 0) {
1986             httpSetTimeout(connection, clientTimeout);
1987             do_log(D_CLIENT_DATA,
1988                    "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1989                    (unsigned long)connection, (unsigned long)object,
1990                    connection->offset, len);
1991             /* IO_NOTNOW in order to give other clients a chance to run. */
1992             do_stream(IO_WRITE | IO_NOTNOW |
1993                       (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
1994                       (end ? IO_END : 0),
1995                       connection->fd, 0,
1996                       object->chunks[i].data + j, len,
1997                       httpServeObjectStreamHandler, connection);
1998         } else {
1999             httpSetTimeout(connection, clientTimeout);
2000             do_log(D_CLIENT_DATA,
2001                    "Serving on 0x%lx for 0x%lx: offset %d len %d + %d\n",
2002                    (unsigned long)connection, (unsigned long)object,
2003                    connection->offset, len, len2);
2004             do_stream_2(IO_WRITE | IO_NOTNOW |
2005                         (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
2006                         (end ? IO_END : 0),
2007                         connection->fd, 0,
2008                         object->chunks[i].data + j, len,
2009                         object->chunks[i + 1].data, len2,
2010                         httpServeObjectStreamHandler2, connection);
2011         }
2012         return 1;
2013     }
2014
2015     abort();
2016
2017  fail:
2018     unlockChunk(object, i);
2019  fail_no_unlock:
2020     if(request->chandler)
2021         unregisterConditionHandler(request->chandler);
2022     request->chandler = NULL;
2023     httpClientFinish(connection, 1);
2024     return 1;
2025 }
2026
2027 static int
2028 httpServeChunkDelayed(TimeEventHandlerPtr event)
2029 {
2030     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
2031     httpServeChunk(connection);
2032     return 1;
2033 }
2034
2035 int
2036 delayedHttpServeChunk(HTTPConnectionPtr connection)
2037 {
2038     TimeEventHandlerPtr event;
2039     event = scheduleTimeEvent(-1, httpServeChunkDelayed,
2040                               sizeof(connection), &connection);
2041     if(!event) return -1;
2042     return 1;
2043 }
2044
2045 int
2046 httpServeObjectHandler(int status, ConditionHandlerPtr chandler)
2047 {
2048     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)chandler->data;
2049     HTTPRequestPtr request = connection->request;
2050     int rc;
2051
2052     unlockChunk(request->object, connection->offset / CHUNK_SIZE);
2053
2054     if((request->object->flags & OBJECT_ABORTED) || status < 0) {
2055         shutdown(connection->fd, 1);
2056         httpSetTimeout(connection, 10);
2057         /* httpServeChunk will take care of the error. */
2058     }
2059
2060     httpSetTimeout(connection, -1);
2061
2062     request->chandler = NULL;
2063     rc = delayedHttpServeChunk(connection);
2064     if(rc < 0) {
2065         do_log(L_ERROR, "Couldn't schedule serving.\n");
2066         abortObject(request->object, 503,
2067                     internAtom("Couldn't schedule serving"));
2068     }
2069     return 1;
2070 }
2071
2072 static int
2073 httpServeObjectStreamHandlerCommon(int kind, int status,
2074                                    FdEventHandlerPtr event,
2075                                    StreamRequestPtr srequest)
2076 {
2077     HTTPConnectionPtr connection = srequest->data;
2078     HTTPRequestPtr request = connection->request;
2079     int condition_result = httpCondition(request->object, request->condition);
2080     int i = connection->offset / CHUNK_SIZE;
2081
2082     assert(!request->chandler);
2083
2084     if(status == 0 && !streamRequestDone(srequest)) {
2085         httpSetTimeout(connection, clientTimeout);
2086         return 0;
2087     }
2088
2089     httpSetTimeout(connection, -1);
2090
2091     unlockChunk(request->object, i);
2092     if(kind == 2)
2093         unlockChunk(request->object, i + 1);
2094
2095     if(status) {
2096         if(status < 0) {
2097             do_log_error(status == -ECONNRESET ? D_IO : L_ERROR,
2098                          -status, "Couldn't write to client");
2099             if(status == -EIO || status == -ESHUTDOWN)
2100                 httpClientFinish(connection, 2);
2101             else
2102                 httpClientFinish(connection, 1);
2103         } else {
2104             do_log(D_IO, "Couldn't write to client: short write.\n");
2105             httpClientFinish(connection, 2);
2106         }
2107         return 1;
2108     }
2109
2110     if(srequest->operation & IO_CHUNKED) {
2111         assert(srequest->offset > 2);
2112         connection->offset += srequest->offset - 2;
2113     } else {
2114         connection->offset += srequest->offset;
2115     }
2116     request->flags &= ~REQUEST_REQUESTED;
2117
2118     if(request->object->flags & OBJECT_ABORTED) {
2119         httpClientFinish(connection, 1);
2120         return 1;
2121     }
2122
2123     if(connection->request->method == METHOD_HEAD ||
2124        condition_result == CONDITION_NOT_MODIFIED) {
2125         httpClientFinish(connection, 0);
2126         return 1;
2127     }
2128
2129     if(srequest->operation & IO_END)
2130         httpClientFinish(connection, 0);
2131     else {
2132         httpConnectionDestroyBuf(connection);
2133         httpServeChunk(connection);
2134     }
2135     return 1;
2136 }
2137
2138 int
2139 httpServeObjectStreamHandler(int status,
2140                              FdEventHandlerPtr event,
2141                              StreamRequestPtr srequest)
2142 {
2143     return httpServeObjectStreamHandlerCommon(1, status, event, srequest);
2144 }
2145
2146 int
2147 httpServeObjectStreamHandler2(int status,
2148                               FdEventHandlerPtr event,
2149                               StreamRequestPtr srequest)
2150 {
2151     return httpServeObjectStreamHandlerCommon(2, status, event, srequest);
2152 }