netwerk/protocol/http/src/nsHttpConnection.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* vim:set ts=4 sw=4 sts=4 et cin: */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications.
  20  * Portions created by the Initial Developer are Copyright (C) 2001
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Darin Fisher <darin@netscape.com> (original author)
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "nsHttpConnection.h"
  41 #include "nsHttpTransaction.h"
  42 #include "nsHttpRequestHead.h"
  43 #include "nsHttpResponseHead.h"
  44 #include "nsHttpHandler.h"
  45 #include "nsISocketTransportService.h"
  46 #include "nsISocketTransport.h"
  47 #include "nsIServiceManager.h"
  48 #include "nsISSLSocketControl.h"
  49 #include "nsStringStream.h"
  50 #include "netCore.h"
  51 #include "nsNetCID.h"
  52 #include "nsAutoLock.h"
  53 #include "prmem.h"
  54
  55 #ifdef DEBUG
  56 // defined by the socket transport service while active
  57 extern PRThread *gSocketThread;
  58 #endif
  59
  60 static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);
  61
  62 //-----------------------------------------------------------------------------
  63 // nsHttpConnection <public>
  64 //-----------------------------------------------------------------------------
  65
  66 nsHttpConnection::nsHttpConnection()
  67     : mTransaction(nsnull)
  68     , mConnInfo(nsnull)
  69     , mLock(nsnull)
  70     , mLastReadTime(0)
  71     , mIdleTimeout(0)
  72     , mKeepAlive(PR_TRUE) // assume to keep-alive by default
  73     , mKeepAliveMask(PR_TRUE)
  74     , mSupportsPipelining(PR_FALSE) // assume low-grade server
  75     , mIsReused(PR_FALSE)
  76     , mCompletedSSLConnect(PR_FALSE)
  77 {
  78     LOG(("Creating nsHttpConnection @%x\n", this));
  79
  80     // grab a reference to the handler to ensure that it doesn't go away.
  81     nsHttpHandler *handler = gHttpHandler;
  82     NS_ADDREF(handler);
  83 }
  84
  85 nsHttpConnection::~nsHttpConnection()
  86 {
  87     LOG(("Destroying nsHttpConnection @%x\n", this));
  88
  89     NS_IF_RELEASE(mConnInfo);
  90     NS_IF_RELEASE(mTransaction);
  91
  92     if (mLock) {
  93         PR_DestroyLock(mLock);
  94         mLock = nsnull;
  95     }
  96
  97     // release our reference to the handler
  98     nsHttpHandler *handler = gHttpHandler;
  99     NS_RELEASE(handler);
 100 }
 101
 102 nsresult
 103 nsHttpConnection::Init(nsHttpConnectionInfo *info, PRUint16 maxHangTime)
 104 {
 105     LOG(("nsHttpConnection::Init [this=%x]\n", this));
 106
 107     NS_ENSURE_ARG_POINTER(info);
 108     NS_ENSURE_TRUE(!mConnInfo, NS_ERROR_ALREADY_INITIALIZED);
 109
 110     mLock = PR_NewLock();
 111     if (!mLock)
 112         return NS_ERROR_OUT_OF_MEMORY;
 113
 114     mConnInfo = info;
 115     NS_ADDREF(mConnInfo);
 116
 117     mMaxHangTime = maxHangTime;
 118     mLastReadTime = NowInSeconds();
 119     return NS_OK;
 120 }
 121
 122 // called on the socket thread
 123 nsresult
 124 nsHttpConnection::Activate(nsAHttpTransaction *trans, PRUint8 caps)
 125 {
 126     nsresult rv;
 127
 128     LOG(("nsHttpConnection::Activate [this=%x trans=%x caps=%x]\n",
 129          this, trans, caps));
 130
 131     NS_ENSURE_ARG_POINTER(trans);
 132     NS_ENSURE_TRUE(!mTransaction, NS_ERROR_IN_PROGRESS);
 133
 134     // take ownership of the transaction
 135     mTransaction = trans;
 136     NS_ADDREF(mTransaction);
 137
 138     // set mKeepAlive according to what will be requested
 139     mKeepAliveMask = mKeepAlive = (caps & NS_HTTP_ALLOW_KEEPALIVE);
 140
 141     // if we don't have a socket transport then create a new one
 142     if (!mSocketTransport) {
 143         rv = CreateTransport(caps);
 144         if (NS_FAILED(rv))
 145             goto loser;
 146     }
 147
 148     // need to handle SSL proxy CONNECT if this is the first time.
 149     if (mConnInfo->UsingSSL() && mConnInfo->UsingHttpProxy() && !mCompletedSSLConnect) {
 150         rv = SetupSSLProxyConnect();
 151         if (NS_FAILED(rv))
 152             goto loser;
 153     }
 154
 155     // wait for the output stream to be readable
 156     rv = mSocketOut->AsyncWait(this, 0, 0, nsnull);
 157     if (NS_SUCCEEDED(rv))
 158         return rv;
 159
 160 loser:
 161     NS_RELEASE(mTransaction);
 162     return rv;
 163 }
 164
 165 void
 166 nsHttpConnection::Close(nsresult reason)
 167 {
 168     LOG(("nsHttpConnection::Close [this=%x reason=%x]\n", this, reason));
 169
 170     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 171
 172     if (NS_FAILED(reason)) {
 173         if (mSocketTransport) {
 174             mSocketTransport->SetSecurityCallbacks(nsnull);
 175             mSocketTransport->SetEventSink(nsnull, nsnull);
 176             mSocketTransport->Close(reason);
 177         }
 178         mKeepAlive = PR_FALSE;
 179     }
 180 }
 181
 182 // called on the socket thread
 183 nsresult
 184 nsHttpConnection::ProxyStartSSL()
 185 {
 186     LOG(("nsHttpConnection::ProxyStartSSL [this=%x]\n", this));
 187 #ifdef DEBUG
 188     NS_PRECONDITION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 189 #endif
 190
 191     nsCOMPtr<nsISupports> securityInfo;
 192     nsresult rv = mSocketTransport->GetSecurityInfo(getter_AddRefs(securityInfo));
 193     if (NS_FAILED(rv)) return rv;
 194
 195     nsCOMPtr<nsISSLSocketControl> ssl = do_QueryInterface(securityInfo, &rv);
 196     if (NS_FAILED(rv)) return rv;
 197
 198     return ssl->ProxyStartSSL();
 199 }
 200
 201 PRBool
 202 nsHttpConnection::CanReuse()
 203 {
 204     return IsKeepAlive() && (NowInSeconds() - mLastReadTime < mIdleTimeout)
 205                          && IsAlive();
 206 }
 207
 208 PRBool
 209 nsHttpConnection::IsAlive()
 210 {
 211     if (!mSocketTransport)
 212         return PR_FALSE;
 213
 214     PRBool alive;
 215     nsresult rv = mSocketTransport->IsAlive(&alive);
 216     if (NS_FAILED(rv))
 217         alive = PR_FALSE;
 218
 219 //#define TEST_RESTART_LOGIC
 220 #ifdef TEST_RESTART_LOGIC
 221     if (!alive) {
 222         LOG(("pretending socket is still alive to test restart logic\n"));
 223         alive = PR_TRUE;
 224     }
 225 #endif
 226
 227     return alive;
 228 }
 229
 230 PRBool
 231 nsHttpConnection::SupportsPipelining(nsHttpResponseHead *responseHead)
 232 {
 233     // XXX there should be a strict mode available that disables this
 234     // blacklisting.
 235
 236     // assuming connection is HTTP/1.1 with keep-alive enabled
 237     if (mConnInfo->UsingHttpProxy() && !mConnInfo->UsingSSL()) {
 238         // XXX check for bad proxy servers...
 239         return PR_TRUE;
 240     }
 241
 242     // XXX what about checking for a Via header? (transparent proxies)
 243
 244     // check for bad origin servers
 245     const char *val = responseHead->PeekHeader(nsHttp::Server);
 246     if (!val)
 247         return PR_FALSE; // no header, no love
 248
 249     // the list of servers known to do bad things with pipelined requests
 250     static const char *bad_servers[] = {
 251         "Microsoft-IIS/4.",
 252         "Microsoft-IIS/5.",
 253         "Netscape-Enterprise/3.",
 254         nsnull
 255     };
 256
 257     for (const char **server = bad_servers; *server; ++server) {
 258         if (PL_strcasestr(val, *server) != nsnull) {
 259             LOG(("looks like this server does not support pipelining"));
 260             return PR_FALSE;
 261         }
 262     }
 263
 264     // ok, let's allow pipelining to this server
 265     return PR_TRUE;
 266 }
 267
 268 //----------------------------------------------------------------------------
 269 // nsHttpConnection::nsAHttpConnection compatible methods
 270 //----------------------------------------------------------------------------
 271
 272 nsresult
 273 nsHttpConnection::OnHeadersAvailable(nsAHttpTransaction *trans,
 274                                      nsHttpRequestHead *requestHead,
 275                                      nsHttpResponseHead *responseHead,
 276                                      PRBool *reset)
 277 {
 278     LOG(("nsHttpConnection::OnHeadersAvailable [this=%p trans=%p response-head=%p]\n",
 279         this, trans, responseHead));
 280
 281     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 282     NS_ENSURE_ARG_POINTER(trans);
 283     NS_ASSERTION(responseHead, "No response head?");
 284
 285     // If the server issued an explicit timeout, then we need to close down the
 286     // socket transport.  We pass an error code of NS_ERROR_NET_RESET to
 287     // trigger the transactions 'restart' mechanism.  We tell it to reset its
 288     // response headers so that it will be ready to receive the new response.
 289     if (responseHead->Status() == 408) {
 290         Close(NS_ERROR_NET_RESET);
 291         *reset = PR_TRUE;
 292         return NS_OK;
 293     }
 294
 295     // we won't change our keep-alive policy unless the server has explicitly
 296     // told us to do so.
 297
 298     // inspect the connection headers for keep-alive info provided the
 299     // transaction completed successfully.
 300     const char *val = responseHead->PeekHeader(nsHttp::Connection);
 301     if (!val)
 302         val = responseHead->PeekHeader(nsHttp::Proxy_Connection);
 303
 304     // reset to default (the server may have changed since we last checked)
 305     mSupportsPipelining = PR_FALSE;
 306
 307     if ((responseHead->Version() < NS_HTTP_VERSION_1_1) ||
 308         (requestHead->Version() < NS_HTTP_VERSION_1_1)) {
 309         // HTTP/1.0 connections are by default NOT persistent
 310         if (val && !PL_strcasecmp(val, "keep-alive"))
 311             mKeepAlive = PR_TRUE;
 312         else
 313             mKeepAlive = PR_FALSE;
 314     }
 315     else {
 316         // HTTP/1.1 connections are by default persistent
 317         if (val && !PL_strcasecmp(val, "close"))
 318             mKeepAlive = PR_FALSE;
 319         else {
 320             mKeepAlive = PR_TRUE;
 321
 322             // Do not support pipelining when we are establishing
 323             // an SSL tunnel though an HTTP proxy. Pipelining support
 324             // determination must be based on comunication with the
 325             // target server in this case. See bug 422016 for futher
 326             // details.
 327             if (!mSSLProxyConnectStream)
 328               mSupportsPipelining = SupportsPipelining(responseHead);
 329         }
 330     }
 331     mKeepAliveMask = mKeepAlive;
 332
 333     // if this connection is persistent, then the server may send a "Keep-Alive"
 334     // header specifying the maximum number of times the connection can be
 335     // reused as well as the maximum amount of time the connection can be idle
 336     // before the server will close it.  we ignore the max reuse count, because
 337     // a "keep-alive" connection is by definition capable of being reused, and
 338     // we only care about being able to reuse it once.  if a timeout is not
 339     // specified then we use our advertized timeout value.
 340     if (mKeepAlive) {
 341         val = responseHead->PeekHeader(nsHttp::Keep_Alive);
 342
 343         const char *cp = PL_strcasestr(val, "timeout=");
 344         if (cp)
 345             mIdleTimeout = (PRUint32) atoi(cp + 8);
 346         else
 347             mIdleTimeout = gHttpHandler->IdleTimeout();
 348
 349         LOG(("Connection can be reused [this=%x idle-timeout=%u]\n", this, mIdleTimeout));
 350     }
 351
 352     // if we're doing an SSL proxy connect, then we need to check whether or not
 353     // the connect was successful.  if so, then we have to reset the transaction
 354     // and step-up the socket connection to SSL. finally, we have to wake up the
 355     // socket write request.
 356     if (mSSLProxyConnectStream) {
 357         mSSLProxyConnectStream = 0;
 358         if (responseHead->Status() == 200) {
 359             LOG(("SSL proxy CONNECT succeeded!\n"));
 360             *reset = PR_TRUE;
 361             nsresult rv = ProxyStartSSL();
 362             if (NS_FAILED(rv)) // XXX need to handle this for real
 363                 LOG(("ProxyStartSSL failed [rv=%x]\n", rv));
 364             mCompletedSSLConnect = PR_TRUE;
 365             rv = mSocketOut->AsyncWait(this, 0, 0, nsnull);
 366             // XXX what if this fails -- need to handle this error
 367             NS_ASSERTION(NS_SUCCEEDED(rv), "mSocketOut->AsyncWait failed");
 368         }
 369         else {
 370             LOG(("SSL proxy CONNECT failed!\n"));
 371             // NOTE: this cast is valid since this connection cannot be
 372             // processing a transaction pipeline until after the first HTTP/1.1
 373             // response.
 374             nsHttpTransaction *trans =
 375                     static_cast<nsHttpTransaction *>(mTransaction);
 376             trans->SetSSLConnectFailed();
 377         }
 378     }
 379
 380     return NS_OK;
 381 }
 382
 383 void
 384 nsHttpConnection::GetSecurityInfo(nsISupports **secinfo)
 385 {
 386     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 387
 388     if (mSocketTransport) {
 389         if (NS_FAILED(mSocketTransport->GetSecurityInfo(secinfo)))
 390             *secinfo = nsnull;
 391     }
 392 }
 393
 394 nsresult
 395 nsHttpConnection::ResumeSend()
 396 {
 397     LOG(("nsHttpConnection::ResumeSend [this=%p]\n", this));
 398
 399     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 400
 401     if (mSocketOut)
 402         return mSocketOut->AsyncWait(this, 0, 0, nsnull);
 403
 404     NS_NOTREACHED("no socket output stream");
 405     return NS_ERROR_UNEXPECTED;
 406 }
 407
 408 nsresult
 409 nsHttpConnection::ResumeRecv()
 410 {
 411     LOG(("nsHttpConnection::ResumeRecv [this=%p]\n", this));
 412
 413     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 414
 415     if (mSocketIn)
 416         return mSocketIn->AsyncWait(this, 0, 0, nsnull);
 417
 418     NS_NOTREACHED("no socket input stream");
 419     return NS_ERROR_UNEXPECTED;
 420 }
 421
 422 //-----------------------------------------------------------------------------
 423 // nsHttpConnection <private>
 424 //-----------------------------------------------------------------------------
 425
 426 nsresult
 427 nsHttpConnection::CreateTransport(PRUint8 caps)
 428 {
 429     nsresult rv;
 430
 431     NS_PRECONDITION(!mSocketTransport, "unexpected");
 432
 433     nsCOMPtr<nsISocketTransportService> sts =
 434             do_GetService(kSocketTransportServiceCID, &rv);
 435     if (NS_FAILED(rv)) return rv;
 436
 437     // configure the socket type based on the connection type requested.
 438     const char* types[1];
 439
 440     if (mConnInfo->UsingSSL())
 441         types[0] = "ssl";
 442     else
 443         types[0] = gHttpHandler->DefaultSocketType();
 444
 445     nsCOMPtr<nsISocketTransport> strans;
 446     PRUint32 typeCount = (types[0] != nsnull);
 447
 448     rv = sts->CreateTransport(types, typeCount,
 449                               nsDependentCString(mConnInfo->Host()),
 450                               mConnInfo->Port(),
 451                               mConnInfo->ProxyInfo(),
 452                               getter_AddRefs(strans));
 453     if (NS_FAILED(rv)) return rv;
 454
 455     if (caps & NS_HTTP_REFRESH_DNS)
 456         strans->SetConnectionFlags(nsISocketTransport::BYPASS_CACHE);
 457
 458     // NOTE: these create cyclical references, which we break inside
 459     //       nsHttpConnection::Close
 460     rv = strans->SetEventSink(this, nsnull);
 461     if (NS_FAILED(rv)) return rv;
 462     rv = strans->SetSecurityCallbacks(this);
 463     if (NS_FAILED(rv)) return rv;
 464
 465     // next open the socket streams
 466     nsCOMPtr<nsIOutputStream> sout;
 467     rv = strans->OpenOutputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
 468                                   getter_AddRefs(sout));
 469     if (NS_FAILED(rv)) return rv;
 470     nsCOMPtr<nsIInputStream> sin;
 471     rv = strans->OpenInputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
 472                                  getter_AddRefs(sin));
 473     if (NS_FAILED(rv)) return rv;
 474
 475     mSocketTransport = strans;
 476     mSocketIn = do_QueryInterface(sin);
 477     mSocketOut = do_QueryInterface(sout);
 478     return NS_OK;
 479 }
 480
 481 void
 482 nsHttpConnection::CloseTransaction(nsAHttpTransaction *trans, nsresult reason)
 483 {
 484     LOG(("nsHttpConnection::CloseTransaction[this=%x trans=%x reason=%x]\n",
 485         this, trans, reason));
 486
 487     NS_ASSERTION(trans == mTransaction, "wrong transaction");
 488     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 489
 490     // mask this error code because its not a real error.
 491     if (reason == NS_BASE_STREAM_CLOSED)
 492         reason = NS_OK;
 493
 494     mTransaction->Close(reason);
 495
 496     NS_RELEASE(mTransaction);
 497     mTransaction = 0;
 498
 499     if (NS_FAILED(reason))
 500         Close(reason);
 501
 502     // flag the connection as reused here for convenience sake.  certainly
 503     // it might be going away instead ;-)
 504     mIsReused = PR_TRUE;
 505 }
 506
 507 NS_METHOD
 508 nsHttpConnection::ReadFromStream(nsIInputStream *input,
 509                                  void *closure,
 510                                  const char *buf,
 511                                  PRUint32 offset,
 512                                  PRUint32 count,
 513                                  PRUint32 *countRead)
 514 {
 515     // thunk for nsIInputStream instance
 516     nsHttpConnection *conn = (nsHttpConnection *) closure;
 517     return conn->OnReadSegment(buf, count, countRead);
 518 }
 519
 520 nsresult
 521 nsHttpConnection::OnReadSegment(const char *buf,
 522                                 PRUint32 count,
 523                                 PRUint32 *countRead)
 524 {
 525     if (count == 0) {
 526         // some ReadSegments implementations will erroneously call the writer
 527         // to consume 0 bytes worth of data.  we must protect against this case
 528         // or else we'd end up closing the socket prematurely.
 529         NS_ERROR("bad ReadSegments implementation");
 530         return NS_ERROR_FAILURE; // stop iterating
 531     }
 532
 533     nsresult rv = mSocketOut->Write(buf, count, countRead);
 534     if (NS_FAILED(rv))
 535         mSocketOutCondition = rv;
 536     else if (*countRead == 0)
 537         mSocketOutCondition = NS_BASE_STREAM_CLOSED;
 538     else
 539         mSocketOutCondition = NS_OK; // reset condition
 540
 541     return mSocketOutCondition;
 542 }
 543
 544 nsresult
 545 nsHttpConnection::OnSocketWritable()
 546 {
 547     LOG(("nsHttpConnection::OnSocketWritable [this=%x]\n", this));
 548
 549     nsresult rv;
 550     PRUint32 n;
 551     PRBool again = PR_TRUE;
 552
 553     do {
 554         // if we're doing an SSL proxy connect, then we need to bypass calling
 555         // into the transaction.
 556         //
 557         // NOTE: this code path can't be shared since the transaction doesn't
 558         // implement nsIInputStream.  doing so is not worth the added cost of
 559         // extra indirections during normal reading.
 560         //
 561         if (mSSLProxyConnectStream) {
 562             LOG(("  writing CONNECT request stream\n"));
 563             rv = mSSLProxyConnectStream->ReadSegments(ReadFromStream, this,
 564                                                       NS_HTTP_SEGMENT_SIZE, &n);
 565         }
 566         else {
 567             LOG(("  writing transaction request stream\n"));
 568             rv = mTransaction->ReadSegments(this, NS_HTTP_SEGMENT_SIZE, &n);
 569         }
 570
 571         LOG(("  ReadSegments returned [rv=%x read=%u sock-cond=%x]\n",
 572             rv, n, mSocketOutCondition));
 573
 574         // XXX some streams return NS_BASE_STREAM_CLOSED to indicate EOF.
 575         if (rv == NS_BASE_STREAM_CLOSED) {
 576             rv = NS_OK;
 577             n = 0;
 578         }
 579
 580         if (NS_FAILED(rv)) {
 581             // if the transaction didn't want to write any more data, then
 582             // wait for the transaction to call ResumeSend.
 583             if (rv == NS_BASE_STREAM_WOULD_BLOCK)
 584                 rv = NS_OK;
 585             again = PR_FALSE;
 586         }
 587         else if (NS_FAILED(mSocketOutCondition)) {
 588             if (mSocketOutCondition == NS_BASE_STREAM_WOULD_BLOCK)
 589                 rv = mSocketOut->AsyncWait(this, 0, 0, nsnull); // continue writing
 590             else
 591                 rv = mSocketOutCondition;
 592             again = PR_FALSE;
 593         }
 594         else if (n == 0) {
 595             //
 596             // at this point we've written out the entire transaction, and now we
 597             // must wait for the server's response.  we manufacture a status message
 598             // here to reflect the fact that we are waiting.  this message will be
 599             // trumped (overwritten) if the server responds quickly.
 600             //
 601             mTransaction->OnTransportStatus(nsISocketTransport::STATUS_WAITING_FOR,
 602                                             LL_ZERO);
 603
 604             rv = mSocketIn->AsyncWait(this, 0, 0, nsnull); // start reading
 605             again = PR_FALSE;
 606         }
 607         // write more to the socket until error or end-of-request...
 608     } while (again);
 609
 610     return rv;
 611 }
 612
 613 nsresult
 614 nsHttpConnection::OnWriteSegment(char *buf,
 615                                  PRUint32 count,
 616                                  PRUint32 *countWritten)
 617 {
 618     if (count == 0) {
 619         // some WriteSegments implementations will erroneously call the reader
 620         // to provide 0 bytes worth of data.  we must protect against this case
 621         // or else we'd end up closing the socket prematurely.
 622         NS_ERROR("bad WriteSegments implementation");
 623         return NS_ERROR_FAILURE; // stop iterating
 624     }
 625
 626     nsresult rv = mSocketIn->Read(buf, count, countWritten);
 627     if (NS_FAILED(rv))
 628         mSocketInCondition = rv;
 629     else if (*countWritten == 0)
 630         mSocketInCondition = NS_BASE_STREAM_CLOSED;
 631     else
 632         mSocketInCondition = NS_OK; // reset condition
 633
 634     return mSocketInCondition;
 635 }
 636
 637 nsresult
 638 nsHttpConnection::OnSocketReadable()
 639 {
 640     LOG(("nsHttpConnection::OnSocketReadable [this=%x]\n", this));
 641
 642     PRUint32 now = NowInSeconds();
 643
 644     if (mKeepAliveMask && (now - mLastReadTime >= PRUint32(mMaxHangTime))) {
 645         LOG(("max hang time exceeded!\n"));
 646         // give the handler a chance to create a new persistent connection to
 647         // this host if we've been busy for too long.
 648         mKeepAliveMask = PR_FALSE;
 649         gHttpHandler->ProcessPendingQ(mConnInfo);
 650     }
 651     mLastReadTime = now;
 652
 653     nsresult rv;
 654     PRUint32 n;
 655     PRBool again = PR_TRUE;
 656
 657     do {
 658         rv = mTransaction->WriteSegments(this, NS_HTTP_SEGMENT_SIZE, &n);
 659         if (NS_FAILED(rv)) {
 660             // if the transaction didn't want to take any more data, then
 661             // wait for the transaction to call ResumeRecv.
 662             if (rv == NS_BASE_STREAM_WOULD_BLOCK)
 663                 rv = NS_OK;
 664             again = PR_FALSE;
 665         }
 666         else if (NS_FAILED(mSocketInCondition)) {
 667             // continue waiting for the socket if necessary...
 668             if (mSocketInCondition == NS_BASE_STREAM_WOULD_BLOCK)
 669                 rv = mSocketIn->AsyncWait(this, 0, 0, nsnull);
 670             else
 671                 rv = mSocketInCondition;
 672             again = PR_FALSE;
 673         }
 674         // read more from the socket until error...
 675     } while (again);
 676
 677     return rv;
 678 }
 679
 680 nsresult
 681 nsHttpConnection::SetupSSLProxyConnect()
 682 {
 683     const char *val;
 684
 685     LOG(("nsHttpConnection::SetupSSLProxyConnect [this=%x]\n", this));
 686
 687     NS_ENSURE_TRUE(!mSSLProxyConnectStream, NS_ERROR_ALREADY_INITIALIZED);
 688
 689     nsCAutoString buf;
 690     buf.Assign(mConnInfo->Host());
 691     buf.Append(':');
 692     buf.AppendInt(mConnInfo->Port());
 693
 694     // CONNECT host:port HTTP/1.1
 695     nsHttpRequestHead request;
 696     request.SetMethod(nsHttp::Connect);
 697     request.SetVersion(gHttpHandler->HttpVersion());
 698     request.SetRequestURI(buf);
 699     request.SetHeader(nsHttp::User_Agent, gHttpHandler->UserAgent());
 700
 701     // send this header for backwards compatibility.
 702     request.SetHeader(nsHttp::Proxy_Connection, NS_LITERAL_CSTRING("keep-alive"));
 703
 704     // NOTE: this cast is valid since this connection cannot be processing a
 705     // transaction pipeline until after the first HTTP/1.1 response.
 706     nsHttpTransaction *trans = static_cast<nsHttpTransaction *>(mTransaction);
 707
 708     val = trans->RequestHead()->PeekHeader(nsHttp::Host);
 709     if (val) {
 710         // all HTTP/1.1 requests must include a Host header (even though it
 711         // may seem redundant in this case; see bug 82388).
 712         request.SetHeader(nsHttp::Host, nsDependentCString(val));
 713     }
 714
 715     val = trans->RequestHead()->PeekHeader(nsHttp::Proxy_Authorization);
 716     if (val) {
 717         // we don't know for sure if this authorization is intended for the
 718         // SSL proxy, so we add it just in case.
 719         request.SetHeader(nsHttp::Proxy_Authorization, nsDependentCString(val));
 720     }
 721
 722     buf.Truncate();
 723     request.Flatten(buf, PR_FALSE);
 724     buf.AppendLiteral("\r\n");
 725
 726     return NS_NewCStringInputStream(getter_AddRefs(mSSLProxyConnectStream), buf);
 727 }
 728
 729 //-----------------------------------------------------------------------------
 730 // nsHttpConnection::nsISupports
 731 //-----------------------------------------------------------------------------
 732
 733 NS_IMPL_THREADSAFE_ISUPPORTS4(nsHttpConnection,
 734                               nsIInputStreamCallback,
 735                               nsIOutputStreamCallback,
 736                               nsITransportEventSink,
 737                               nsIInterfaceRequestor)
 738
 739 //-----------------------------------------------------------------------------
 740 // nsHttpConnection::nsIInputStreamCallback
 741 //-----------------------------------------------------------------------------
 742
 743 // called on the socket transport thread
 744 NS_IMETHODIMP
 745 nsHttpConnection::OnInputStreamReady(nsIAsyncInputStream *in)
 746 {
 747     NS_ASSERTION(in == mSocketIn, "unexpected stream");
 748     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 749
 750     // if the transaction was dropped...
 751     if (!mTransaction) {
 752         LOG(("  no transaction; ignoring event\n"));
 753         return NS_OK;
 754     }
 755
 756     nsresult rv = OnSocketReadable();
 757     if (NS_FAILED(rv))
 758         CloseTransaction(mTransaction, rv);
 759
 760     return NS_OK;
 761 }
 762
 763 //-----------------------------------------------------------------------------
 764 // nsHttpConnection::nsIOutputStreamCallback
 765 //-----------------------------------------------------------------------------
 766
 767 NS_IMETHODIMP
 768 nsHttpConnection::OnOutputStreamReady(nsIAsyncOutputStream *out)
 769 {
 770     NS_ASSERTION(out == mSocketOut, "unexpected stream");
 771     NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
 772
 773     // if the transaction was dropped...
 774     if (!mTransaction) {
 775         LOG(("  no transaction; ignoring event\n"));
 776         return NS_OK;
 777     }
 778
 779     nsresult rv = OnSocketWritable();
 780     if (NS_FAILED(rv))
 781         CloseTransaction(mTransaction, rv);
 782
 783     return NS_OK;
 784 }
 785
 786 //-----------------------------------------------------------------------------
 787 // nsHttpConnection::nsITransportEventSink
 788 //-----------------------------------------------------------------------------
 789
 790 NS_IMETHODIMP
 791 nsHttpConnection::OnTransportStatus(nsITransport *trans,
 792                                     nsresult status,
 793                                     PRUint64 progress,
 794                                     PRUint64 progressMax)
 795 {
 796     if (mTransaction)
 797         mTransaction->OnTransportStatus(status, progress);
 798     return NS_OK;
 799 }
 800
 801 //-----------------------------------------------------------------------------
 802 // nsHttpConnection::nsIInterfaceRequestor
 803 //-----------------------------------------------------------------------------
 804
 805 // not called on the socket transport thread
 806 NS_IMETHODIMP
 807 nsHttpConnection::GetInterface(const nsIID &iid, void **result)
 808 {
 809     // NOTE: This function is only called on the UI thread via sync proxy from
 810     //       the socket transport thread.  If that weren't the case, then we'd
 811     //       have to worry about the possibility of mTransaction going away
 812     //       part-way through this function call.  See CloseTransaction.
 813     NS_ASSERTION(PR_GetCurrentThread() != gSocketThread, "wrong thread");
 814
 815     if (mTransaction) {
 816         nsCOMPtr<nsIInterfaceRequestor> callbacks;
 817         mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks));
 818         if (callbacks)
 819             return callbacks->GetInterface(iid, result);
 820     }
 821
 822     return NS_ERROR_NO_INTERFACE;
 823 }