Back to index

lightning-sunbird  0.9+nobinonly
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
nsHttpConnection Class Reference

#include <nsHttpConnection.h>

Inheritance diagram for nsHttpConnection:
Inheritance graph
[legend]
Collaboration diagram for nsHttpConnection:
Collaboration graph
[legend]

List of all members.

Public Member Functions

NS_DECL_ISUPPORTS
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR 
nsHttpConnection ()
virtual ~nsHttpConnection ()
nsresult Init (nsHttpConnectionInfo *info, PRUint16 maxHangTime)
nsresult Activate (nsAHttpTransaction *, PRUint8 caps)
void Close (nsresult reason)
PRBool SupportsPipelining ()
PRBool IsKeepAlive ()
PRBool CanReuse ()
void DontReuse ()
void DropTransport ()
nsAHttpTransactionTransaction ()
nsHttpConnectionInfoConnectionInfo ()
nsresult OnHeadersAvailable (nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, PRBool *reset)
void CloseTransaction (nsAHttpTransaction *, nsresult reason)
void GetConnectionInfo (nsHttpConnectionInfo **ci)
void GetSecurityInfo (nsISupports **)
PRBool IsPersistent ()
PRBool IsReused ()
nsresult PushBack (const char *data, PRUint32 length)
nsresult ResumeSend ()
nsresult ResumeRecv ()
virtual nsresult OnReadSegment (const char *segment, PRUint32 count, PRUint32 *countRead)=0
virtual nsresult OnWriteSegment (char *segment, PRUint32 count, PRUint32 *countWritten)=0
void onInputStreamReady (in nsIAsyncInputStream aStream)
 Called to indicate that the stream is either readable or closed.
void onOutputStreamReady (in nsIAsyncOutputStream aStream)
 Called to indicate that the stream is either writable or closed.
void onTransportStatus (in nsITransport aTransport, in nsresult aStatus, in unsigned long long aProgress, in unsigned long long aProgressMax)
 Transport status notification.
void getInterface (in nsIIDRef uuid,[iid_is(uuid), retval] out nsQIResult result)
 Retrieves the specified interface pointer.

Static Public Member Functions

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

Private Member Functions

nsresult ProxyStartSSL ()
nsresult CreateTransport ()
nsresult OnTransactionDone (nsresult reason)
nsresult OnSocketWritable ()
nsresult OnSocketReadable ()
nsresult SetupSSLProxyConnect ()
PRBool IsAlive ()
PRBool SupportsPipelining (nsHttpResponseHead *)

Private Attributes

nsCOMPtr< nsISocketTransportmSocketTransport
nsCOMPtr< nsIAsyncInputStreammSocketIn
nsCOMPtr< nsIAsyncOutputStreammSocketOut
nsresult mSocketInCondition
nsresult mSocketOutCondition
nsCOMPtr< nsIInputStreammSSLProxyConnectStream
nsCOMPtr< nsIInputStreammRequestStream
nsAHttpTransactionmTransaction
nsHttpConnectionInfomConnInfo
PRLockmLock
PRUint32 mLastReadTime
PRUint16 mMaxHangTime
PRUint16 mIdleTimeout
PRPackedBool mKeepAlive
PRPackedBool mKeepAliveMask
PRPackedBool mSupportsPipelining
PRPackedBool mIsReused
PRPackedBool mCompletedSSLConnect

Detailed Description

Definition at line 64 of file nsHttpConnection.h.


Constructor & Destructor Documentation

Definition at line 67 of file nsHttpConnection.cpp.

    : mTransaction(nsnull)
    , mConnInfo(nsnull)
    , mLock(nsnull)
    , mLastReadTime(0)
    , mIdleTimeout(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)
{
    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);
}

Here is the call graph for this function:

Definition at line 86 of file nsHttpConnection.cpp.

{
    LOG(("Destroying nsHttpConnection @%x\n", this));
 
    NS_IF_RELEASE(mConnInfo);
    NS_IF_RELEASE(mTransaction);

    if (mLock) {
        PR_DestroyLock(mLock);
        mLock = nsnull;
    }

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

Here is the call graph for this function:


Member Function Documentation

Definition at line 125 of file nsHttpConnection.cpp.

{
    nsresult rv;

    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();
        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 loser;
    }

    // wait for the output stream to be readable
    rv = mSocketOut->AsyncWait(this, 0, 0, nsnull);
    if (NS_SUCCEEDED(rv))
        return rv;

loser:
    NS_RELEASE(mTransaction);
    return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 203 of file nsHttpConnection.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 167 of file nsHttpConnection.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 473 of file nsHttpConnection.cpp.

{
    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);

    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;
}

