Attachment #520642 for bug #623948

Attachment #520642: syn retry v5 for bug #623948

View | Details | Raw Unified | Return to bug 623948
Collapse All | Expand All





// for certain services (i.e. EF for VoIP, AF4x for interactive video,
// AF3x for broadcast/streaming video, etc)

// default value for HTTP
// in a DSCP environment this should be 40 (0x28, or AF11), per RFC-4594,
// Section 4.8 "High-Throughput Data Service Class"
pref("network.http.qos", 0);

// The number of milliseconds after sending a SYN for an HTTP connection,
// to wait before trying a different connection. 0 means do not use a second
// connection.
pref("network.http.connection-retry-timeout", 250);

// default values for FTP
// in a DSCP environment this should be 40 (0x28, or AF11), per RFC-4594,
// Section 4.8 "High-Throughput Data Service Class", and 80 (0x50, or AF22)
// per Section 4.7 "Low-Latency Data Service Class".
pref("network.ftp.data.qos", 0);
pref("network.ftp.control.qos", 0);

// </http>





    nsAutoLock lock(mLock);
    NS_IF_ADDREF(*callbacks = mCallbacks);
    return NS_OK;
}

NS_IMETHODIMP
nsSocketTransport::SetSecurityCallbacks(nsIInterfaceRequestor *callbacks)
{
    nsCOMPtr<nsISupports> secinfo;
    {
        nsAutoLock lock(mLock);
        mCallbacks = callbacks;
        SOCKET_LOG(("Reset callbacks for secinfo=%p callbacks=%p\n",
                    mSecInfo.get(), mCallbacks.get()));

        secinfo = mSecInfo;
    }

    // don't call into PSM while holding mLock!!
    nsCOMPtr<nsISSLSocketControl> secCtrl(do_QueryInterface(secinfo));
    if (secCtrl)
        secCtrl->SetNotificationCallbacks(callbacks);

    return NS_OK;
}

NS_IMETHODIMP
nsSocketTransport::SetEventSink(nsITransportEventSink *sink,
                                nsIEventTarget *target)
{
    nsCOMPtr<nsITransportEventSink> temp;





#define nsAHttpTransaction_h__

#include "nsISupports.h"

class nsAHttpConnection;
class nsAHttpSegmentReader;
class nsAHttpSegmentWriter;
class nsIInterfaceRequestor;
class nsIEventTarget;

//----------------------------------------------------------------------------
// Abstract base class for a HTTP transaction:
//
// A transaction is a "sink" for the response data.  The connection pushes
// data to the transaction by writing to it.  The transaction supports
// WriteSegments and may refuse to accept data if its buffers are full (its
// write function returns NS_BASE_STREAM_WOULD_BLOCK in this case).

class nsAHttpTransaction : public nsISupports
{
public:
    // called by the connection when it takes ownership of the transaction.
    virtual void SetConnection(nsAHttpConnection *) = 0;

    // called by the connection to get security callbacks to set on the 
    // socket transport.
    virtual void GetSecurityCallbacks(nsIInterfaceRequestor **,
                                      nsIEventTarget **) = 0;

    // called to report socket status (see nsITransportEventSink)
    virtual void OnTransportStatus(nsresult status, PRUint64 progress) = 0;

    // called to check the transaction status.
    virtual PRBool   IsDone() = 0;
    virtual nsresult Status() = 0;


                                   PRUint32 count, PRUint32 *countWritten) = 0;

    // called to close the transaction
    virtual void Close(nsresult reason) = 0;
};

#define NS_DECL_NSAHTTPTRANSACTION \
    void SetConnection(nsAHttpConnection *); \
    void GetSecurityCallbacks(nsIInterfaceRequestor **, \
                              nsIEventTarget **);       \
    void OnTransportStatus(nsresult status, PRUint64 progress); \
    PRBool   IsDone(); \
    nsresult Status(); \
    PRUint32 Available(); \
    nsresult ReadSegments(nsAHttpSegmentReader *, PRUint32, PRUint32 *); \
    nsresult WriteSegments(nsAHttpSegmentWriter *, PRUint32, PRUint32 *); \
    void     Close(nsresult reason);






#include "nsISocketTransportService.h"
#include "nsISocketTransport.h"
#include "nsIServiceManager.h"
#include "nsISSLSocketControl.h"
#include "nsStringStream.h"
#include "netCore.h"
#include "nsNetCID.h"
#include "nsAutoLock.h"
#include "nsProxyRelease.h"
#include "prmem.h"

#ifdef DEBUG
// defined by the socket transport service while active
extern PRThread *gSocketThread;
#endif

static NS_DEFINE_CID(kSocketTransportServiceCID, NS_SOCKETTRANSPORTSERVICE_CID);

//-----------------------------------------------------------------------------
// nsHttpConnection <public>
//-----------------------------------------------------------------------------

nsHttpConnection::nsHttpConnection()
    : mTransaction(nsnull)
    , mConnInfo(nsnull)
    , mLastReadTime(0)
    , mIdleTimeout(0)
    , mConsiderReusedAfterInterval(0)
    , mConsiderReusedAfterEpoch(0)
    , mKeepAlive(PR_TRUE) // assume to keep-alive by default
    , mKeepAliveMask(PR_TRUE)
    , mSupportsPipelining(PR_FALSE) // assume low-grade server
    , mIsReused(PR_FALSE)
    , mCompletedSSLConnect(PR_FALSE)
    , mLastTransactionExpectedNoContent(PR_FALSE)
{
    LOG(("Creating nsHttpConnection @%x\n", this));

    // grab a reference to the handler to ensure that it doesn't go away.
    nsHttpHandler *handler = gHttpHandler;
    NS_ADDREF(handler);
}

nsHttpConnection::~nsHttpConnection()
{
    LOG(("Destroying nsHttpConnection @%x\n", this));

    if (mCallbacks) {
        nsIInterfaceRequestor *cbs = nsnull;
        mCallbacks.swap(cbs);
        NS_ProxyRelease(mCallbackTarget, cbs);
    }

    // release our reference to the handler
    nsHttpHandler *handler = gHttpHandler;
    NS_RELEASE(handler);
}

nsresult
nsHttpConnection::Init(nsHttpConnectionInfo *info,
                       PRUint16 maxHangTime,
                       nsISocketTransport *transport,
                       nsIAsyncInputStream *instream,
                       nsIAsyncOutputStream *outstream,
                       nsIInterfaceRequestor *callbacks,
                       nsIEventTarget *callbackTarget)
{
    NS_ABORT_IF_FALSE(transport && instream && outstream,
                      "invalid socket information");
    LOG(("nsHttpConnection::Init [this=%p "
         "transport=%p instream=%p outstream=%p]\n",
         this, transport, instream, outstream));

    NS_ENSURE_ARG_POINTER(info);
    NS_ENSURE_TRUE(!mConnInfo, NS_ERROR_ALREADY_INITIALIZED);

    mConnInfo = info;
    NS_ADDREF(mConnInfo);

    mMaxHangTime = maxHangTime;
    mLastReadTime = NowInSeconds();

    mSocketTransport = transport;
    mSocketIn = instream;
    mSocketOut = outstream;
    nsresult rv = mSocketTransport->SetEventSink(this, nsnull);
    NS_ENSURE_SUCCESS(rv, rv);

    mCallbacks = callbacks;
    mCallbackTarget = callbackTarget;
    rv = mSocketTransport->SetSecurityCallbacks(this);
    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;
}

// called on the socket thread
nsresult
nsHttpConnection::Activate(nsAHttpTransaction *trans, PRUint8 caps)
{
    nsresult rv;

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
    LOG(("nsHttpConnection::Activate [this=%x trans=%x caps=%x]\n",
         this, trans, caps));

    NS_ENSURE_ARG_POINTER(trans);
    NS_ENSURE_TRUE(!mTransaction, NS_ERROR_IN_PROGRESS);

    // take ownership of the transaction
    mTransaction = trans;
    NS_ADDREF(mTransaction);

    // set mKeepAlive according to what will be requested
    mKeepAliveMask = mKeepAlive = (caps & NS_HTTP_ALLOW_KEEPALIVE);

    // if we don't have a socket transport then create a new one
    if (!mSocketTransport) {
        rv = CreateTransport(caps);
        if (NS_FAILED(rv))
            goto loser;
    }

    // need to handle SSL proxy CONNECT if this is the first time.
    if (mConnInfo->UsingSSL() && mConnInfo->UsingHttpProxy() && !mCompletedSSLConnect) {
        rv = SetupSSLProxyConnect();
        if (NS_FAILED(rv))
            goto failed_activation;
    }

    rv = OnOutputStreamReady(mSocketOut);
    
failed_activation:
    if (NS_FAILED(rv)) {
        mTransaction = nsnull;
    }

loser:
    NS_RELEASE(mTransaction);
    return rv;
}

