/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla. * * The Initial Developer of the Original Code is * Netscape Communications. * Portions created by the Initial Developer are Copyright (C) 2001 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Darin Fisher (original author) * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #ifndef nsHttpTransaction_h__ #define nsHttpTransaction_h__ #include "nsHttp.h" #include "nsHttpHeaderArray.h" #include "nsAHttpTransaction.h" #include "nsAHttpConnection.h" #include "nsCOMPtr.h" #include "nsIPipe.h" #include "nsIInputStream.h" #include "nsIOutputStream.h" #include "nsIInterfaceRequestor.h" #include "nsISocketTransportService.h" #include "nsITransport.h" #include "nsIEventTarget.h" #include "TimingStruct.h" //----------------------------------------------------------------------------- class nsHttpTransaction; class nsHttpRequestHead; class nsHttpResponseHead; class nsHttpChunkedDecoder; class nsIHttpActivityObserver; //----------------------------------------------------------------------------- // nsHttpTransaction represents a single HTTP transaction. It is thread-safe, // intended to run on the socket thread. //----------------------------------------------------------------------------- class nsHttpTransaction : public nsAHttpTransaction , public nsIInputStreamCallback , public nsIOutputStreamCallback { public: NS_DECL_ISUPPORTS NS_DECL_NSAHTTPTRANSACTION NS_DECL_NSIINPUTSTREAMCALLBACK NS_DECL_NSIOUTPUTSTREAMCALLBACK nsHttpTransaction(); virtual ~nsHttpTransaction(); // // called to initialize the transaction // // @param caps // the transaction capabilities (see nsHttp.h) // @param connInfo // the connection type for this transaction. // @param reqHeaders // the request header struct // @param reqBody // the request body (POST or PUT data stream) // @param reqBodyIncludesHeaders // fun stuff to support NPAPI plugins. // @param target // the dispatch target were notifications should be sent. // @param callbacks // the notification callbacks to be given to PSM. // @param responseBody // the input stream that will contain the response data. async // wait on this input stream for data. on first notification, // headers should be available (check transaction status). // nsresult Init(PRUint8 caps, nsHttpConnectionInfo *connInfo, nsHttpRequestHead *reqHeaders, nsIInputStream *reqBody, bool reqBodyIncludesHeaders, nsIEventTarget *consumerTarget, nsIInterfaceRequestor *callbacks, nsITransportEventSink *eventsink, nsIAsyncInputStream **responseBody); // attributes PRUint8 Caps() { return mCaps; } nsHttpConnectionInfo *ConnectionInfo() { return mConnInfo; } nsHttpResponseHead *ResponseHead() { return mHaveAllHeaders ? mResponseHead : nsnull; } nsISupports *SecurityInfo() { return mSecurityInfo; } nsIInterfaceRequestor *Callbacks() { return mCallbacks; } nsIEventTarget *ConsumerTarget() { return mConsumerTarget; } // Called to take ownership of the response headers; the transaction // will drop any reference to the response headers after this call. nsHttpResponseHead *TakeResponseHead(); // Called to find out if the transaction generated a complete response. bool ResponseIsComplete() { return mResponseIsComplete; } bool SSLConnectFailed() { return mSSLConnectFailed; } // SetPriority() may only be used by the connection manager. void SetPriority(PRInt32 priority) { mPriority = priority; } PRInt32 Priority() { return mPriority; } const TimingStruct& Timings() const { return mTimings; } private: nsresult Restart(); char *LocateHttpStart(char *buf, PRUint32 len, bool aAllowPartialMatch); nsresult ParseLine(char *line); nsresult ParseLineSegment(char *seg, PRUint32 len); nsresult ParseHead(char *, PRUint32 count, PRUint32 *countRead); nsresult HandleContentStart(); nsresult HandleContent(char *, PRUint32 count, PRUint32 *contentRead, PRUint32 *contentRemaining); nsresult ProcessData(char *, PRUint32, PRUint32 *); void DeleteSelfOnConsumerThread(); static NS_METHOD ReadRequestSegment(nsIInputStream *, void *, const char *, PRUint32, PRUint32, PRUint32 *); static NS_METHOD WritePipeSegment(nsIOutputStream *, void *, char *, PRUint32, PRUint32, PRUint32 *); bool TimingEnabled() const { return mCaps & NS_HTTP_TIMING_ENABLED; } private: nsCOMPtr mCallbacks; nsCOMPtr mTransportSink; nsCOMPtr mConsumerTarget; nsCOMPtr mSecurityInfo; nsCOMPtr mPipeIn; nsCOMPtr mPipeOut; nsCOMPtr mChannel; nsCOMPtr mActivityDistributor; nsCString mReqHeaderBuf; // flattened request headers nsCOMPtr mRequestStream; PRUint32 mRequestSize; nsAHttpConnection *mConnection; // hard ref nsHttpConnectionInfo *mConnInfo; // hard ref nsHttpRequestHead *mRequestHead; // weak ref nsHttpResponseHead *mResponseHead; // hard ref nsAHttpSegmentReader *mReader; nsAHttpSegmentWriter *mWriter; nsCString mLineBuf; // may contain a partial line PRInt64 mContentLength; // equals -1 if unknown PRInt64 mContentRead; // count of consumed content bytes // After a 304/204 or other "no-content" style response we will skip over // up to MAX_INVALID_RESPONSE_BODY_SZ bytes when looking for the next // response header to deal with servers that actually sent a response // body where they should not have. This member tracks how many bytes have // so far been skipped. PRUint32 mInvalidResponseBytesRead; nsHttpChunkedDecoder *mChunkedDecoder; TimingStruct mTimings; nsresult mStatus; PRInt16 mPriority; PRUint16 mRestartCount; // the number of times this transaction has been restarted PRUint8 mCaps; // state flags, all logically boolean, but not packed together into a // bitfield so as to avoid bitfield-induced races. See bug 560579. bool mClosed; bool mConnected; bool mHaveStatusLine; bool mHaveAllHeaders; bool mTransactionDone; bool mResponseIsComplete; bool mDidContentStart; bool mNoContent; // expecting an empty entity body bool mSentData; bool mReceivedData; bool mStatusEventPending; bool mHasRequestBody; bool mSSLConnectFailed; bool mHttpResponseMatched; bool mPreserveStream; // mClosed := transaction has been explicitly closed // mTransactionDone := transaction ran to completion or was interrupted // mResponseComplete := transaction ran to completion }; #endif // nsHttpTransaction_h__