Here is the call graph for this function:

Definition at line 109 of file nsHttpConnection.h.

{ return mConnInfo; }

Here is the caller graph for this function:

Definition at line 421 of file nsHttpConnection.cpp.

{
    nsresult rv;

    NS_PRECONDITION(!mSocketTransport, "unexpected");

    nsCOMPtr<nsISocketTransportService> sts =
            do_GetService(kSocketTransportServiceCID, &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;

    // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 103 of file nsHttpConnection.h.

Here is the caller graph for this function:

Definition at line 106 of file nsHttpConnection.h.

Here is the call graph for this function:

Definition at line 114 of file nsHttpConnection.h.

{ NS_IF_ADDREF(*ci = mConnInfo); }
void nsIInterfaceRequestor::getInterface ( in nsIIDRef  uuid,
[iid_is(uuid), retval] out nsQIResult  result 
) [inherited]

Retrieves the specified interface pointer.

Parameters:
uuidThe IID of the interface being requested.
result[out] The interface pointer to be filled in if the interface is accessible.
Returns:
NS_OK - interface was successfully returned. NS_NOINTERFACE - interface not accessible. NS_ERROR* - method failure.
void nsHttpConnection::GetSecurityInfo ( nsISupports **  secinfo)

Definition at line 378 of file nsHttpConnection.cpp.

{
    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");

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

Here is the call graph for this function:

Definition at line 104 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::Init [this=%x]\n", this));

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

    mLock = PR_NewLock();
    if (!mLock)
        return NS_ERROR_OUT_OF_MEMORY;

    mConnInfo = info;
    NS_ADDREF(mConnInfo);

    mMaxHangTime = maxHangTime;
    mLastReadTime = NowInSeconds();
    return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 210 of file nsHttpConnection.cpp.

{
    if (!mSocketTransport)
        return PR_FALSE;

    PRBool alive;
    nsresult rv = mSocketTransport->IsAlive(&alive);
    if (NS_FAILED(rv))
        alive = PR_FALSE;

//#define TEST_RESTART_LOGIC
#ifdef TEST_RESTART_LOGIC
    if (!alive) {
        LOG(("pretending socket is still alive to test restart logic\n"));
        alive = PR_TRUE;
    }
#endif

    return alive;
}

Here is the caller graph for this function:

Definition at line 101 of file nsHttpConnection.h.

{ return mKeepAliveMask && mKeepAlive; }

Here is the caller graph for this function:

Definition at line 116 of file nsHttpConnection.h.

{ return IsKeepAlive(); }

Here is the call graph for this function:

Definition at line 117 of file nsHttpConnection.h.

{ return mIsReused; }
nsresult nsHttpConnection::OnHeadersAvailable ( nsAHttpTransaction trans,
nsHttpRequestHead requestHead,
nsHttpResponseHead responseHead,
PRBool reset 
)

Definition at line 274 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::OnHeadersAvailable [this=%p trans=%p response-head=%p]\n",
        this, trans, responseHead));

    NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
    NS_ENSURE_ARG_POINTER(trans);
    NS_ASSERTION(responseHead, "No response head?");

    // If the server issued an explicit timeout, then we need to close down the
    // socket transport.  We pass an error code of NS_ERROR_NET_RESET to
    // trigger the transactions 'restart' mechanism.  We tell it to reset its
    // response headers so that it will be ready to receive the new response.
    if (responseHead->Status() == 408) {
        Close(NS_ERROR_NET_RESET);
        *reset = PR_TRUE;
        return NS_OK;
    }

    // we won't change our keep-alive policy unless the server has explicitly
    // told us to do so.

    // inspect the connection headers for keep-alive info provided the
    // transaction completed successfully.
    const char *val = responseHead->PeekHeader(nsHttp::Connection);
    if (!val)
        val = responseHead->PeekHeader(nsHttp::Proxy_Connection);

    // reset to default (the server may have changed since we last checked)
    mSupportsPipelining = PR_FALSE;

    if ((responseHead->Version() < NS_HTTP_VERSION_1_1) ||
        (requestHead->Version() < NS_HTTP_VERSION_1_1)) {
        // HTTP/1.0 connections are by default NOT persistent
        if (val && !PL_strcasecmp(val, "keep-alive"))
            mKeepAlive = PR_TRUE;
        else
            mKeepAlive = PR_FALSE;
    }
    else {
        // HTTP/1.1 connections are by default persistent
        if (val && !PL_strcasecmp(val, "close")) 
            mKeepAlive = PR_FALSE;
        else {
            mKeepAlive = PR_TRUE;
            mSupportsPipelining = SupportsPipelining(responseHead);
        }
    }
    mKeepAliveMask = mKeepAlive;

    // if this connection is persistent, then the server may send a "Keep-Alive"
    // header specifying the maximum number of times the connection can be
    // reused as well as the maximum amount of time the connection can be idle
    // before the server will close it.  we ignore the max reuse count, because
    // a "keep-alive" connection is by definition capable of being reused, and
    // we only care about being able to reuse it once.  if a timeout is not 
    // specified then we use our advertized timeout value.
    if (mKeepAlive) {
        val = responseHead->PeekHeader(nsHttp::Keep_Alive);

        const char *cp = PL_strcasestr(val, "timeout=");
        if (cp)
            mIdleTimeout = (PRUint32) atoi(cp + 8);
        else
            mIdleTimeout = gHttpHandler->IdleTimeout();
        
        LOG(("Connection can be reused [this=%x idle-timeout=%u]\n", this, mIdleTimeout));
    }

    // if we're doing an SSL proxy connect, then we need to check whether or not
    // the connect was successful.  if so, then we have to reset the transaction
    // and step-up the socket connection to SSL. finally, we have to wake up the
    // socket write request.
    if (mSSLProxyConnectStream) {
        mSSLProxyConnectStream = 0;
        if (responseHead->Status() == 200) {
            LOG(("SSL proxy CONNECT succeeded!\n"));
            *reset = PR_TRUE;
            nsresult rv = ProxyStartSSL();
            if (NS_FAILED(rv)) // XXX need to handle this for real
                LOG(("ProxyStartSSL failed [rv=%x]\n", rv));
            mCompletedSSLConnect = PR_TRUE;
            rv = mSocketOut->AsyncWait(this, 0, 0, nsnull);
            // XXX what if this fails -- need to handle this error
            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 =
                    NS_STATIC_CAST(nsHttpTransaction *, mTransaction);
            trans->SetSSLConnectFailed();
        }
    }

    return NS_OK;
}