void
nsHttpConnection::Close(nsresult reason)
{
    LOG(("nsHttpConnection::Close [this=%x reason=%x]\n", this, reason));

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");

    if (NS_FAILED(reason)) {
        if (mSocketTransport) {
            mSocketTransport->SetSecurityCallbacks(nsnull);
            mSocketTransport->SetEventSink(nsnull, nsnull);
            mSocketTransport->Close(reason);
        }
        mKeepAlive = PR_FALSE;

    if (NS_FAILED(rv)) return rv;

    return ssl->ProxyStartSSL();
}

PRBool
nsHttpConnection::CanReuse()
{
    PRBool canReuse = IsKeepAlive() &&
        (NowInSeconds() - mLastReadTime < mIdleTimeout) &&
        IsAlive();
    
    // An idle persistent connection should not have data waiting to be read
    // before a request is sent. Data here is likely a 408 timeout response
    // which we would deal with later on through the restart logic, but that
    // path is more expensive than just closing the socket now. SSL check can
    // be removed with fixing of 631801

    PRUint32 dataSize;
    if (canReuse && mSocketIn && !mConnInfo->UsingSSL() &&
        NS_SUCCEEDED(mSocketIn->Available(&dataSize)) && dataSize) {
        LOG(("nsHttpConnection::CanReuse %p %s"
             "Socket not reusable because read data pending (%d) on it.\n",
             this, mConnInfo->Host(), dataSize));
        canReuse = PR_FALSE;
    }
    return canReuse;
}

PRUint32 nsHttpConnection::TimeToLive()
{
    PRInt32 tmp = mIdleTimeout - (NowInSeconds() - mLastReadTime);
    if (0 > tmp)
        tmp = 0;


            NS_ASSERTION(NS_SUCCEEDED(rv), "mSocketOut->AsyncWait failed");
        }
        else {
            LOG(("SSL proxy CONNECT failed!\n"));
            // NOTE: this cast is valid since this connection cannot be
            // processing a transaction pipeline until after the first HTTP/1.1
            // response.
            nsHttpTransaction *trans =
                    static_cast<nsHttpTransaction *>(mTransaction.get());
            trans->SetSSLConnectFailed();
        }
    }

    return NS_OK;
}

PRBool
nsHttpConnection::IsReused()
{
    if (mIsReused) return PR_TRUE;
    if (!mConsiderReusedAfterInterval) return PR_FALSE;
    
    // ReusedAfter allows a socket to be consider reused only after a certain
    // interval of time has passed
    return (PR_IntervalNow() - mConsiderReusedAfterEpoch) >=
        mConsiderReusedAfterInterval;
}

void
nsHttpConnection::SetIsReusedAfter(PRUint32 afterMilliseconds)
{
    mConsiderReusedAfterEpoch = PR_IntervalNow();
    mConsiderReusedAfterInterval = PR_MillisecondsToInterval(afterMilliseconds);
}

void
nsHttpConnection::GetSecurityInfo(nsISupports **secinfo)
{
    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");

    if (mSocketTransport) {
        if (NS_FAILED(mSocketTransport->GetSecurityInfo(secinfo)))
            *secinfo = nsnull;

    NS_NOTREACHED("no socket input stream");
    return NS_ERROR_UNEXPECTED;
}

//-----------------------------------------------------------------------------
// nsHttpConnection <private>
//-----------------------------------------------------------------------------

nsresult
nsHttpConnection::CreateTransport(PRUint8 caps)
{
    nsresult rv;

    NS_PRECONDITION(!mSocketTransport, "unexpected");

    nsCOMPtr<nsISocketTransportService> sts =
            do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
    if (NS_FAILED(rv)) return rv;

    // configure the socket type based on the connection type requested.
    const char* types[1];

    if (mConnInfo->UsingSSL())
        types[0] = "ssl";
    else
        types[0] = gHttpHandler->DefaultSocketType();

    nsCOMPtr<nsISocketTransport> strans;
    PRUint32 typeCount = (types[0] != nsnull);

    rv = sts->CreateTransport(types, typeCount,
                              nsDependentCString(mConnInfo->Host()),
                              mConnInfo->Port(),
                              mConnInfo->ProxyInfo(),
                              getter_AddRefs(strans));
    if (NS_FAILED(rv)) return rv;

    PRUint32 tmpFlags = 0;
    if (caps & NS_HTTP_REFRESH_DNS)
        tmpFlags = nsISocketTransport::BYPASS_CACHE;
    
    if (caps & NS_HTTP_LOAD_ANONYMOUS)
        tmpFlags |= nsISocketTransport::ANONYMOUS_CONNECT;
    
    strans->SetConnectionFlags(tmpFlags); 

    strans->SetQoSBits(gHttpHandler->GetQoSBits());

    // NOTE: these create cyclical references, which we break inside
    //       nsHttpConnection::Close
    rv = strans->SetEventSink(this, nsnull);
    if (NS_FAILED(rv)) return rv;
    rv = strans->SetSecurityCallbacks(this);
    if (NS_FAILED(rv)) return rv;

    // next open the socket streams
    nsCOMPtr<nsIOutputStream> sout;
    rv = strans->OpenOutputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
                                  getter_AddRefs(sout));
    if (NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIInputStream> sin;
    rv = strans->OpenInputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
                                 getter_AddRefs(sin));
    if (NS_FAILED(rv)) return rv;

    mSocketTransport = strans;
    mSocketIn = do_QueryInterface(sin);
    mSocketOut = do_QueryInterface(sout);
    return NS_OK;
}

void
nsHttpConnection::CloseTransaction(nsAHttpTransaction *trans, nsresult reason)
{
    LOG(("nsHttpConnection::CloseTransaction[this=%x trans=%x reason=%x]\n",
        this, trans, reason));

    NS_ASSERTION(trans == mTransaction, "wrong transaction");
    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");

    // mask this error code because its not a real error.
    if (reason == NS_BASE_STREAM_CLOSED)
        reason = NS_OK;

    mTransaction->Close(reason);
    mTransaction = nsnull;
    NS_RELEASE(mTransaction);
    mTransaction = 0;

    if (NS_FAILED(reason))
        Close(reason);

    // flag the connection as reused here for convenience sake.  certainly
    // it might be going away instead ;-)
    mIsReused = PR_TRUE;
}

    request.SetRequestURI(buf);
    request.SetHeader(nsHttp::User_Agent, gHttpHandler->UserAgent());

    // send this header for backwards compatibility.
    request.SetHeader(nsHttp::Proxy_Connection, NS_LITERAL_CSTRING("keep-alive"));

    // NOTE: this cast is valid since this connection cannot be processing a
    // transaction pipeline until after the first HTTP/1.1 response.
    nsHttpTransaction *trans =
        static_cast<nsHttpTransaction *>(mTransaction.get());
    
    val = trans->RequestHead()->PeekHeader(nsHttp::Host);
    if (val) {
        // all HTTP/1.1 requests must include a Host header (even though it
        // may seem redundant in this case; see bug 82388).
        request.SetHeader(nsHttp::Host, nsDependentCString(val));
    }



//-----------------------------------------------------------------------------
// nsHttpConnection::nsIOutputStreamCallback
//-----------------------------------------------------------------------------

NS_IMETHODIMP
nsHttpConnection::OnOutputStreamReady(nsIAsyncOutputStream *out)
{
    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");
    NS_ABORT_IF_FALSE(out == mSocketOut, "unexpected socket");

    // if the transaction was dropped...
    if (!mTransaction) {
        LOG(("  no transaction; ignoring event\n"));
        return NS_OK;
    }

    nsresult rv = OnSocketWritable();

// not called on the socket transport thread
NS_IMETHODIMP
nsHttpConnection::GetInterface(const nsIID &iid, void **result)
{
    // NOTE: This function is only called on the UI thread via sync proxy from
    //       the socket transport thread.  If that weren't the case, then we'd
    //       have to worry about the possibility of mTransaction going away
    //       part-way through this function call.  See CloseTransaction.

    // NOTE - there is a bug here, the call to getinterface is proxied off the
    // nss thread, not the ui thread as the above comment says. So there is
    // indeed a chance of mTransaction going away. bug 615342

    NS_ASSERTION(PR_GetCurrentThread() != gSocketThread, "wrong thread");
 
    if (mTransaction) {
        nsCOMPtr<nsIInterfaceRequestor> callbacks;
        mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks));
        if (callbacks)
            return callbacks->GetInterface(iid, result);
    }

    if (mCallbacks)
        return mCallbacks->GetInterface(iid, result);
    return NS_ERROR_NO_INTERFACE;
}





#include "nsHttp.h"
#include "nsHttpConnectionInfo.h"
#include "nsAHttpConnection.h"
#include "nsAHttpTransaction.h"
#include "nsXPIDLString.h"
#include "nsCOMPtr.h"
#include "prlock.h"
#include "nsAutoPtr.h"
#include "prinrval.h"

#include "nsIStreamListener.h"
#include "nsISocketTransport.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#include "nsIInterfaceRequestor.h"
#include "nsIEventTarget.h"

