path: root/indra/llcorehttp/httpresponse.h

/**
 * @file httpresponse.h
 * @brief Public-facing declarations for the HttpResponse class
 *
 * $LicenseInfo:firstyear=2012&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2012-2013, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef	_LLCORE_HTTP_RESPONSE_H_
#define	_LLCORE_HTTP_RESPONSE_H_


#include <string>

#include "httpcommon.h"
#include "httpheaders.h"
#include "_refcounted.h"


namespace LLCore
{

class BufferArray;
class HttpHeaders;

/// HttpResponse is instantiated by the library and handed to
/// the caller during callbacks to the handler.  It supplies
/// all the status, header and HTTP body data the caller is
/// interested in.  Methods provide simple getters to return
/// individual pieces of the response.
///
/// Typical usage will have the caller interrogate the object
/// during the handler callback and then simply returning.
/// But instances are refcounted and and callers can add a
/// reference and hold onto the object after the callback.
///
/// Threading:  Not intrinsically thread-safe.
///
/// Allocation:  Refcounted, heap only.  Caller of the constructor
/// is given a refcount.
///
class HttpResponse : public LLCoreInt::RefCounted
{
public:
	HttpResponse();

protected:
	virtual ~HttpResponse();							// Use release()
	
	HttpResponse(const HttpResponse &);					// Not defined
	void operator=(const HttpResponse &);				// Not defined
	
public:
	/// Statistics for the HTTP 
	struct TransferStats
	{
		typedef std::shared_ptr<TransferStats> ptr_t;

		TransferStats() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {}
		F64 mSizeDownload;
		F64 mTotalTime;
		F64 mSpeedDownload;
	};


	/// Returns the final status of the requested operation.
	///
	HttpStatus getStatus() const
		{
			return mStatus;
		}

	void setStatus(const HttpStatus & status)
		{
			mStatus = status;
		}

	/// Simple getter for the response body returned as a scatter/gather
	/// buffer.  If the operation doesn't produce data (such as the Null
	/// or StopThread operations), this may be NULL.
	///
	/// Caller can hold onto the response by incrementing the reference
	/// count of the returned object.
	BufferArray * getBody() const
		{
			return mBufferArray;
		}

	/// Safely get the size of the body buffer.  If the body buffer is missing
	/// return 0 as the size.
	size_t getBodySize() const;

	/// Set the response data in the instance.  Will drop the reference
	/// count to any existing data and increment the count of that passed
	/// in.  It is legal to set the data to NULL.
	void setBody(BufferArray * ba);
	
	/// And a getter for the headers.  And as with @see getResponse(),
	/// if headers aren't available because the operation doesn't produce
	/// any or delivery of headers wasn't requested in the options, this
	/// will be NULL.
	///
	/// Caller can hold onto the headers by incrementing the reference
	/// count of the returned object.
	HttpHeaders::ptr_t getHeaders() const
	{
			return mHeaders;
	}

	/// Behaves like @see setResponse() but for header data.
	void setHeaders(HttpHeaders::ptr_t &headers);

	/// If a 'Range:' header was used, these methods are involved
	/// in setting and returning data about the actual response.
	/// If both @offset and @length are returned as 0, we probably
	/// didn't get a Content-Range header in the response.  This
	/// occurs with various Capabilities-based services and the
	/// caller is going to have to make assumptions on receipt of
	/// a 206 status.  The @full value may also be zero in cases of
	/// parsing problems or a wild-carded length response.
	///
	/// These values will not necessarily agree with the data in
	/// the body itself (if present).  The BufferArray object
	/// is authoritative for actual data length.
	void getRange(unsigned int * offset, unsigned int * length, unsigned int * full) const
		{
			*offset = mReplyOffset;
			*length = mReplyLength;
			*full = mReplyFullLength;
		}

	void setRange(unsigned int offset, unsigned int length, unsigned int full_length)
		{
			mReplyOffset = offset;
			mReplyLength = length;
			mReplyFullLength = full_length;
		}

	///
	const std::string & getContentType() const
		{
			return mContentType;
		}

	void setContentType(const std::string & con_type)
		{
			mContentType = con_type;
		}

	/// Get and set retry attempt information on the request.
	void getRetries(unsigned int * retries, unsigned int * retries_503) const
		{
			if (retries)
			{
				*retries = mRetries;
			}
			if (retries_503)
			{
				*retries_503 = m503Retries;
			}
		}

	void setRetries(unsigned int retries, unsigned int retries_503)
		{
			mRetries = retries;
			m503Retries = retries_503;
		}

	void setTransferStats(TransferStats::ptr_t &stats) 
		{
			mStats = stats;
		}

	TransferStats::ptr_t getTransferStats()
		{
			return mStats;
		}

    void setRequestURL(const std::string &url)
        {
            mRequestUrl = url;
        }

    const std::string &getRequestURL() const
        {
            return mRequestUrl;
        }

    void setRequestMethod(const std::string &method)
        {
            mRequestMethod = method;
        }

    const std::string &getRequestMethod() const
        {
            return mRequestMethod;
        }

protected:
	// Response data here
	HttpStatus			mStatus;
	unsigned int		mReplyOffset;
	unsigned int		mReplyLength;
	unsigned int		mReplyFullLength;
	BufferArray *		mBufferArray;
	HttpHeaders::ptr_t	mHeaders;
	std::string			mContentType;
	unsigned int		mRetries;
	unsigned int		m503Retries;
    std::string         mRequestUrl;
    std::string         mRequestMethod;

	TransferStats::ptr_t	mStats;
};


}   // end namespace LLCore

#endif	// _LLCORE_HTTP_RESPONSE_H_