Here is the call graph for this function:

Called to indicate that the stream is either readable or closed.

Parameters:
aStreamThe stream whose asyncWait method was called.

Called to indicate that the stream is either writable or closed.

Parameters:
aStreamThe stream whose asyncWait method was called.
virtual nsresult nsAHttpSegmentReader::OnReadSegment ( const char *  segment,
PRUint32  count,
PRUint32 countRead 
) [pure virtual, inherited]

Here is the caller graph for this function:

Definition at line 629 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::OnSocketReadable [this=%x]\n", this));

    PRUint32 now = NowInSeconds();

    if (mKeepAliveMask && (now - mLastReadTime >= PRUint32(mMaxHangTime))) {
        LOG(("max hang time exceeded!\n"));
        // give the handler a chance to create a new persistent connection to
        // this host if we've been busy for too long.
        mKeepAliveMask = PR_FALSE;
        gHttpHandler->ProcessPendingQ(mConnInfo);
    }
    mLastReadTime = now;

    nsresult rv;
    PRUint32 n;
    PRBool again = PR_TRUE;

    do {
        rv = mTransaction->WriteSegments(this, NS_HTTP_SEGMENT_SIZE, &n);
        if (NS_FAILED(rv)) {
            // if the transaction didn't want to take any more data, then
            // wait for the transaction to call ResumeRecv.
            if (rv == NS_BASE_STREAM_WOULD_BLOCK)
                rv = NS_OK;
            again = PR_FALSE;
        }
        else if (NS_FAILED(mSocketInCondition)) {
            // continue waiting for the socket if necessary...
            if (mSocketInCondition == NS_BASE_STREAM_WOULD_BLOCK)
                rv = mSocketIn->AsyncWait(this, 0, 0, nsnull);
            else
                rv = mSocketInCondition;
            again = PR_FALSE;
        }
        // read more from the socket until error...
    } while (again);

    return rv;
}

Here is the call graph for this function:

Definition at line 536 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::OnSocketWritable [this=%x]\n", this));

    nsresult rv;
    PRUint32 n;
    PRBool again = PR_TRUE;

    do {
        // if we're doing an SSL proxy connect, then we need to bypass calling
        // into the transaction.
        //
        // NOTE: this code path can't be shared since the transaction doesn't
        // implement nsIInputStream.  doing so is not worth the added cost of
        // extra indirections during normal reading.
        //
        if (mSSLProxyConnectStream) {
            LOG(("  writing CONNECT request stream\n"));
            rv = mSSLProxyConnectStream->ReadSegments(ReadFromStream, this,
                                                      NS_HTTP_SEGMENT_SIZE, &n);
        }
        else {
            LOG(("  writing transaction request stream\n"));
            rv = mTransaction->ReadSegments(this, NS_HTTP_SEGMENT_SIZE, &n);
        }

        LOG(("  ReadSegments returned [rv=%x read=%u sock-cond=%x]\n",
            rv, n, mSocketOutCondition));

        // XXX some streams return NS_BASE_STREAM_CLOSED to indicate EOF.
        if (rv == NS_BASE_STREAM_CLOSED) {
            rv = NS_OK;
            n = 0;
        }

        if (NS_FAILED(rv)) {
            // if the transaction didn't want to write any more data, then
            // wait for the transaction to call ResumeSend.
            if (rv == NS_BASE_STREAM_WOULD_BLOCK)
                rv = NS_OK;
            again = PR_FALSE;
        }
        else if (NS_FAILED(mSocketOutCondition)) {
            if (mSocketOutCondition == NS_BASE_STREAM_WOULD_BLOCK)
                rv = mSocketOut->AsyncWait(this, 0, 0, nsnull); // continue writing
            else
                rv = mSocketOutCondition;
            again = PR_FALSE;
        }
        else if (n == 0) {
            // 
            // at this point we've written out the entire transaction, and now we
            // must wait for the server's response.  we manufacture a status message
            // here to reflect the fact that we are waiting.  this message will be
            // trumped (overwritten) if the server responds quickly.
            //
            mTransaction->OnTransportStatus(nsISocketTransport::STATUS_WAITING_FOR,
                                            LL_ZERO);

            rv = mSocketIn->AsyncWait(this, 0, 0, nsnull); // start reading
            again = PR_FALSE;
        }
        // write more to the socket until error or end-of-request...
    } while (again);

    return rv;
}

Here is the call graph for this function:

void nsITransportEventSink::onTransportStatus ( in nsITransport  aTransport,
in nsresult  aStatus,
in unsigned long long  aProgress,
in unsigned long long  aProgressMax 
) [inherited]

Transport status notification.

Parameters:
aTransportthe transport sending this status notification.
aStatusthe transport status (resolvable to a string using nsIErrorService). See nsISocketTransport for socket specific status codes and more comments.
aProgressthe amount of data either read or written depending on the value of the status code. this value is relative to aProgressMax.
aProgressMaxthe maximum amount of data that will be read or written. if unknown, 0xFFFFFFFF will be passed.
virtual nsresult nsAHttpSegmentWriter::OnWriteSegment ( char *  segment,
PRUint32  count,
PRUint32 countWritten 
) [pure virtual, inherited]

Implemented in nsHttpPushBackWriter.

Here is the caller graph for this function:

Definition at line 185 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::ProxyStartSSL [this=%x]\n", this));
#ifdef DEBUG
    NS_PRECONDITION(PR_GetCurrentThread() == gSocketThread, "wrong thread");
#endif

    nsCOMPtr<nsISupports> securityInfo;
    nsresult rv = mSocketTransport->GetSecurityInfo(getter_AddRefs(securityInfo));
    if (NS_FAILED(rv)) return rv;

    nsCOMPtr<nsISSLSocketControl> ssl = do_QueryInterface(securityInfo, &rv);
    if (NS_FAILED(rv)) return rv;

    return ssl->ProxyStartSSL();
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsHttpConnection::PushBack ( const char *  data,
PRUint32  length 
) [inline]

Definition at line 118 of file nsHttpConnection.h.

{ NS_NOTREACHED("PushBack"); return NS_ERROR_UNEXPECTED; }
NS_METHOD nsHttpConnection::ReadFromStream ( nsIInputStream input,
void closure,
const char *  buf,
PRUint32  offset,
PRUint32  count,
PRUint32 countRead 
) [static]

Definition at line 499 of file nsHttpConnection.cpp.