//-----------------------------------------------------------------------------
// nsHttpConnection - represents a connection to a HTTP server (or proxy)
//
// NOTE: this objects lives on the socket thread only.  it should not be
// accessed from any other thread.
//-----------------------------------------------------------------------------


    nsHttpConnection();
    virtual ~nsHttpConnection();

    // Initialize the connection:
    //  info        - specifies the connection parameters.
    //  maxHangTime - limits the amount of time this connection can spend on a
    //                single transaction before it should no longer be kept 
    //                alive.  a value of 0xffff indicates no limit.
    nsresult Init(nsHttpConnectionInfo *info, PRUint16 maxHangTime,
                  nsISocketTransport *, nsIAsyncInputStream *,
                  nsIAsyncOutputStream *, nsIInterfaceRequestor *,
                  nsIEventTarget *);

    // Activate causes the given transaction to be processed on this
    // connection.  It fails if there is already an existing transaction.
    nsresult Activate(nsAHttpTransaction *, PRUint8 caps);

    // Close the underlying socket transport.
    void Close(nsresult reason);


    nsHttpConnectionInfo *ConnectionInfo() { return mConnInfo; }

    // nsAHttpConnection compatible methods (non-virtual):
    nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, PRBool *reset);
    void     CloseTransaction(nsAHttpTransaction *, nsresult reason);
    void     GetConnectionInfo(nsHttpConnectionInfo **ci) { NS_IF_ADDREF(*ci = mConnInfo); }
    void     GetSecurityInfo(nsISupports **);
    PRBool   IsPersistent() { return IsKeepAlive(); }
    PRBool   IsReused();
    void     SetIsReusedAfter(PRUint32 afterMilliseconds);
    void     SetIdleTimeout(PRUint16 val) {mIdleTimeout = val;}
    nsresult PushBack(const char *data, PRUint32 length) { NS_NOTREACHED("PushBack"); return NS_ERROR_UNEXPECTED; }
    nsresult ResumeSend();
    nsresult ResumeRecv();

    static NS_METHOD ReadFromStream(nsIInputStream *, void *, const char *,
                                    PRUint32, PRUint32, PRUint32 *);

private:
    // called to cause the underlying socket to start speaking SSL
    nsresult ProxyStartSSL();

    nsresult CreateTransport(PRUint8 caps);
    nsresult OnTransactionDone(nsresult reason);
    nsresult OnSocketWritable();
    nsresult OnSocketReadable();

    nsresult SetupSSLProxyConnect();

    PRBool   IsAlive();
    PRBool   SupportsPipelining(nsHttpResponseHead *);

    nsCOMPtr<nsIAsyncOutputStream>  mSocketOut;

    nsresult                        mSocketInCondition;
    nsresult                        mSocketOutCondition;

    nsCOMPtr<nsIInputStream>        mSSLProxyConnectStream;
    nsCOMPtr<nsIInputStream>        mRequestStream;

    // mTransaction only points to the HTTP Transaction callbacks if the
    // transaction is open, otherwise it is null.
    nsRefPtr<nsAHttpTransaction>    mTransaction;

    nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
    nsCOMPtr<nsIEventTarget>        mCallbackTarget;

    nsRefPtr<nsHttpConnectionInfo> mConnInfo;

    PRUint32                        mLastReadTime;
    PRUint16                        mMaxHangTime;    // max download time before dropping keep-alive status
    PRUint16                        mIdleTimeout;    // value of keep-alive: timeout=
    PRIntervalTime                  mConsiderReusedAfterInterval;
    PRIntervalTime                  mConsiderReusedAfterEpoch;

    PRPackedBool                    mKeepAlive;
    PRPackedBool                    mKeepAliveMask;
    PRPackedBool                    mSupportsPipelining;
    PRPackedBool                    mIsReused;
    PRPackedBool                    mCompletedSSLConnect;
    PRPackedBool                    mLastTransactionExpectedNoContent;
};

(-)a/netwerk/protocol/http/nsHttpConnectionMgr.cpp (-44 / +417 lines)

Line	Link Here

Lines 395-428 nsHttpConnectionMgr::ProcessOneTransacti	Link Here

395

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

395

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

396

397

    if (self->ProcessPendingQForEntry(ent))

397

    if (self->ProcessPendingQForEntry(ent))

398

        return kHashEnumerateStop;

398

        return kHashEnumerateStop;

399

400

    return kHashEnumerateNext;

400

    return kHashEnumerateNext;

401

402

403

// If the global number of idle connections is preventing the opening of

404

// new connections to a host without idle connections, then

405

// close them regardless of their TTL

403

PRIntn

406

PRIntn

404

nsHttpConnectionMgr::PurgeOneIdleConnectionCB(nsHashKey *key, void *data, void *closure)

407

nsHttpConnectionMgr::PurgeExcessIdleConnectionsCB(nsHashKey *key,

408

                                                  void *data, void *closure)

405

409

406

    nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;

410

    nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;

407

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

411

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

408

412

409

    if (ent->mIdleConns.Length() > 0) {

413

    while (self->mNumIdleConns + self->mNumActiveConns + 1 >= self->mMaxConns) {

414

        if (!ent->mIdleConns.Length()) {

415

            // There are no idle conns left in this connection entry

416

            return kHashEnumerateNext;

417

410

        nsHttpConnection *conn = ent->mIdleConns[0];

418

        nsHttpConnection *conn = ent->mIdleConns[0];

411

        ent->mIdleConns.RemoveElementAt(0);

419

        ent->mIdleConns.RemoveElementAt(0);

412

        conn->Close(NS_ERROR_ABORT);

420

        conn->Close(NS_ERROR_ABORT);

413

        NS_RELEASE(conn);

421

        NS_RELEASE(conn);

414

        self->mNumIdleConns--;

422

        self->mNumIdleConns--;

415

        if (0 == self->mNumIdleConns)

423

        if (0 == self->mNumIdleConns)

416

            self->StopPruneDeadConnectionsTimer();

424

            self->StopPruneDeadConnectionsTimer();

417

        return kHashEnumerateStop;

418

425

419

426

    return kHashEnumerateStop;

420

    return kHashEnumerateNext;

421

427

422

428

423

PRIntn

429

PRIntn

424

nsHttpConnectionMgr::PruneDeadConnectionsCB(nsHashKey *key, void *data, void *closure)

430

nsHttpConnectionMgr::PruneDeadConnectionsCB(nsHashKey *key, void *data, void *closure)

425

431

426

    nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;

432

    nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;

427

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

433

    nsConnectionEntry *ent = (nsConnectionEntry *) data;

428

434

Lines 469-484 nsHttpConnectionMgr::PruneDeadConnection	Link Here

469

            LOG(("    active conn [%x] with trans [%x]\n", conn, conn->Transaction()));

475

            LOG(("    active conn [%x] with trans [%x]\n", conn, conn->Transaction()));

470

476

471

477

472

#endif

478

#endif

473

479

474

    // if this entry is empty, then we can remove it.

480

    // if this entry is empty, then we can remove it.

475

    if (ent->mIdleConns.Length()   == 0 &&

481

    if (ent->mIdleConns.Length()   == 0 &&

476

        ent->mActiveConns.Length() == 0 &&

482

        ent->mActiveConns.Length() == 0 &&

483

        ent->mHalfOpens.Length()   == 0 &&

477

        ent->mPendingQ.Length()    == 0) {

484

        ent->mPendingQ.Length()    == 0) {

478

        LOG(("    removing empty connection entry\n"));

485

        LOG(("    removing empty connection entry\n"));

479

        delete ent;

486

        delete ent;

480

        return kHashEnumerateRemove;

487

        return kHashEnumerateRemove;

481

488

482

489

483

    // else, use this opportunity to compact our arrays...

490

    // else, use this opportunity to compact our arrays...

484

    ent->mIdleConns.Compact();

491

    ent->mIdleConns.Compact();

Lines 528-543 nsHttpConnectionMgr::ShutdownPassCB(nsHa	Link Here

528

        trans = ent->mPendingQ[0];

535

        trans = ent->mPendingQ[0];

529

536

530

        ent->mPendingQ.RemoveElementAt(0);

537

        ent->mPendingQ.RemoveElementAt(0);

531

538

532

        trans->Close(NS_ERROR_ABORT);

539

        trans->Close(NS_ERROR_ABORT);

533

        NS_RELEASE(trans);

540

        NS_RELEASE(trans);

534

541

535

542

543

    // close all half open tcp connections

544

    for (PRInt32 i = ((PRInt32) ent->mHalfOpens.Length()) - 1; i >= 0; i--)

545

        ent->mHalfOpens[i]->Abandon();

546

536

    delete ent;

547

    delete ent;

537

    return kHashEnumerateRemove;

548

    return kHashEnumerateRemove;

538

549

539

550

540

//-----------------------------------------------------------------------------

551

//-----------------------------------------------------------------------------

541

552

542

PRBool

553

PRBool

543

nsHttpConnectionMgr::ProcessPendingQForEntry(nsConnectionEntry *ent)

554

nsHttpConnectionMgr::ProcessPendingQForEntry(nsConnectionEntry *ent)

Lines 547-563 nsHttpConnectionMgr::ProcessPendingQForE	Link Here

547

558

548

    PRInt32 i, count = ent->mPendingQ.Length();

559

    PRInt32 i, count = ent->mPendingQ.Length();

549

    if (count > 0) {

560

    if (count > 0) {

550

        LOG(("  pending-count=%u\n", count));

561

        LOG(("  pending-count=%u\n", count));

551

        nsHttpTransaction *trans = nsnull;

562

        nsHttpTransaction *trans = nsnull;

552

        nsHttpConnection *conn = nsnull;

563

        nsHttpConnection *conn = nsnull;

553

        for (i=0; i<count; ++i) {

564

        for (i=0; i<count; ++i) {

554

            trans = ent->mPendingQ[i];

565

            trans = ent->mPendingQ[i];

555

            GetConnection(ent, trans->Caps(), &conn);

566

            GetConnection(ent, trans, &conn);

556

            if (conn)

567

            if (conn)

557

                break;

568

                break;

558

569

559

        if (conn) {

570

        if (conn) {

560

            LOG(("  dispatching pending transaction...\n"));

571

            LOG(("  dispatching pending transaction...\n"));

561

572

562

            // remove pending transaction

573

            // remove pending transaction

563

            ent->mPendingQ.RemoveElementAt(i);

574

            ent->mPendingQ.RemoveElementAt(i);

Lines 587-604 nsHttpConnectionMgr::ProcessPendingQForE	Link Here

587

PRBool

598

PRBool

588

nsHttpConnectionMgr::AtActiveConnectionLimit(nsConnectionEntry *ent, PRUint8 caps)

599

nsHttpConnectionMgr::AtActiveConnectionLimit(nsConnectionEntry *ent, PRUint8 caps)

589

600

590

    nsHttpConnectionInfo *ci = ent->mConnInfo;

601

    nsHttpConnectionInfo *ci = ent->mConnInfo;

591

602

592

    LOG(("nsHttpConnectionMgr::AtActiveConnectionLimit [ci=%s caps=%x]\n",

603

    LOG(("nsHttpConnectionMgr::AtActiveConnectionLimit [ci=%s caps=%x]\n",

593

        ci->HashKey().get(), caps));

604

        ci->HashKey().get(), caps));

594

605

595

    // If we have more active connections than the limit, then we're done --

606

    // If there are more active connections than the global limit, then we're

596

    // purging idle connections won't get us below it.

607

    // done. Purging idle connections won't get us below it.

597

    if (mNumActiveConns >= mMaxConns) {

608

    if (mNumActiveConns >= mMaxConns) {

598

        LOG(("  num active conns == max conns\n"));

609

        LOG(("  num active conns == max conns\n"));

599

        return PR_TRUE;

610

        return PR_TRUE;

600

611

601

612

602

    nsHttpConnection *conn;

613

    nsHttpConnection *conn;

603

    PRInt32 i, totalCount, persistCount = 0;

614

    PRInt32 i, totalCount, persistCount = 0;

604

615

Lines 606-621 nsHttpConnectionMgr::AtActiveConnectionL	Link Here

606

617

607

    // count the number of persistent connections

618

    // count the number of persistent connections

608

    for (i=0; i<totalCount; ++i) {

619

    for (i=0; i<totalCount; ++i) {

609

        conn = ent->mActiveConns[i];

620

        conn = ent->mActiveConns[i];

610

        if (conn->IsKeepAlive()) // XXX make sure this is thread-safe

621

        if (conn->IsKeepAlive()) // XXX make sure this is thread-safe

611

            persistCount++;

622

            persistCount++;

612

623

613

624

625

    // Add in the in-progress tcp connections, we will assume they are

626

    // keepalive enabled.

627

    totalCount += ent->mHalfOpens.Length();

628

    persistCount += ent->mHalfOpens.Length();

629

614

    LOG(("   total=%d, persist=%d\n", totalCount, persistCount));

630

    LOG(("   total=%d, persist=%d\n", totalCount, persistCount));

615

631

616

    PRUint16 maxConns;

632

    PRUint16 maxConns;

617

    PRUint16 maxPersistConns;

633

    PRUint16 maxPersistConns;

618

634

619

    if (ci->UsingHttpProxy() && !ci->UsingSSL()) {

635

    if (ci->UsingHttpProxy() && !ci->UsingSSL()) {

620

        maxConns = mMaxConnsPerProxy;

636

        maxConns = mMaxConnsPerProxy;

621

        maxPersistConns = mMaxPersistConnsPerProxy;

637

        maxPersistConns = mMaxPersistConnsPerProxy;

Lines 626-653 nsHttpConnectionMgr::AtActiveConnectionL	Link Here

626

642

627

643

628

    // use >= just to be safe

644

    // use >= just to be safe

629

    return (totalCount >= maxConns) || ( (caps & NS_HTTP_ALLOW_KEEPALIVE) &&

645

    return (totalCount >= maxConns) || ( (caps & NS_HTTP_ALLOW_KEEPALIVE) &&

630

                                         (persistCount >= maxPersistConns) );

646

                                         (persistCount >= maxPersistConns) );

631

647

632

648

633

void

649

void

634

nsHttpConnectionMgr::GetConnection(nsConnectionEntry *ent, PRUint8 caps,

650

nsHttpConnectionMgr::GetConnection(nsConnectionEntry *ent,

651

                                   nsHttpTransaction *trans,

635

                                   nsHttpConnection **result)

652

                                   nsHttpConnection **result)

636

653

637

    LOG(("nsHttpConnectionMgr::GetConnection [ci=%s caps=%x]\n",

654

    LOG(("nsHttpConnectionMgr::GetConnection [ci=%s caps=%x]\n",

638

        ent->mConnInfo->HashKey().get(), PRUint32(caps)));

655

        ent->mConnInfo->HashKey().get(), PRUint32(trans->Caps())));

656

657

    // First, see if an idle persistent connection may be reused instead of

658

    // establishing a new socket. We do not need to check the connection limits

659

    // yet as they govern the maximum number of open connections and reusing

660

    // an old connection never increases that.

639

661

640

    *result = nsnull;

662

    *result = nsnull;

641

663

642

    nsHttpConnection *conn = nsnull;

664

    nsHttpConnection *conn = nsnull;

643

665

644

    if (caps & NS_HTTP_ALLOW_KEEPALIVE) {

666

    if (trans->Caps() & NS_HTTP_ALLOW_KEEPALIVE) {

645

        // search the idle connection list

667

        // search the idle connection list. Each element in the list

668

        // has a reference, so if we remove it from the list into a local

669

        // ptr, that ptr now owns the reference

646

        while (!conn && (ent->mIdleConns.Length() > 0)) {

670

        while (!conn && (ent->mIdleConns.Length() > 0)) {

647

            conn = ent->mIdleConns[0];

671

            conn = ent->mIdleConns[0];

648

            // we check if the connection can be reused before even checking if

672

            // we check if the connection can be reused before even checking if

649

            // it is a "matching" connection.

673

            // it is a "matching" connection.

650

            if (!conn->CanReuse()) {

674

            if (!conn->CanReuse()) {

651

                LOG(("   dropping stale connection: [conn=%x]\n", conn));

675

                LOG(("   dropping stale connection: [conn=%x]\n", conn));

652

                conn->Close(NS_ERROR_ABORT);

676

                conn->Close(NS_ERROR_ABORT);

653

                NS_RELEASE(conn);

677

                NS_RELEASE(conn);

Lines 667-707 nsHttpConnectionMgr::GetConnection(nsCon	Link Here

667

    if (!conn) {

691

    if (!conn) {

668

        // Check if we need to purge an idle connection. Note that we may have

692

        // Check if we need to purge an idle connection. Note that we may have

669

        // removed one above; if so, this will be a no-op. We do this before

693

        // removed one above; if so, this will be a no-op. We do this before

670

        // checking the active connection limit to catch the case where we do

694

        // checking the active connection limit to catch the case where we do

671

        // have an idle connection, but the purge timer hasn't fired yet.

695

        // have an idle connection, but the purge timer hasn't fired yet.

672

        // XXX this just purges a random idle connection.  we should instead

696

        // XXX this just purges a random idle connection.  we should instead

673

        // enumerate the entire hash table to find the eldest idle connection.

697

        // enumerate the entire hash table to find the eldest idle connection.

674

        if (mNumIdleConns && mNumIdleConns + mNumActiveConns + 1 >= mMaxConns)

698

        if (mNumIdleConns && mNumIdleConns + mNumActiveConns + 1 >= mMaxConns)

675

            mCT.Enumerate(PurgeOneIdleConnectionCB, this);

699

            mCT.Enumerate(PurgeExcessIdleConnectionsCB, this);

676

700

677

        // Need to make a new TCP connection. First, we check if we've hit

701

        // Need to make a new TCP connection. First, we check if we've hit

678

        // either the maximum connection limit globally or for this particular

702

        // either the maximum connection limit globally or for this particular

679

        // host or proxy. If we have, we're done.

703

        // host or proxy. If we have, we're done.

680

        if (AtActiveConnectionLimit(ent, caps)) {

704

        if (AtActiveConnectionLimit(ent, trans->Caps())) {

681

            LOG(("  at active connection limit!\n"));

705

            LOG(("nsHttpConnectionMgr::GetConnection [ci = %s]"

706

                 "at active connection limit - will queue\n",

707

                 ent->mConnInfo->HashKey().get()));

682

            return;

708

            return;

683

709

684

710

685

        conn = new nsHttpConnection();

711

        nsresult rv = CreateTransport(ent, trans);

686

        if (!conn)

712

        if (NS_FAILED(rv))

687

            return;

713

            trans->Close(rv);

688

        NS_ADDREF(conn);

714

        return;

689

690

        nsresult rv = conn->Init(ent->mConnInfo, mMaxRequestDelay);

691

        if (NS_FAILED(rv)) {

692

            NS_RELEASE(conn);

693

            return;

694

695

715

696

716

717

    // hold an owning ref to this connection

718

    ent->mActiveConns.AppendElement(conn);

719

    mNumActiveConns++;

720

    NS_ADDREF(conn);

721

697

    *result = conn;

722

    *result = conn;

698

723

699

724

725

void

726

nsHttpConnectionMgr::AddActiveConn(nsHttpConnection *conn,

727

                                   nsConnectionEntry *ent)

728

729

    NS_ADDREF(conn);

730

    ent->mActiveConns.AppendElement(conn);

731

    mNumActiveConns++;

732

733

734

void

735

nsHttpConnectionMgr::StartedConnect()

736

737

    mNumActiveConns++;

738

739

740

void

741

nsHttpConnectionMgr::RecvdConnect()

742

743

    mNumActiveConns--;

744

745

746

nsresult

747

nsHttpConnectionMgr::CreateTransport(nsConnectionEntry *ent,

748

                                     nsHttpTransaction *trans)

749

750

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");

751

752

    nsRefPtr<nsHalfOpenSocket> sock = new nsHalfOpenSocket(ent, trans);

753

    nsresult rv = sock->SetupPrimaryStreams();

754

    NS_ENSURE_SUCCESS(rv, rv);

755

756

    sock->SetupBackupTimer();

757

    ent->mHalfOpens.AppendElement(sock);

758

    return NS_OK;

759

760

700

nsresult

761

nsresult

701

nsHttpConnectionMgr::DispatchTransaction(nsConnectionEntry *ent,

762

nsHttpConnectionMgr::DispatchTransaction(nsConnectionEntry *ent,

702

                                         nsAHttpTransaction *trans,

763

                                         nsAHttpTransaction *trans,

703

                                         PRUint8 caps,

764

                                         PRUint8 caps,

704

                                         nsHttpConnection *conn)

765

                                         nsHttpConnection *conn)

705

766

706

    LOG(("nsHttpConnectionMgr::DispatchTransaction [ci=%s trans=%x caps=%x conn=%x]\n",

767

    LOG(("nsHttpConnectionMgr::DispatchTransaction [ci=%s trans=%x caps=%x conn=%x]\n",

707

        ent->mConnInfo->HashKey().get(), trans, caps, conn));

768

        ent->mConnInfo->HashKey().get(), trans, caps, conn));

Lines 713-733 nsHttpConnectionMgr::DispatchTransaction	Link Here

713

774

714

    nsHttpPipeline *pipeline = nsnull;

775

    nsHttpPipeline *pipeline = nsnull;

715

    if (conn->SupportsPipelining() && (caps & NS_HTTP_ALLOW_PIPELINING)) {

776

    if (conn->SupportsPipelining() && (caps & NS_HTTP_ALLOW_PIPELINING)) {

716

        LOG(("  looking to build pipeline...\n"));

777

        LOG(("  looking to build pipeline...\n"));

717

        if (BuildPipeline(ent, trans, &pipeline))

778

        if (BuildPipeline(ent, trans, &pipeline))

718

            trans = pipeline;

779

            trans = pipeline;

719

780

720

781

721

    // hold an owning ref to this connection

722

    ent->mActiveConns.AppendElement(conn);

723

    mNumActiveConns++;

724

    NS_ADDREF(conn);

725

726

    // give the transaction the indirect reference to the connection.

782

    // give the transaction the indirect reference to the connection.

727

    trans->SetConnection(handle);

783

    trans->SetConnection(handle);

728

784

729

    nsresult rv = conn->Activate(trans, caps);

785

    nsresult rv = conn->Activate(trans, caps);

730

786

731

    if (NS_FAILED(rv)) {

787

    if (NS_FAILED(rv)) {

732

        LOG(("  conn->Activate failed [rv=%x]\n", rv));

788

        LOG(("  conn->Activate failed [rv=%x]\n", rv));

733

        ent->mActiveConns.RemoveElement(conn);

789

        ent->mActiveConns.RemoveElement(conn);

Lines 790-805 nsHttpConnectionMgr::BuildPipeline(nsCon	Link Here

790

    LOG(("  pipelined %u transactions\n", numAdded));

846

    LOG(("  pipelined %u transactions\n", numAdded));

791

    NS_ADDREF(*result = pipeline);

847

    NS_ADDREF(*result = pipeline);

792

    return PR_TRUE;

848

    return PR_TRUE;

793

849

794

850

795

nsresult

851

nsresult

796

nsHttpConnectionMgr::ProcessNewTransaction(nsHttpTransaction *trans)

852

nsHttpConnectionMgr::ProcessNewTransaction(nsHttpTransaction *trans)

797

853

854

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");

855

798

    // since "adds" and "cancels" are processed asynchronously and because

856

    // since "adds" and "cancels" are processed asynchronously and because

799

    // various events might trigger an "add" directly on the socket thread,

857

    // various events might trigger an "add" directly on the socket thread,

800

    // we must take care to avoid dispatching a transaction that has already

858

    // we must take care to avoid dispatching a transaction that has already

801

    // been canceled (see bug 190001).

859

    // been canceled (see bug 190001).

802

    if (NS_FAILED(trans->Status())) {

860

    if (NS_FAILED(trans->Status())) {

803

        LOG(("  transaction was canceled... dropping event!\n"));

861

        LOG(("  transaction was canceled... dropping event!\n"));

804

        return NS_OK;

862

        return NS_OK;

805

863

Lines 832-859 nsHttpConnectionMgr::ProcessNewTransacti	Link Here

832

890

833

        // steal reference from connection handle.

891

        // steal reference from connection handle.

834

        // XXX prevent SetConnection(nsnull) from calling ReclaimConnection

892

        // XXX prevent SetConnection(nsnull) from calling ReclaimConnection

835

        conn = handle->mConn;

893

        conn = handle->mConn;

836

        handle->mConn = nsnull;

894

        handle->mConn = nsnull;

837

895

838

        // destroy connection handle.

896

        // destroy connection handle.

839

        trans->SetConnection(nsnull);

897

        trans->SetConnection(nsnull);

840

841

        // remove sticky connection from active connection list; we'll add it

842

        // right back in DispatchTransaction.

843

        if (ent->mActiveConns.RemoveElement(conn))

844

            mNumActiveConns--;

845

        else {

846

            NS_ERROR("sticky connection not found in active list");

847

            return NS_ERROR_UNEXPECTED;

848

849

898

850

    else

899

    else

851

        GetConnection(ent, caps, &conn);

900

        GetConnection(ent, trans, &conn);

852

901

853

    nsresult rv;

902

    nsresult rv;

854

    if (!conn) {

903

    if (!conn) {

855

        LOG(("  adding transaction to pending queue [trans=%x pending-count=%u]\n",

904

        LOG(("  adding transaction to pending queue [trans=%x pending-count=%u]\n",

856

            trans, ent->mPendingQ.Length()+1));

905

            trans, ent->mPendingQ.Length()+1));

857

        // put this transaction on the pending queue...

906

        // put this transaction on the pending queue...

858

        InsertTransactionSorted(ent->mPendingQ, trans);

907

        InsertTransactionSorted(ent->mPendingQ, trans);

859

        NS_ADDREF(trans);

908

        NS_ADDREF(trans);

Lines 993-1030 nsHttpConnectionMgr::OnMsgReclaimConnect	Link Here

993

    nsHttpConnectionInfo *ci = conn->ConnectionInfo();

1042

    nsHttpConnectionInfo *ci = conn->ConnectionInfo();

994

    NS_ADDREF(ci);

1043

    NS_ADDREF(ci);

995

1044

996

    nsCStringKey key(ci->HashKey());

1045

    nsCStringKey key(ci->HashKey());

997

    nsConnectionEntry *ent = (nsConnectionEntry *) mCT.Get(&key);

1046

    nsConnectionEntry *ent = (nsConnectionEntry *) mCT.Get(&key);

998

1047

999

    NS_ASSERTION(ent, "no connection entry");

1048

    NS_ASSERTION(ent, "no connection entry");

1000

    if (ent) {

1049

    if (ent) {

1001

        ent->mActiveConns.RemoveElement(conn);

1050

        // If the connection is in the active list, remove that entry

1002

        mNumActiveConns--;

1051

        // and the reference held by the mActiveConns list.

1052

        // This is never the final reference on conn as the event context

1053

        // is also holding one that is released at the end of this function.

1054

        if (ent->mActiveConns.RemoveElement(conn)) {

1055

            nsHttpConnection *temp = conn;

1056

            NS_RELEASE(temp);

1057

            mNumActiveConns--;

1058

1059

1003

        if (conn->CanReuse()) {

1060

        if (conn->CanReuse()) {

1004

            LOG(("  adding connection to idle list\n"));

1061

            LOG(("  adding connection to idle list\n"));

1005

            // hold onto this connection in the idle list.  we push it to

1062

            // hold onto this connection in the idle list.  we push it to

1006

            // the end of the list so as to ensure that we'll visit older

1063

            // the end of the list so as to ensure that we'll visit older

1007

            // connections first before getting to this one.

1064

            // connections first before getting to this one.

1065

            NS_ADDREF(conn);

1008

            ent->mIdleConns.AppendElement(conn);

1066

            ent->mIdleConns.AppendElement(conn);

1009

            mNumIdleConns++;

1067

            mNumIdleConns++;

1010

            // If the added connection was first idle connection or has shortest

1068

            // If the added connection was first idle connection or has shortest

1011

            // time to live among the idle connections, pruning dead

1069

            // time to live among the idle connections, pruning dead

1012

            // connections needs to be done when it can't be reused anymore.

1070

            // connections needs to be done when it can't be reused anymore.

1013

            PRUint32 timeToLive = conn->TimeToLive();

1071

            PRUint32 timeToLive = conn->TimeToLive();

1014

            if(!mTimer || NowInSeconds() + timeToLive < mTimeOfNextWakeUp)

1072

            if(!mTimer || NowInSeconds() + timeToLive < mTimeOfNextWakeUp)

1015

                PruneDeadConnectionsAfter(timeToLive);

1073

                PruneDeadConnectionsAfter(timeToLive);

1016

1074

1017

        else {

1075

        else {

1018

            LOG(("  connection cannot be reused; closing connection\n"));

1076

            LOG(("  connection cannot be reused; closing connection\n"));

1019

            // make sure the connection is closed and release our reference.

1077

            // make sure the connection is closed and release our reference.

1020

            conn->Close(NS_ERROR_ABORT);

1078

            conn->Close(NS_ERROR_ABORT);

1021

            nsHttpConnection *temp = conn;

1022

            NS_RELEASE(temp);

1023

1079

1024

1080

1025

1081

1026

    OnMsgProcessPendingQ(NS_OK, ci); // releases |ci|

1082

    OnMsgProcessPendingQ(NS_OK, ci); // releases |ci|

1027

    NS_RELEASE(conn);

1083

    NS_RELEASE(conn);

1028

1084

1029

1085

1030

void

1086

void

Lines 1125-1140 nsHttpConnectionMgr::nsConnectionHandle:	Link Here

1125

1181

1126

1182

1127

nsresult

1183

nsresult

1128

nsHttpConnectionMgr::nsConnectionHandle::PushBack(const char *buf, PRUint32 bufLen)

1184

nsHttpConnectionMgr::nsConnectionHandle::PushBack(const char *buf, PRUint32 bufLen)

1129

1185

1130

    return mConn->PushBack(buf, bufLen);

1186

    return mConn->PushBack(buf, bufLen);

1131

1187

1132

1188

1189

1190

//////////////////////// nsHalfOpenSocket

1191

1192

1193

NS_IMPL_THREADSAFE_ISUPPORTS4(nsHttpConnectionMgr::nsHalfOpenSocket,

1194

                              nsIOutputStreamCallback,

1195

                              nsITransportEventSink,

1196

                              nsIInterfaceRequestor,

1197

                              nsITimerCallback)

1198

1199

nsHttpConnectionMgr::

1200

nsHalfOpenSocket::nsHalfOpenSocket(nsConnectionEntry *ent,

1201

                                   nsHttpTransaction *trans)

1202

    : mEnt(ent),

1203

      mTransaction(trans)

1204

1205

    NS_ABORT_IF_FALSE(ent && trans, "constructor with null arguments");

1206

    LOG(("Creating nsHalfOpenSocket [this=%p trans=%p ent=%s]\n",

1207

         this, trans, ent->mConnInfo->Host()));

1208

1209

1210

nsHttpConnectionMgr::nsHalfOpenSocket::~nsHalfOpenSocket()

1211

1212

    NS_ABORT_IF_FALSE(!mStreamOut, "streamout not null");

1213

    NS_ABORT_IF_FALSE(!mBackupStreamOut, "backupstreamout not null");

1214

    NS_ABORT_IF_FALSE(!mSynTimer, "syntimer not null");

1215

    LOG(("Destroying nsHalfOpenSocket [this=%p]\n", this));

1216

1217

    if (mEnt) {

1218

        PRInt32 index = mEnt->mHalfOpens.IndexOf(this);

1219

        NS_ABORT_IF_FALSE(index != -1, "half open complete but no item");

1220

        mEnt->mHalfOpens.RemoveElementAt(index);

1221

1222

1223

1224

nsresult

1225

nsHttpConnectionMgr::

1226

nsHalfOpenSocket::SetupStreams(nsISocketTransport **transport,

1227

                               nsIAsyncInputStream **instream,

1228

                               nsIAsyncOutputStream **outstream)

1229

1230

    nsresult rv;

1231

1232

    const char* types[1];

1233

    types[0] = (mEnt->mConnInfo->UsingSSL()) ?

1234

        "ssl" : gHttpHandler->DefaultSocketType();

1235

    PRUint32 typeCount = (types[0] != nsnull);

1236

1237

    nsCOMPtr<nsISocketTransport> socketTransport;

1238

    nsCOMPtr<nsISocketTransportService> sts;

1239

1240

    sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);

1241

    NS_ENSURE_SUCCESS(rv, rv);

1242

1243

    rv = sts->CreateTransport(types, typeCount,

1244

                              nsDependentCString(mEnt->mConnInfo->Host()),

1245

                              mEnt->mConnInfo->Port(),

1246

                              mEnt->mConnInfo->ProxyInfo(),

1247

                              getter_AddRefs(socketTransport));

1248

    NS_ENSURE_SUCCESS(rv, rv);

1249

1250

    PRUint32 tmpFlags = 0;

1251

    if (mTransaction->Caps() & NS_HTTP_REFRESH_DNS)

1252

        tmpFlags = nsISocketTransport::BYPASS_CACHE;

1253

1254

    if (mTransaction->Caps() & NS_HTTP_LOAD_ANONYMOUS)

1255

        tmpFlags |= nsISocketTransport::ANONYMOUS_CONNECT;

1256

1257

    socketTransport->SetConnectionFlags(tmpFlags);

1258

1259

    socketTransport->SetQoSBits(gHttpHandler->GetQoSBits());

1260

1261

    rv = socketTransport->SetEventSink(this, nsnull);

1262

    NS_ENSURE_SUCCESS(rv, rv);

1263

1264

    rv = socketTransport->SetSecurityCallbacks(this);

1265

    NS_ENSURE_SUCCESS(rv, rv);

1266

1267

    nsCOMPtr<nsIOutputStream> sout;

1268

    rv = socketTransport->OpenOutputStream(nsITransport::OPEN_UNBUFFERED,

1269

                                            0, 0,

1270

                                            getter_AddRefs(sout));

1271

    NS_ENSURE_SUCCESS(rv, rv);

1272

1273

    nsCOMPtr<nsIInputStream> sin;

1274

    rv = socketTransport->OpenInputStream(nsITransport::OPEN_UNBUFFERED,

1275

                                           0, 0,

1276

                                           getter_AddRefs(sin));

1277

    NS_ENSURE_SUCCESS(rv, rv);

1278

1279

    socketTransport.forget(transport);

1280

    CallQueryInterface(sin, instream);

1281

    CallQueryInterface(sout, outstream);

1282

1283

    rv = (*outstream)->AsyncWait(this, 0, 0, nsnull);

1284

    if (NS_SUCCEEDED(rv))

1285

        gHttpHandler->ConnMgr()->StartedConnect();

1286

1287

    return rv;

1288

1289

1290

nsresult

1291

nsHttpConnectionMgr::nsHalfOpenSocket::SetupPrimaryStreams()

1292

1293

    nsresult rv = SetupStreams(getter_AddRefs(mSocketTransport),

1294

                               getter_AddRefs(mStreamIn),

1295

                               getter_AddRefs(mStreamOut));

1296

    LOG(("nsHalfOpenSocket::SetupPrimaryStream [this=%p ent=%s rv=%x]",

1297

         this, mEnt->mConnInfo->Host(), rv));

1298

    if (NS_FAILED(rv)) {

1299

        if (mStreamOut)

1300

            mStreamOut->AsyncWait(nsnull, 0, 0, nsnull);

1301

        mStreamOut = nsnull;

1302

        mStreamIn = nsnull;

1303

        mSocketTransport = nsnull;

1304

1305

    return rv;

1306

1307

1308

nsresult

1309

nsHttpConnectionMgr::nsHalfOpenSocket::SetupBackupStreams()

1310

1311

    nsresult rv = SetupStreams(getter_AddRefs(mBackupTransport),

1312

                               getter_AddRefs(mBackupStreamIn),

1313

                               getter_AddRefs(mBackupStreamOut));

1314

    LOG(("nsHalfOpenSocket::SetupBackupStream [this=%p ent=%s rv=%x]",

1315

         this, mEnt->mConnInfo->Host(), rv));

1316

    if (NS_FAILED(rv)) {

1317

        if (mBackupStreamOut)

1318

            mBackupStreamOut->AsyncWait(nsnull, 0, 0, nsnull);

1319

        mBackupStreamOut = nsnull;

1320

        mBackupStreamIn = nsnull;

1321

        mBackupTransport = nsnull;

1322

1323

    return rv;

1324

1325

1326

void

1327

nsHttpConnectionMgr::nsHalfOpenSocket::SetupBackupTimer()

1328

1329

    PRUint16 timeout = gHttpHandler->GetIdleSynTimeout();

1330

    NS_ABORT_IF_FALSE(!mSynTimer, "timer already initd");

1331

    if (timeout) {

1332

        // Setup the timer that will establish a backup socket

1333

        // if we do not get a writable event on the main one.

1334

        // We do this because a lost SYN takes a very long time

1335

        // to repair at the TCP level.

1336

//

1337

        // Failure to setup the timer is something we can live with,

1338

        // so don't return an error in that case.

1339

        nsresult rv;

1340

        mSynTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);

1341

        if (NS_SUCCEEDED(rv))

1342

            mSynTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);

1343

1344

1345

1346

void

1347

nsHttpConnectionMgr::nsHalfOpenSocket::Abandon()

1348

1349

    LOG(("nsHalfOpenSocket::Abandon [this=%p ent=%s]",

1350

         this, mEnt->mConnInfo->Host()));

1351

    nsRefPtr<nsHalfOpenSocket> deleteProtector(this);

1352

1353

    if (mStreamOut) {

1354

        gHttpHandler->ConnMgr()->RecvdConnect();

1355

        mStreamOut->AsyncWait(nsnull, 0, 0, nsnull);

1356

        mStreamOut = nsnull;

1357

1358

    if (mBackupStreamOut) {

1359

        gHttpHandler->ConnMgr()->RecvdConnect();

1360

        mBackupStreamOut->AsyncWait(nsnull, 0, 0, nsnull);

1361

        mBackupStreamOut = nsnull;

1362

1363

    if (mSynTimer) {

1364

        mSynTimer->Cancel();

1365

        mSynTimer = nsnull;

1366

1367

1368

    mEnt = nsnull;

1369

1370

1371

NS_IMETHODIMP // method for nsITimerCallback

1372

nsHttpConnectionMgr::nsHalfOpenSocket::Notify(nsITimer *timer)

1373

1374

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");

1375

    NS_ABORT_IF_FALSE(timer == mSynTimer, "wrong timer");

1376

1377

    mSynTimer = nsnull;

1378

    if (!gHttpHandler->ConnMgr()->

1379

        AtActiveConnectionLimit(mEnt, mTransaction->Caps())) {

1380

        SetupBackupStreams();

1381

1382

    return NS_OK;

1383

1384

1385

// method for nsIAsyncOutputStreamCallback

1386

NS_IMETHODIMP

1387

nsHttpConnectionMgr::

1388

nsHalfOpenSocket::OnOutputStreamReady(nsIAsyncOutputStream *out)

1389

1390

    NS_ABORT_IF_FALSE(PR_GetCurrentThread() == gSocketThread, "wrong thread");

1391

    NS_ABORT_IF_FALSE(out == mStreamOut ||

1392

                      out == mBackupStreamOut, "stream mismatch");

1393

    LOG(("nsHalfOpenSocket::OnOutputStreamReady [this=%p ent=%s %s]\n",

1394

         this, mEnt->mConnInfo->Host(),

1395

         out == mStreamOut ? "primary" : "backup"));

1396

    PRInt32 index;

1397

    nsresult rv;

1398

1399

    gHttpHandler->ConnMgr()->RecvdConnect();

1400

1401

    // If the syntimer is still armed, we can cancel it because no backup

1402

    // socket should be formed at this point

1403

    if (mSynTimer) {

1404

        NS_ABORT_IF_FALSE (out == mStreamOut, "timer for non existant stream");

1405

        LOG(("nsHalfOpenSocket::OnOutputStreamReady "

1406

             "Backup connection timer canceled\n"));

1407

        mSynTimer->Cancel();

1408

        mSynTimer = nsnull;

1409

1410

1411

    // assign the new socket to the http connection

1412

    nsRefPtr<nsHttpConnection> conn = new nsHttpConnection();

1413

    LOG(("nsHalfOpenSocket::OnOutputStreamReady "

1414

         "Created new nshttpconnection %p\n", conn));

1415

1416

    nsCOMPtr<nsIInterfaceRequestor> callbacks;

1417

    nsCOMPtr<nsIEventTarget>        callbackTarget;

1418

    mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks),

1419

                                       getter_AddRefs(callbackTarget));

1420

    if (out == mStreamOut) {

1421

        rv = conn->Init(mEnt->mConnInfo,

1422

                        gHttpHandler->ConnMgr()->mMaxRequestDelay,

1423

                        mSocketTransport, mStreamIn, mStreamOut,

1424

                        callbacks, callbackTarget);

1425

1426

        // The nsHttpConnection object now owns these streams and sockets

1427

        mStreamOut = nsnull;

1428

        mStreamIn = nsnull;

1429

        mSocketTransport = nsnull;

1430

1431

    else {

1432

        rv = conn->Init(mEnt->mConnInfo,

1433

                        gHttpHandler->ConnMgr()->mMaxRequestDelay,

1434

                        mBackupTransport, mBackupStreamIn, mBackupStreamOut,

1435

                        callbacks, callbackTarget);

1436

1437

        // The nsHttpConnection object now owns these streams and sockets

1438

        mBackupStreamOut = nsnull;

1439

        mBackupStreamIn = nsnull;

1440

        mBackupTransport = nsnull;

1441

1442

1443

    if (NS_FAILED(rv)) {

1444

        LOG(("nsHalfOpenSocket::OnOutputStreamReady "

1445

             "conn->init (%p) failed %x\n", conn, rv));

1446

        return rv;

1447

1448

1449

    // if this is still in the pending list, remove it and dispatch it

1450

    index = mEnt->mPendingQ.IndexOf(mTransaction);

1451

    if (index != -1) {

1452

        mEnt->mPendingQ.RemoveElementAt(index);

1453

        nsHttpTransaction *temp = mTransaction;

1454

        NS_RELEASE(temp);

1455

        gHttpHandler->ConnMgr()->AddActiveConn(conn, mEnt);

1456

        rv = gHttpHandler->ConnMgr()->DispatchTransaction(mEnt, mTransaction,

1457

                                                          mTransaction->Caps(),

1458

                                                          conn);

1459

1460

    else {

1461

        // this transaction was dispatched off the pending q before all the

1462

        // sockets established themselves.

1463

1464

        // We need to establish a small non-zero idle timeout so the connection

1465

        // mgr perceives this socket as suitable for persistent connection reuse

1466

        conn->SetIdleTimeout(NS_MIN((PRUint16) 5, gHttpHandler->IdleTimeout()));

1467

1468

        // After about 1 second allow for the possibility of restarting a

1469

        // transaction due to server close. Keep at sub 1 second as that is the

1470

        // minimum granularity we can expect a server to be timing out with.

1471

        conn->SetIsReusedAfter(950);

1472

1473

        NS_ADDREF(conn);  // because onmsg*() expects to drop a reference

1474

        gHttpHandler->ConnMgr()->OnMsgReclaimConnection(NS_OK, conn);

1475

1476

1477

    return rv;

1478

1479

1480

// method for nsITransportEventSink

1481

NS_IMETHODIMP

1482

nsHttpConnectionMgr::nsHalfOpenSocket::OnTransportStatus(nsITransport *trans,

1483

                                                         nsresult status,

1484

                                                         PRUint64 progress,

1485

                                                         PRUint64 progressMax)

1486

1487

    if (mTransaction)

1488

        mTransaction->OnTransportStatus(status, progress);

1489

    return NS_OK;

1490

1491

1492

// method for nsIInterfaceRequestor

1493

NS_IMETHODIMP

1494

nsHttpConnectionMgr::nsHalfOpenSocket::GetInterface(const nsIID &iid,

1495

                                                    void **result)

1496

1497

    if (mTransaction) {

1498

        nsCOMPtr<nsIInterfaceRequestor> callbacks;

1499

        mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks), nsnull);

1500

        if (callbacks)

1501

            return callbacks->GetInterface(iid, result);

1502

1503

    return NS_ERROR_NO_INTERFACE;

1504

1505

1133

PRBool

1506

PRBool

1134

nsHttpConnectionMgr::nsConnectionHandle::LastTransactionExpectedNoContent()

1507

nsHttpConnectionMgr::nsConnectionHandle::LastTransactionExpectedNoContent()

1135

1508

1136

    return mConn->LastTransactionExpectedNoContent();

1509

    return mConn->LastTransactionExpectedNoContent();

1137

1510

1138

1511

1139

void

1512

void

1140

nsHttpConnectionMgr::

1513

nsHttpConnectionMgr::





#include "nsHttpConnectionInfo.h"
#include "nsHttpConnection.h"
#include "nsHttpTransaction.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"
#include "nsHashtable.h"
#include "nsAutoPtr.h"
#include "prmon.h"
#include "nsISocketTransportService.h"

#include "nsIObserver.h"
#include "nsITimer.h"

class nsHttpPipeline;

//-----------------------------------------------------------------------------


    void AddTransactionToPipeline(nsHttpPipeline *);

    // called to force the transaction queue to be processed once more, giving
    // preference to the specified connection.
    nsresult ProcessPendingQ(nsHttpConnectionInfo *);

private:
    virtual ~nsHttpConnectionMgr();
    class nsHalfOpenSocket;
    
    // nsConnectionEntry
    //
    // mCT maps connection info hash key to nsConnectionEntry object, which
    // contains list of active and idle connections as well as the list of
    // pending transactions.
    //
    struct nsConnectionEntry
    {

            NS_ADDREF(mConnInfo);
        }
       ~nsConnectionEntry() { NS_RELEASE(mConnInfo); }

        nsHttpConnectionInfo        *mConnInfo;
        nsTArray<nsHttpTransaction*> mPendingQ;    // pending transaction queue
        nsTArray<nsHttpConnection*>  mActiveConns; // active connections
        nsTArray<nsHttpConnection*>  mIdleConns;   // idle persistent connections
        nsTArray<nsHalfOpenSocket*>  mHalfOpens;
    };

    // nsConnectionHandle
    //
    // thin wrapper around a real connection, used to keep track of references
    // to the connection to determine when the connection may be reused.  the
    // transaction (or pipeline) owns a reference to this handle.  this extra
    // layer of indirection greatly simplifies consumer code, avoiding the

        NS_DECL_NSAHTTPCONNECTION

        nsConnectionHandle(nsHttpConnection *conn) { NS_ADDREF(mConn = conn); }
        virtual ~nsConnectionHandle();

        nsHttpConnection *mConn;
    };

    // nsHalfOpenSocket is used to hold the state of an opening TCP socket
    // while we wait for it to establish and bind it to a connection

    class nsHalfOpenSocket : public nsIOutputStreamCallback,
                             public nsITransportEventSink,
                             public nsIInterfaceRequestor,
                             public nsITimerCallback
    {
    public:
        NS_DECL_ISUPPORTS
        NS_DECL_NSIOUTPUTSTREAMCALLBACK
        NS_DECL_NSITRANSPORTEVENTSINK
        NS_DECL_NSIINTERFACEREQUESTOR
        NS_DECL_NSITIMERCALLBACK

        nsHalfOpenSocket(nsConnectionEntry *ent,
                         nsHttpTransaction *trans);
        ~nsHalfOpenSocket();
        
        nsresult SetupStreams(nsISocketTransport **,
                              nsIAsyncInputStream **,
                              nsIAsyncOutputStream **);
        nsresult SetupPrimaryStreams();
        nsresult SetupBackupStreams();
        void     SetupBackupTimer();
        void     Abandon();
        
    private:
        nsConnectionEntry              *mEnt;
        nsRefPtr<nsHttpTransaction>    mTransaction;
        nsCOMPtr<nsISocketTransport>   mSocketTransport;
        nsCOMPtr<nsIAsyncOutputStream> mStreamOut;
        nsCOMPtr<nsIAsyncInputStream>  mStreamIn;

        // for syn retry
        nsCOMPtr<nsITimer>             mSynTimer;
        nsCOMPtr<nsISocketTransport>   mBackupTransport;
        nsCOMPtr<nsIAsyncOutputStream> mBackupStreamOut;
        nsCOMPtr<nsIAsyncInputStream>  mBackupStreamIn;
    };
    friend class nsHalfOpenSocket;

    //-------------------------------------------------------------------------
    // NOTE: these members may be accessed from any thread (use mMonitor)
    //-------------------------------------------------------------------------

    PRInt32                      mRef;
    PRMonitor                   *mMonitor;
    nsCOMPtr<nsIEventTarget>     mSocketThreadTarget;



    PRPackedBool mIsShuttingDown;

    //-------------------------------------------------------------------------
    // NOTE: these members are only accessed on the socket transport thread
    //-------------------------------------------------------------------------

    static PRIntn ProcessOneTransactionCB(nsHashKey *, void *, void *);

    static PRIntn PruneDeadConnectionsCB(nsHashKey *, void *, void *);
    static PRIntn ShutdownPassCB(nsHashKey *, void *, void *);
    static PRIntn PurgeExcessIdleConnectionsCB(nsHashKey *, void *, void *);
    PRBool   ProcessPendingQForEntry(nsConnectionEntry *);
    PRBool   AtActiveConnectionLimit(nsConnectionEntry *, PRUint8 caps);
    void     GetConnection(nsConnectionEntry *, nsHttpTransaction *,
                           nsHttpConnection **);
    nsresult DispatchTransaction(nsConnectionEntry *, nsAHttpTransaction *,
                                 PRUint8 caps, nsHttpConnection *);
    PRBool   BuildPipeline(nsConnectionEntry *, nsAHttpTransaction *, nsHttpPipeline **);
    nsresult ProcessNewTransaction(nsHttpTransaction *);
    nsresult EnsureSocketThreadTargetIfOnline();
    nsresult CreateTransport(nsConnectionEntry *, nsHttpTransaction *);
    void     AddActiveConn(nsHttpConnection *, nsConnectionEntry *);
    void     StartedConnect();
    void     RecvdConnect();
    
    // message handlers have this signature
    typedef void (nsHttpConnectionMgr:: *nsConnEventHandler)(PRInt32, void *);

    // nsConnEvent
    //
    // subclass of nsRunnable used to marshall events to the socket transport
    // thread.  this class is used to implement PostEvent.
    //





    , mHttpVersion(NS_HTTP_VERSION_1_1)
    , mProxyHttpVersion(NS_HTTP_VERSION_1_1)
    , mCapabilities(NS_HTTP_ALLOW_KEEPALIVE)
    , mProxyCapabilities(NS_HTTP_ALLOW_KEEPALIVE)
    , mReferrerLevel(0xff) // by default we always send a referrer
    , mIdleTimeout(10)
    , mMaxRequestAttempts(10)
    , mMaxRequestDelay(10)
    , mIdleSynTimeout(250)
    , mMaxConnections(24)
    , mMaxConnectionsPerServer(8)
    , mMaxPersistentConnectionsPerServer(2)
    , mMaxPersistentConnectionsPerProxy(4)
    , mMaxPipelinedRequests(2)
    , mRedirectionLimit(10)
    , mPhishyUserPassLength(1)
    , mQoSBits(0x00)

    }

    if (PREF_CHANGED(HTTP_PREF("redirection-limit"))) {
        rv = prefs->GetIntPref(HTTP_PREF("redirection-limit"), &val);
        if (NS_SUCCEEDED(rv))
            mRedirectionLimit = (PRUint8) NS_CLAMP(val, 0, 0xff);
    }

    if (PREF_CHANGED(HTTP_PREF("connection-retry-timeout"))) {
        rv = prefs->GetIntPref(HTTP_PREF("connection-retry-timeout"), &val);
        if (NS_SUCCEEDED(rv))
            mIdleSynTimeout = (PRUint16) NS_CLAMP(val, 0, 3000);
    }

    if (PREF_CHANGED(HTTP_PREF("version"))) {
        nsXPIDLCString httpVersion;
        prefs->GetCharPref(HTTP_PREF("version"), getter_Copies(httpVersion));
        if (httpVersion) {
            if (!PL_strcmp(httpVersion, "1.1"))
                mHttpVersion = NS_HTTP_VERSION_1_1;
            else if (!PL_strcmp(httpVersion, "0.9"))
                mHttpVersion = NS_HTTP_VERSION_0_9;





    PRBool         SendSecureXSiteReferrer() { return mSendSecureXSiteReferrer; }
    PRUint8        RedirectionLimit()        { return mRedirectionLimit; }
    PRUint16       IdleTimeout()             { return mIdleTimeout; }
    PRUint16       MaxRequestAttempts()      { return mMaxRequestAttempts; }
    const char    *DefaultSocketType()       { return mDefaultSocketType.get(); /* ok to return null */ }
    nsIIDNService *IDNConverter()            { return mIDNConverter; }
    PRUint32       PhishyUserPassLength()    { return mPhishyUserPassLength; }
    PRUint8        GetQoSBits()              { return mQoSBits; }
    PRUint16       GetIdleSynTimeout()       { return mIdleSynTimeout; }
    
    PRBool         IsPersistentHttpsCachingEnabled() { return mEnablePersistentHttpsCaching; }

    PRBool         PromptTempRedirect()      { return mPromptTempRedirect; }

    nsHttpAuthCache     *AuthCache() { return &mAuthCache; }
    nsHttpConnectionMgr *ConnMgr()   { return mConnMgr; }


    PRUint8  mProxyHttpVersion;
    PRUint8  mCapabilities;
    PRUint8  mProxyCapabilities;
    PRUint8  mReferrerLevel;

    PRUint16 mIdleTimeout;
    PRUint16 mMaxRequestAttempts;
    PRUint16 mMaxRequestDelay;
    PRUint16 mIdleSynTimeout;

    PRUint16 mMaxConnections;
    PRUint8  mMaxConnectionsPerServer;
    PRUint8  mMaxPersistentConnectionsPerServer;
    PRUint8  mMaxPersistentConnectionsPerProxy;
    PRUint8  mMaxPipelinedRequests;

    PRUint8  mRedirectionLimit;





    NS_IF_ADDREF(mConnection = conn);

    PRInt32 i, count = mRequestQ.Length();
    for (i=0; i<count; ++i)
        Request(i)->SetConnection(this);
}

void
nsHttpPipeline::GetSecurityCallbacks(nsIInterfaceRequestor **result,
                                     nsIEventTarget        **target)
{
    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");

    // return security callbacks from first request
    nsAHttpTransaction *trans = Request(0);
    if (trans)
        trans->GetSecurityCallbacks(result, target);
    else {
        *result = nsnull;
        if (target)
            *target = nsnull;
    }
}

void
nsHttpPipeline::OnTransportStatus(nsresult status, PRUint64 progress)
{
    LOG(("nsHttpPipeline::OnStatus [this=%x status=%x progress=%llu]\n",
        this, status, progress));






void
nsHttpTransaction::SetConnection(nsAHttpConnection *conn)
{
    NS_IF_RELEASE(mConnection);
    NS_IF_ADDREF(mConnection = conn);
}

void
nsHttpTransaction::GetSecurityCallbacks(nsIInterfaceRequestor **cb,
                                        nsIEventTarget        **target)
{
    NS_IF_ADDREF(*cb = mCallbacks);
    if (target)
        NS_IF_ADDREF(*target = mConsumerTarget);
}

void
nsHttpTransaction::OnTransportStatus(nsresult status, PRUint64 progress)
{
    LOG(("nsHttpTransaction::OnSocketStatus [this=%x status=%x progress=%llu]\n",
        this, status, progress));


Return to bug 623948