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     /* The spec doesn't strictly forbid 206 for non-200 instances, but doing
1152        that breaks some client software. */
1153     if(object->code && object->code != 200) {
1154         request->from = 0;
1155         request->to = -1;
1156     }
1157
1158     if(request->condition && request->condition->ifrange) {
1159         if(!object->etag ||
1160            strcmp(object->etag, request->condition->ifrange) != 0) {
1161             request->from = 0;
1162             request->to = -1;
1163         }
1164     }
1165
1166     if(object->flags & OBJECT_DYNAMIC) {
1167         request->from = 0;
1168         request->to = -1;
1169     }
1170
1171     if(request->method == METHOD_HEAD)
1172         haveData = !(request->object->flags & OBJECT_INITIAL);
1173     else
1174         haveData =
1175             (request->object->length >= 0 &&
1176              request->object->length <= request->from) ||
1177             (objectHoleSize(request->object, request->from) == 0);
1178
1179     if(request->flags & REQUEST_REQUESTED)
1180         validate = 0;
1181     else if(novalidate || (!local && proxyOffline))
1182         validate = 0;
1183     else if(local)
1184         validate =
1185             objectMustRevalidate(request->object, &request->cache_control);
1186     else if(request->cache_control.flags & CACHE_ONLY_IF_CACHED)
1187         validate = 0;
1188     else if((request->object->flags & OBJECT_FAILED) &&
1189             !(object->flags & OBJECT_INPROGRESS) &&
1190             !relaxTransparency)
1191         validate = 1;
1192     else if(request->method != METHOD_HEAD &&
1193             !objectHasData(object, request->from, request->to) &&
1194             !(object->flags & OBJECT_INPROGRESS))
1195         validate = 1;
1196     else if(objectMustRevalidate((relaxTransparency <= 1 ?
1197                                   request->object : NULL),
1198                                  &request->cache_control))
1199         validate = 1;
1200     else
1201         validate = 0;
1202
1203     if(request->cache_control.flags & CACHE_ONLY_IF_CACHED) {
1204         validate = 0;
1205         if(!haveData) {
1206             if(serveNow) {
1207                 connection->flags |= CONN_WRITER;
1208                 return httpClientRawError(connection, 504,
1209                                           internAtom("Object not in cache"),
1210                                           0);
1211             } else
1212                 return 1;
1213         }
1214     }
1215
1216     if(!(request->object->flags & OBJECT_VALIDATING) &&
1217        ((!validate && haveData) ||
1218         (request->object->flags & OBJECT_FAILED))) {
1219         if(serveNow) {
1220             connection->flags |= CONN_WRITER;
1221             lockChunk(request->object, request->from / CHUNK_SIZE);
1222             return httpServeObject(connection);
1223         } else {
1224             return 1;
1225         }
1226     }
1227
1228     if((request->flags & REQUEST_REQUESTED) &&
1229        !(request->object->flags & OBJECT_INPROGRESS)) {
1230         /* This can happen either because the server side ran out of
1231            memory, or because it is using HEAD validation.  We mark
1232            the object to be fetched again. */
1233         request->flags &= ~REQUEST_REQUESTED;
1234     }
1235
1236     if(serveNow) {
1237         connection->flags |= CONN_WRITER;
1238         if(!local && proxyOffline)
1239             return httpClientRawError(connection, 502,
1240                                       internAtom("Disconnected operation "
1241                                                  "and object not in cache"),
1242                                       0);
1243         request->chandler =
1244             conditionWait(&request->object->condition, httpClientGetHandler,
1245                           sizeof(request), &request);
1246         if(request->chandler == NULL) {
1247             do_log(L_ERROR, "Couldn't register condition handler.\n");
1248             return httpClientRawError(connection, 503,
1249                                       internAtom("Couldn't register "
1250                                                  "condition handler"), 0);
1251         }
1252     }
1253
1254     if(request->object->flags & OBJECT_VALIDATING)
1255         return 1;
1256
1257     conditional = (haveData && request->method == METHOD_GET);
1258     if(!mindlesslyCacheVary && (request->object->cache_control & CACHE_VARY))
1259         conditional = conditional && (request->object->etag != NULL);
1260
1261     conditional =
1262         conditional && !(request->object->cache_control & CACHE_MISMATCH);
1263
1264     request->object->flags |= OBJECT_VALIDATING;
1265     rc = request->object->request(request->object,
1266                                   conditional ? METHOD_CONDITIONAL_GET :
1267                                   request->method,
1268                                   request->from, request->to, request,
1269                                   request->object->request_closure);
1270     if(rc < 0) {
1271         if(request->chandler)
1272             unregisterConditionHandler(request->chandler);
1273         request->chandler = NULL;
1274         request->object->flags &= ~OBJECT_VALIDATING;
1275         request->object->flags |= OBJECT_FAILED;
1276         if(request->error_message)
1277             releaseAtom(request->error_message);
1278         request->error_code = 503;
1279         request->error_message = internAtom("Couldn't schedule get");
1280     }
1281     return 1;
1282 }
1283
1284 static int
1285 httpClientNoticeRequestDelayed(TimeEventHandlerPtr event)
1286 {
1287     HTTPRequestPtr request = *(HTTPRequestPtr*)event->data;
1288     httpClientNoticeRequest(request, 0);
1289     return 1;
1290 }
1291
1292 int
1293 delayedHttpClientNoticeRequest(HTTPRequestPtr request)
1294 {
1295     TimeEventHandlerPtr event;
1296     event = scheduleTimeEvent(-1, httpClientNoticeRequestDelayed,
1297                               sizeof(request), &request);
1298     if(!event)
1299         return -1;
1300     return 1;
1301 }
1302
1303 int
1304 httpClientContinueDelayed(TimeEventHandlerPtr event)
1305 {
1306     static char httpContinue[] = "HTTP/1.1 100 Continue\r\n\r\n";
1307     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1308
1309     do_stream(IO_WRITE, connection->fd, 0, httpContinue, 25,
1310               httpErrorNofinishStreamHandler, connection);
1311     return 1;
1312 }
1313
1314 int
1315 delayedHttpClientContinue(HTTPConnectionPtr connection)
1316 {
1317     TimeEventHandlerPtr event;
1318     event = scheduleTimeEvent(-1, httpClientContinueDelayed,
1319                               sizeof(connection), &connection);
1320     if(!event)
1321         return -1;
1322     return 1;
1323 }
1324
1325 int
1326 httpClientGetHandler(int status, ConditionHandlerPtr chandler)
1327 {
1328     HTTPRequestPtr request = *(HTTPRequestPtr*)chandler->data;
1329     HTTPConnectionPtr connection = request->connection;
1330     ObjectPtr object = request->object;
1331     int rc;
1332
1333     assert(request == connection->request);
1334
1335     if(request->request) {
1336         assert(request->object->flags & OBJECT_INPROGRESS);
1337         assert(!request->request->object ||
1338                request->request->object == request->object);
1339     }
1340
1341     if(status < 0) {
1342         object->flags &= ~OBJECT_VALIDATING; /* for now */
1343         if(request->request && request->request->request == request)
1344             httpServerClientReset(request->request);
1345         lockChunk(object, request->from / CHUNK_SIZE);
1346         request->chandler = NULL;
1347         rc = delayedHttpServeObject(connection);
1348         if(rc < 0) {
1349             unlockChunk(object, request->from / CHUNK_SIZE);
1350             do_log(L_ERROR, "Couldn't schedule serving.\n");
1351             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1352         }
1353         return 1;
1354     }
1355
1356     if(object->flags & OBJECT_VALIDATING)
1357         return 0;
1358
1359     if(request->error_code) {
1360         lockChunk(object, request->from / CHUNK_SIZE);
1361         request->chandler = NULL;
1362         rc = delayedHttpServeObject(connection);
1363         if(rc < 0) {
1364             unlockChunk(object, request->from / CHUNK_SIZE);
1365             do_log(L_ERROR, "Couldn't schedule serving.\n");
1366             abortObject(object, 503, internAtom("Couldn't schedule serving"));
1367         }
1368         return 1;
1369     }
1370
1371     if(request->flags & REQUEST_WAIT_CONTINUE) {
1372         if(request->request &&
1373            !(request->request->flags & REQUEST_WAIT_CONTINUE)) {
1374             request->flags &= ~REQUEST_WAIT_CONTINUE;
1375             delayedHttpClientContinue(connection);
1376         }
1377         return 0;
1378     }
1379
1380     /* See httpServerHandlerHeaders */
1381     if((object->flags & OBJECT_SUPERSEDED) &&
1382        request->request && request->request->can_mutate) {
1383         ObjectPtr new_object = retainObject(request->request->can_mutate);
1384         if(object->requestor == request) {
1385             if(new_object->requestor == NULL)
1386                 new_object->requestor = request;
1387             object->requestor = NULL;
1388         }
1389         request->chandler = NULL;
1390         releaseObject(object);
1391         request->object = new_object;
1392         request->request->object = new_object;
1393         /* We're handling the wrong object now.  It's simpler to
1394            rebuild the whole data structure from scratch rather than
1395            trying to compensate. */
1396         rc = delayedHttpClientNoticeRequest(request);
1397         if(rc < 0) {
1398             do_log(L_ERROR, "Couldn't schedule noticing of request.");
1399             abortObject(object, 500,
1400                         internAtom("Couldn't schedule "
1401                                    "noticing of request"));
1402             /* We're probably out of memory.  What can we do? */
1403             shutdown(connection->fd, 1);
1404         }
1405         return 1;
1406     }
1407
1408     if(object->requestor != request && !(object->flags & OBJECT_ABORTED)) {
1409         /* Make sure we don't serve an object that is stale for us
1410            unless we're the requestor. */
1411         if((object->flags & (OBJECT_LINEAR | OBJECT_MUTATING)) ||
1412            objectMustRevalidate(object, &request->cache_control)) {
1413            if(object->flags & OBJECT_INPROGRESS)
1414                return 0;
1415            rc = delayedHttpClientNoticeRequest(request);
1416            if(rc < 0) {
1417                do_log(L_ERROR, "Couldn't schedule noticing of request.");
1418                abortObject(object, 500,
1419                            internAtom("Couldn't schedule "
1420                                       "noticing of request"));
1421            } else {
1422                request->chandler = NULL;
1423                return 1;
1424            }
1425         }
1426     }
1427
1428     if(object->flags & (OBJECT_INITIAL | OBJECT_VALIDATING)) {
1429         if(object->flags & (OBJECT_INPROGRESS | OBJECT_VALIDATING)) {
1430             return 0;
1431         } else if(object->flags & OBJECT_FAILED) {
1432             if(request->error_code)
1433                 abortObject(object,
1434                             request->error_code,
1435                             retainAtom(request->error_message));
1436             else {
1437                 abortObject(object, 500,
1438                             internAtom("Error message lost in transit"));
1439             }
1440         } else {
1441             /* The request was pruned by httpServerDiscardRequests */
1442             if(chandler == request->chandler) {
1443                 int rc;
1444                 request->chandler = NULL;
1445                 rc = delayedHttpClientNoticeRequest(request);
1446                 if(rc < 0)
1447                     abortObject(object, 500,
1448                                 internAtom("Couldn't allocate "
1449                                            "delayed notice request"));
1450                 else
1451                     return 1;
1452             } else {
1453                 abortObject(object, 500,
1454                             internAtom("Wrong request pruned -- "
1455                                        "this shouldn't happen"));
1456             }
1457         }
1458     }
1459
1460     if(request->object->flags & OBJECT_DYNAMIC) {
1461         if(objectHoleSize(request->object, 0) == 0) {
1462             request->from = 0;
1463             request->to = -1;
1464         } else {
1465             /* We really should request again if that is not the case */
1466         }
1467     }
1468
1469     lockChunk(object, request->from / CHUNK_SIZE);
1470     request->chandler = NULL;
1471     rc = delayedHttpServeObject(connection);
1472     if(rc < 0) {
1473         unlockChunk(object, request->from / CHUNK_SIZE);
1474         do_log(L_ERROR, "Couldn't schedule serving.\n");
1475         abortObject(object, 503, internAtom("Couldn't schedule serving"));
1476     }
1477     return 1;
1478 }
1479
1480 int
1481 httpClientSideRequest(HTTPRequestPtr request)
1482 {
1483     HTTPConnectionPtr connection = request->connection;
1484
1485     if(request->from < 0 || request->to >= 0) {
1486         httpClientNoticeError(request, 501,
1487                               internAtom("Partial requests not implemented"));
1488         httpClientDiscardBody(connection);
1489         return 1;
1490     }
1491     if(connection->reqte != TE_IDENTITY) {
1492         httpClientNoticeError(request, 501,
1493                               internAtom("Chunked requests not implemented"));
1494         httpClientDiscardBody(connection);
1495         return 1;
1496     }
1497     if(connection->bodylen < 0) {
1498         httpClientNoticeError(request, 502,
1499                               internAtom("POST or PUT without "
1500                                          "Content-Length"));
1501         httpClientDiscardBody(connection);
1502         return 1;
1503     }
1504     if(connection->reqlen < 0) {
1505         httpClientNoticeError(request, 502,
1506                               internAtom("Incomplete POST or PUT"));
1507         httpClientDiscardBody(connection);
1508         return 1;
1509     }
1510
1511     return httpClientNoticeRequest(request, 0);
1512 }
1513
1514 int
1515 httpClientSideHandler(int status,
1516                       FdEventHandlerPtr event,
1517                       StreamRequestPtr srequest)
1518 {
1519     HTTPConnectionPtr connection = srequest->data;
1520     HTTPRequestPtr request = connection->request;
1521     HTTPRequestPtr requestee;
1522     HTTPConnectionPtr server;
1523     int push;
1524     int code;
1525     AtomPtr message = NULL;
1526
1527     assert(connection->flags & CONN_SIDE_READER);
1528
1529     if((request->object->flags & OBJECT_ABORTED) ||
1530        !(request->object->flags & OBJECT_INPROGRESS)) {
1531         code = request->object->code;
1532         message = retainAtom(request->object->message);
1533         goto fail;
1534     }
1535
1536     if(status < 0) {
1537         do_log_error(L_ERROR, -status, "Reading from client");
1538         code = 502;
1539         message = internAtomError(-status, "Couldn't read from client");
1540         goto fail;
1541     }
1542
1543     requestee = request->request;
1544     server = requestee->connection;
1545
1546     push = MIN(srequest->offset - connection->reqlen,
1547                connection->bodylen - connection->reqoffset);
1548     if(push > 0) {
1549         connection->reqlen += push;
1550         httpServerDoSide(server);
1551         return 1;
1552     }
1553
1554     if(server->reqoffset >= connection->bodylen) {
1555         connection->flags &= ~(CONN_READER | CONN_SIDE_READER);
1556         return 1;
1557     }
1558
1559     assert(status);
1560     do_log(L_ERROR, "Incomplete client request.\n");
1561     code = 502;
1562     message = internAtom("Incomplete client request");
1563
1564  fail:
1565     request->error_code = code;
1566     if(request->error_message)
1567         releaseAtom(request->error_message);
1568     request->error_message = message;
1569     if(request->error_headers)
1570         releaseAtom(request->error_headers);
1571     request->error_headers = NULL;
1572
1573     if(request->request) {
1574         shutdown(request->request->connection->fd, 2);
1575         pokeFdEvent(request->request->connection->fd, -ESHUTDOWN, POLLOUT);
1576     }
1577     notifyObject(request->object);
1578     connection->flags &= ~CONN_SIDE_READER;
1579     httpClientDiscardBody(connection);
1580     return 1;
1581 }
1582
1583 int
1584 httpServeObject(HTTPConnectionPtr connection)
1585 {
1586     HTTPRequestPtr request = connection->request;
1587     ObjectPtr object = request->object;
1588     int i = request->from / CHUNK_SIZE;
1589     int j = request->from % CHUNK_SIZE;
1590     int n, len, rc;
1591     int bufsize = CHUNK_SIZE;
1592     int condition_result;
1593
1594     object->atime = current_time.tv_sec;
1595     objectMetadataChanged(object, 0);
1596
1597     httpSetTimeout(connection, -1);
1598
1599     if((request->error_code && relaxTransparency <= 0) ||
1600        object->flags & OBJECT_INITIAL) {
1601         object->flags &= ~OBJECT_FAILED;
1602         unlockChunk(object, i);
1603         if(request->error_code)
1604             return httpClientRawError(connection,
1605                                       request->error_code,
1606                                       retainAtom(request->error_message), 0);
1607         else
1608             return httpClientRawError(connection,
1609                                       500, internAtom("Object vanished."), 0);
1610     }
1611
1612     if(!(object->flags & OBJECT_INPROGRESS) && object->code == 0) {
1613         if(object->flags & OBJECT_INITIAL) {
1614             unlockChunk(object, i);
1615             return httpClientRawError(connection, 503,
1616                                       internAtom("Error message lost"), 0);
1617
1618         } else {
1619             unlockChunk(object, i);
1620             do_log(L_ERROR, "Internal proxy error: object has no code.\n");
1621             return httpClientRawError(connection, 500,
1622                                       internAtom("Internal proxy error: "
1623                                                  "object has no code"), 0);
1624         }
1625     }
1626
1627     condition_result = httpCondition(object, request->condition);
1628
1629     if(condition_result == CONDITION_FAILED) {
1630         unlockChunk(object, i);
1631         return httpClientRawError(connection, 412,
1632                                   internAtom("Precondition failed"), 0);
1633     } else if(condition_result == CONDITION_NOT_MODIFIED) {
1634         unlockChunk(object, i);
1635         return httpClientRawError(connection, 304,
1636                                   internAtom("Not modified"), 0);
1637     }
1638
1639     objectFillFromDisk(object, request->from,
1640                        (request->method == METHOD_HEAD ||
1641                         condition_result != CONDITION_MATCH) ? 0 : 1);
1642
1643     if(((object->flags & OBJECT_LINEAR) &&
1644         (object->requestor != connection->request)) ||
1645        ((object->flags & OBJECT_SUPERSEDED) &&
1646         !(object->flags & OBJECT_LINEAR))) {
1647         if(request->request) {
1648             request->request->request = NULL;
1649             request->request = NULL;
1650             request->object->requestor = NULL;
1651         }
1652         object = makeObject(OBJECT_HTTP,
1653                             object->key, object->key_size, 1, 0,
1654                             object->request, NULL);
1655         if(request->object->requestor == request)
1656             request->object->requestor = NULL;
1657         unlockChunk(request->object, i);
1658         releaseObject(request->object);
1659         request->object = NULL;
1660         if(object == NULL) {
1661             do_log(L_ERROR, "Couldn't allocate object.");
1662             return httpClientRawError(connection, 501,
1663                                       internAtom("Couldn't allocate object"),
1664                                       1);
1665         }
1666         if(urlIsLocal(object->key, object->key_size)) {
1667             object->flags |= OBJECT_LOCAL;
1668             object->request = httpLocalRequest;
1669         }
1670         request->object = object;
1671         connection->flags &= ~CONN_WRITER;
1672         return httpClientNoticeRequest(request, 1);
1673     }
1674
1675     if(object->flags & OBJECT_ABORTED) {
1676         unlockChunk(object, i);
1677         return httpClientNoticeError(request, object->code,
1678                                      retainAtom(object->message));
1679     }
1680
1681     if(connection->buf == NULL)
1682         connection->buf = get_chunk();
1683     if(connection->buf == NULL) {
1684         unlockChunk(object, i);
1685         do_log(L_ERROR, "Couldn't allocate client buffer.\n");
1686         connection->flags &= ~CONN_WRITER;
1687         httpClientFinish(connection, 1);
1688         return 1;
1689     }
1690
1691     if(object->length >= 0 && request->to >= object->length)
1692         request->to = object->length;
1693
1694     if(request->from > 0 || request->to >= 0) {
1695         if(request->method == METHOD_HEAD) {
1696             request->to = request->from;
1697         } else if(request->to < 0) {
1698             if(object->length >= 0)
1699                 request->to = object->length;
1700         }
1701     }
1702
1703  again:
1704
1705     connection->len = 0;
1706
1707     if((request->from <= 0 && request->to < 0) ||
1708        request->method == METHOD_HEAD) {
1709         n = snnprintf(connection->buf, 0, bufsize,
1710                       "HTTP/1.1 %d %s",
1711                       object->code, atomString(object->message));
1712     } else {
1713         if((object->length >= 0 && request->from >= object->length) ||
1714            (request->to >= 0 && request->from >= request->to)) {
1715             unlockChunk(object, i);
1716             return httpClientRawError(connection, 416,
1717                                       internAtom("Requested range "
1718                                                  "not satisfiable"),
1719                                       0);
1720         } else {
1721             n = snnprintf(connection->buf, 0, bufsize,
1722                           "HTTP/1.1 206 Partial content");
1723         }
1724     }
1725
1726     n = httpWriteObjectHeaders(connection->buf, n, bufsize,
1727                                object, request->from, request->to);
1728     if(n < 0)
1729         goto fail;
1730
1731     if(request->method != METHOD_HEAD &&
1732        condition_result != CONDITION_NOT_MODIFIED &&
1733        request->to < 0 && object->length < 0) {
1734         if(connection->version == HTTP_11) {
1735             connection->te = TE_CHUNKED;
1736             n = snnprintf(connection->buf, n, bufsize,
1737                           "\r\nTransfer-Encoding: chunked");
1738         } else {
1739             request->flags &= ~REQUEST_PERSISTENT;
1740         }
1741     }
1742
1743     if(object->age < current_time.tv_sec) {
1744         n = snnprintf(connection->buf, n, bufsize,
1745                       "\r\nAge: %d",
1746                       (int)(current_time.tv_sec - object->age));
1747     }
1748     n = snnprintf(connection->buf, n, bufsize,
1749                   "\r\nConnection: %s",
1750                   (request->flags & REQUEST_PERSISTENT) ?
1751                   "keep-alive" : "close");
1752
1753     if(!(object->flags & OBJECT_LOCAL)) {
1754         if((object->flags & OBJECT_FAILED) && !proxyOffline) {
1755             n = snnprintf(connection->buf, n, bufsize,
1756                           "\r\nWarning: 111 %s:%d Revalidation failed",
1757                           proxyName->string, proxyPort);
1758             if(request->error_code)
1759                 n = snnprintf(connection->buf, n, bufsize,
1760                               " (%d %s)",
1761                               request->error_code,
1762                               atomString(request->error_message));
1763             object->flags &= ~OBJECT_FAILED;
1764         } else if(proxyOffline &&
1765                   objectMustRevalidate(object, &request->cache_control)) {
1766             n = snnprintf(connection->buf, n, bufsize,
1767                           "\r\nWarning: 112 %s:%d Disconnected operation",
1768                           proxyName->string, proxyPort);
1769         } else if(objectIsStale(object, &request->cache_control)) {
1770             n = snnprintf(connection->buf, n, bufsize,
1771                           "\r\nWarning: 110 %s:%d Object is stale",
1772                           proxyName->string, proxyPort);
1773         } else if(object->expires < 0 && object->max_age < 0 &&
1774                   object->age < current_time.tv_sec - 24 * 3600) {
1775             n = snnprintf(connection->buf, n, bufsize,
1776                           "\r\nWarning: 113 %s:%d Heuristic expiration",
1777                           proxyName->string, proxyPort);
1778         }
1779     }
1780
1781     n = snnprintf(connection->buf, n, bufsize, "\r\n\r\n");
1782
1783     if(n < 0)
1784         goto fail;
1785
1786     connection->offset = request->from;
1787
1788     if(request->method == METHOD_HEAD ||
1789        condition_result == CONDITION_NOT_MODIFIED ||
1790        (object->flags & OBJECT_ABORTED)) {
1791         len = 0;
1792     } else {
1793         if(i < object->numchunks) {
1794             if(object->chunks[i].size <= j)
1795                 len = 0;
1796             else
1797                 len = object->chunks[i].size - j;
1798         } else {
1799             len = 0;
1800         }
1801         if(request->to >= 0)
1802             len = MIN(len, request->to - request->from);
1803     }
1804
1805     connection->offset = request->from;
1806     httpSetTimeout(connection, clientTimeout);
1807     do_log(D_CLIENT_DATA, "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1808            (unsigned long)connection, (unsigned long)object,
1809            connection->offset, len);
1810     do_stream_h(IO_WRITE |
1811                 (connection->te == TE_CHUNKED && len > 0 ? IO_CHUNKED : 0),
1812                 connection->fd, 0,
1813                 connection->buf, n,
1814                 object->chunks[i].data + j, len,
1815                 httpServeObjectStreamHandler, connection);
1816     return 1;
1817
1818  fail:
1819     rc = 0;
1820     connection->len = 0;
1821     if(!(connection->flags & CONN_BIGBUF))
1822         rc = httpConnectionBigify(connection);
1823     if(rc > 0) {
1824         bufsize = bigBufferSize;
1825         goto again;
1826     }
1827     unlockChunk(object, i);
1828     return httpClientRawError(connection, 500,
1829                               rc == 0 ?
1830                               internAtom("No space for headers") :
1831                               internAtom("Couldn't allocate big buffer"), 0);
1832 }
1833
1834 static int
1835 httpServeObjectDelayed(TimeEventHandlerPtr event)
1836 {
1837     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
1838     httpServeObject(connection);
1839     return 1;
1840 }
1841
1842 int
1843 delayedHttpServeObject(HTTPConnectionPtr connection)
1844 {
1845     TimeEventHandlerPtr event;
1846
1847     assert(connection->request->object->chunks[connection->request->from /
1848                                                CHUNK_SIZE].locked > 0);
1849
1850     event = scheduleTimeEvent(-1, httpServeObjectDelayed,
1851                               sizeof(connection), &connection);
1852     if(!event) return -1;
1853     return 1;
1854 }
1855
1856 static int
1857 httpServeObjectFinishHandler(int status,
1858                              FdEventHandlerPtr event,
1859                              StreamRequestPtr srequest)
1860 {
1861     HTTPConnectionPtr connection = srequest->data;
1862     HTTPRequestPtr request = connection->request;
1863
1864     (void)request;
1865     assert(!request->chandler);
1866
1867     if(status == 0 && !streamRequestDone(srequest))
1868         return 0;
1869
1870     httpSetTimeout(connection, -1);
1871
1872     if(status < 0) {
1873         do_log(L_ERROR, "Couldn't terminate chunked reply\n");
1874         httpClientFinish(connection, 1);
1875     } else {
1876         httpClientFinish(connection, 0);
1877     }
1878     return 1;
1879 }
1880
1881 int
1882 httpServeChunk(HTTPConnectionPtr connection)
1883 {
1884     HTTPRequestPtr request = connection->request;
1885     ObjectPtr object = request->object;
1886     int i = connection->offset / CHUNK_SIZE;
1887     int j = connection->offset - (i * CHUNK_SIZE);
1888     int to, len, len2, end;
1889     int rc;
1890
1891     if(object->flags & OBJECT_ABORTED)
1892         goto fail_no_unlock;
1893
1894     if(object->length >= 0 && request->to >= 0)
1895         to = MIN(request->to, object->length);
1896     else if(object->length >= 0)
1897         to = object->length;
1898     else if(request->to >= 0)
1899         to = request->to;
1900     else
1901         to = -1;
1902
1903     lockChunk(object, i);
1904     len = 0;
1905     if(i < object->numchunks)
1906         len = object->chunks[i].size - j;
1907
1908     if(request->method != METHOD_HEAD &&
1909        len < CHUNK_SIZE && connection->offset + len < to) {
1910         objectFillFromDisk(object, connection->offset + len, 2);
1911         len = object->chunks[i].size - j;
1912     }
1913
1914     if(to >= 0)
1915         len = MIN(len, to - connection->offset);
1916
1917     if(len <= 0) {
1918         if(to >= 0 && connection->offset >= to) {
1919             if(request->chandler) {
1920                 unregisterConditionHandler(request->chandler);
1921                 request->chandler = NULL;
1922             }
1923             unlockChunk(object, i);
1924             if(connection->te == TE_CHUNKED) {
1925                 httpSetTimeout(connection, clientTimeout);
1926                 do_stream(IO_WRITE | IO_CHUNKED | IO_END,
1927                           connection->fd, 0, NULL, 0,
1928                           httpServeObjectFinishHandler, connection);
1929             } else {
1930                 httpClientFinish(connection,
1931                                  !(object->length >= 0 &&
1932                                    connection->offset >= object->length));
1933             }
1934             return 1;
1935         } else {
1936             if(!request->chandler) {
1937                 request->chandler =
1938                     conditionWait(&object->condition,
1939                                   httpServeObjectHandler,
1940                                   sizeof(connection), &connection);
1941                 if(!request->chandler) {
1942                     do_log(L_ERROR, "Couldn't register condition handler\n");
1943                     goto fail;
1944                 }
1945             }
1946             if(!(object->flags & OBJECT_INPROGRESS)) {
1947                 if(object->flags & OBJECT_SUPERSEDED) {
1948                     goto fail;
1949                 }
1950                 if(REQUEST_SIDE(request)) goto fail;
1951                 rc = object->request(object, request->method,
1952                                      connection->offset, -1, request,
1953                                      object->request_closure);
1954                 if(rc <= 0) goto fail;
1955             }
1956             return 1;
1957         }
1958     } else {
1959         /* len > 0 */
1960         if(request->method != METHOD_HEAD)
1961             objectFillFromDisk(object, (i + 1) * CHUNK_SIZE, 1);
1962         if(request->chandler) {
1963             unregisterConditionHandler(request->chandler);
1964             request->chandler = NULL;
1965         }
1966         len2 = 0;
1967         if(j + len == CHUNK_SIZE && object->numchunks > i + 1) {
1968             len2 = object->chunks[i + 1].size;
1969             if(to >= 0)
1970                 len2 = MIN(len2, to - (i + 1) * CHUNK_SIZE);
1971         }
1972         /* Lock early -- httpServerRequest may get_chunk */
1973         if(len2 > 0)
1974             lockChunk(object, i + 1);
1975         if(object->length >= 0 &&
1976            connection->offset + len + len2 == object->length)
1977             end = 1;
1978         else
1979             end = 0;
1980         /* Prefetch */
1981         if(!(object->flags & OBJECT_INPROGRESS) && !REQUEST_SIDE(request)) {
1982             if(object->chunks[i].size < CHUNK_SIZE &&
1983                to >= 0 && connection->offset + len + 1 < to)
1984                 object->request(object, request->method,
1985                                 connection->offset + len, -1, request,
1986                                 object->request_closure);
1987             else if(i + 1 < object->numchunks &&
1988                     object->chunks[i + 1].size == 0 &&
1989                     to >= 0 && (i + 1) * CHUNK_SIZE + 1 < to)
1990                 object->request(object, request->method,
1991                                 (i + 1) * CHUNK_SIZE, -1, request,
1992                                 object->request_closure);
1993         }
1994         if(len2 == 0) {
1995             httpSetTimeout(connection, clientTimeout);
1996             do_log(D_CLIENT_DATA,
1997                    "Serving on 0x%lx for 0x%lx: offset %d len %d\n",
1998                    (unsigned long)connection, (unsigned long)object,
1999                    connection->offset, len);
2000             /* IO_NOTNOW in order to give other clients a chance to run. */
2001             do_stream(IO_WRITE | IO_NOTNOW |
2002                       (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
2003                       (end ? IO_END : 0),
2004                       connection->fd, 0,
2005                       object->chunks[i].data + j, len,
2006                       httpServeObjectStreamHandler, connection);
2007         } else {
2008             httpSetTimeout(connection, clientTimeout);
2009             do_log(D_CLIENT_DATA,
2010                    "Serving on 0x%lx for 0x%lx: offset %d len %d + %d\n",
2011                    (unsigned long)connection, (unsigned long)object,
2012                    connection->offset, len, len2);
2013             do_stream_2(IO_WRITE | IO_NOTNOW |
2014                         (connection->te == TE_CHUNKED ? IO_CHUNKED : 0) |
2015                         (end ? IO_END : 0),
2016                         connection->fd, 0,
2017                         object->chunks[i].data + j, len,
2018                         object->chunks[i + 1].data, len2,
2019                         httpServeObjectStreamHandler2, connection);
2020         }
2021         return 1;
2022     }
2023
2024     abort();
2025
2026  fail:
2027     unlockChunk(object, i);
2028  fail_no_unlock:
2029     if(request->chandler)
2030         unregisterConditionHandler(request->chandler);
2031     request->chandler = NULL;
2032     httpClientFinish(connection, 1);
2033     return 1;
2034 }
2035
2036 static int
2037 httpServeChunkDelayed(TimeEventHandlerPtr event)
2038 {
2039     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)event->data;
2040     httpServeChunk(connection);
2041     return 1;
2042 }
2043
2044 int
2045 delayedHttpServeChunk(HTTPConnectionPtr connection)
2046 {
2047     TimeEventHandlerPtr event;
2048     event = scheduleTimeEvent(-1, httpServeChunkDelayed,
2049                               sizeof(connection), &connection);
2050     if(!event) return -1;
2051     return 1;
2052 }
2053
2054 int
2055 httpServeObjectHandler(int status, ConditionHandlerPtr chandler)
2056 {
2057     HTTPConnectionPtr connection = *(HTTPConnectionPtr*)chandler->data;
2058     HTTPRequestPtr request = connection->request;
2059     int rc;
2060
2061     unlockChunk(request->object, connection->offset / CHUNK_SIZE);
2062
2063     if((request->object->flags & OBJECT_ABORTED) || status < 0) {
2064         shutdown(connection->fd, 1);
2065         httpSetTimeout(connection, 10);
2066         /* httpServeChunk will take care of the error. */
2067     }
2068
2069     httpSetTimeout(connection, -1);
2070
2071     request->chandler = NULL;
2072     rc = delayedHttpServeChunk(connection);
2073     if(rc < 0) {
2074         do_log(L_ERROR, "Couldn't schedule serving.\n");
2075         abortObject(request->object, 503,
2076                     internAtom("Couldn't schedule serving"));
2077     }
2078     return 1;
2079 }
2080
2081 static int
2082 httpServeObjectStreamHandlerCommon(int kind, int status,
2083                                    FdEventHandlerPtr event,
2084                                    StreamRequestPtr srequest)
2085 {
2086     HTTPConnectionPtr connection = srequest->data;
2087     HTTPRequestPtr request = connection->request;
2088     int condition_result = httpCondition(request->object, request->condition);
2089     int i = connection->offset / CHUNK_SIZE;
2090
2091     assert(!request->chandler);
2092
2093     if(status == 0 && !streamRequestDone(srequest)) {
2094         httpSetTimeout(connection, clientTimeout);
2095         return 0;
2096     }
2097
2098     httpSetTimeout(connection, -1);
2099
2100     unlockChunk(request->object, i);
2101     if(kind == 2)
2102         unlockChunk(request->object, i + 1);
2103
2104     if(status) {
2105         if(status < 0) {
2106             do_log_error(status == -ECONNRESET ? D_IO : L_ERROR,
2107                          -status, "Couldn't write to client");
2108             if(status == -EIO || status == -ESHUTDOWN)
2109                 httpClientFinish(connection, 2);
2110             else
2111                 httpClientFinish(connection, 1);
2112         } else {
2113             do_log(D_IO, "Couldn't write to client: short write.\n");
2114             httpClientFinish(connection, 2);
2115         }
2116         return 1;
2117     }
2118
2119     if(srequest->operation & IO_CHUNKED) {
2120         assert(srequest->offset > 2);
2121         connection->offset += srequest->offset - 2;
2122     } else {
2123         connection->offset += srequest->offset;
2124     }
2125     request->flags &= ~REQUEST_REQUESTED;
2126
2127     if(request->object->flags & OBJECT_ABORTED) {
2128         httpClientFinish(connection, 1);
2129         return 1;
2130     }
2131
2132     if(connection->request->method == METHOD_HEAD ||
2133        condition_result == CONDITION_NOT_MODIFIED) {
2134         httpClientFinish(connection, 0);
2135         return 1;
2136     }
2137
2138     if(srequest->operation & IO_END)
2139         httpClientFinish(connection, 0);
2140     else {
2141         httpConnectionDestroyBuf(connection);
2142         httpServeChunk(connection);
2143     }
2144     return 1;
2145 }
2146
2147 int
2148 httpServeObjectStreamHandler(int status,
2149                              FdEventHandlerPtr event,
2150                              StreamRequestPtr srequest)
2151 {
2152     return httpServeObjectStreamHandlerCommon(1, status, event, srequest);
2153 }
2154
2155 int
2156 httpServeObjectStreamHandler2(int status,
2157                               FdEventHandlerPtr event,
2158                               StreamRequestPtr srequest)
2159 {
2160     return httpServeObjectStreamHandlerCommon(2, status, event, srequest);
2161 }