{
    // thunk for nsIInputStream instance
    nsHttpConnection *conn = (nsHttpConnection *) closure;
    return conn->OnReadSegment(buf, count, countRead);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 403 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::ResumeRecv [this=%p]\n", this));

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

    if (mSocketIn)
        return mSocketIn->AsyncWait(this, 0, 0, nsnull);

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

Here is the call graph for this function:

Definition at line 389 of file nsHttpConnection.cpp.

{
    LOG(("nsHttpConnection::ResumeSend [this=%p]\n", this));

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

    if (mSocketOut)
        return mSocketOut->AsyncWait(this, 0, 0, nsnull);

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

Here is the call graph for this function:

Definition at line 672 of file nsHttpConnection.cpp.

{
    const char *val;

    LOG(("nsHttpConnection::SetupSSLProxyConnect [this=%x]\n", this));

    NS_ENSURE_TRUE(!mSSLProxyConnectStream, NS_ERROR_ALREADY_INITIALIZED);

    nsCAutoString buf;
    buf.Assign(mConnInfo->Host());
    buf.Append(':');
    buf.AppendInt(mConnInfo->Port());

    // CONNECT host:port HTTP/1.1
    nsHttpRequestHead request;
    request.SetMethod(nsHttp::Connect);
    request.SetVersion(gHttpHandler->HttpVersion());
    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 = NS_STATIC_CAST(nsHttpTransaction *, mTransaction);
    
    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));
    }

    val = trans->RequestHead()->PeekHeader(nsHttp::Proxy_Authorization);
    if (val) {
        // we don't know for sure if this authorization is intended for the
        // SSL proxy, so we add it just in case.
        request.SetHeader(nsHttp::Proxy_Authorization, nsDependentCString(val));
    }

    buf.Truncate();
    request.Flatten(buf, PR_FALSE);
    buf.AppendLiteral("\r\n");

    return NS_NewCStringInputStream(getter_AddRefs(mSSLProxyConnectStream), buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 100 of file nsHttpConnection.h.

{ return mSupportsPipelining; }

Here is the caller graph for this function:

Definition at line 232 of file nsHttpConnection.cpp.

{
    // XXX there should be a strict mode available that disables this
    // blacklisting.

    // assuming connection is HTTP/1.1 with keep-alive enabled
    if (mConnInfo->UsingHttpProxy() && !mConnInfo->UsingSSL()) {
        // XXX check for bad proxy servers...
        return PR_TRUE;
    }

    // XXX what about checking for a Via header? (transparent proxies)

    // check for bad origin servers
    const char *val = responseHead->PeekHeader(nsHttp::Server);
    if (!val)
        return PR_FALSE; // no header, no love

    // the list of servers known to do bad things with pipelined requests
    static const char *bad_servers[] = {
        "Microsoft-IIS/4.",
        "Microsoft-IIS/5.",
        "Netscape-Enterprise/3.",
        nsnull
    };

    for (const char **server = bad_servers; *server; ++server) {
        if (PL_strcasestr(val, *server) != nsnull) {
            LOG(("looks like this server does not support pipelining"));
            return PR_FALSE;
        }
    }

    // ok, let's allow pipelining to this server
    return PR_TRUE;
}

Here is the call graph for this function:

Definition at line 108 of file nsHttpConnection.h.

{ return mTransaction; }

Here is the caller graph for this function:


Member Data Documentation

Definition at line 163 of file nsHttpConnection.h.

Definition at line 151 of file nsHttpConnection.h.

Definition at line 157 of file nsHttpConnection.h.

Definition at line 162 of file nsHttpConnection.h.

Definition at line 159 of file nsHttpConnection.h.

Definition at line 160 of file nsHttpConnection.h.

Definition at line 155 of file nsHttpConnection.h.

Definition at line 153 of file nsHttpConnection.h.

Definition at line 156 of file nsHttpConnection.h.

Definition at line 148 of file nsHttpConnection.h.

Definition at line 141 of file nsHttpConnection.h.

Definition at line 144 of file nsHttpConnection.h.

Definition at line 142 of file nsHttpConnection.h.

Definition at line 145 of file nsHttpConnection.h.

Definition at line 140 of file nsHttpConnection.h.

Definition at line 147 of file nsHttpConnection.h.

Definition at line 161 of file nsHttpConnection.h.

Definition at line 150 of file nsHttpConnection.h.


The documentation for this class was generated from the following files: