summaryrefslogtreecommitdiff
path: root/indra/llcorehttp/httpoptions.h
blob: 8a6de61b04bab9b7823e55bbbdf80cd1b6f23183 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/**
 * @file httpoptions.h
 * @brief Public-facing declarations for the HTTPOptions 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_OPTIONS_H_
#define	_LLCORE_HTTP_OPTIONS_H_


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


namespace LLCore
{


/// Really a struct in spirit, it provides options that
/// modify HTTP requests.
///
/// Sharing instances across requests.  It's intended that
/// these be shared across requests:  caller can create one
/// of these, set it up as needed and then reference it
/// repeatedly in HTTP operations.  But see the Threading
/// note about references.
///
/// Threading:  While this class does nothing to ensure thread
/// safety, it *is* intended to be shared between the application
/// thread and the worker thread.  This means that once an instance
/// is delivered to the library in request operations, the
/// option data must not be written until all such requests
/// complete and relinquish their references.
///
/// Allocation:  Refcounted, heap only.  Caller of the constructor
/// is given a refcount.
///
class HttpOptions : private boost::noncopyable
{
public:
	HttpOptions();

	typedef boost::shared_ptr<HttpOptions> ptr_t;

    virtual ~HttpOptions();						// Use release()

protected:
	
	HttpOptions(const HttpOptions &);			// Not defined
	void operator=(const HttpOptions &);		// Not defined

public:

	// Default:   false
	void				setWantHeaders(bool wanted);
	bool				getWantHeaders() const
	{
		return mWantHeaders;
	}

	// Default:  0
	void				setTrace(int long);
	int					getTrace() const
	{
		return mTracing;
	}

	// Default:  30
	void				setTimeout(unsigned int timeout);
	unsigned int		getTimeout() const
	{
		return mTimeout;
	}

	// Default:  0
	void				setTransferTimeout(unsigned int timeout);
	unsigned int		getTransferTimeout() const
	{
		return mTransferTimeout;
	}

    /// Sets the number of retries on an LLCore::HTTPRequest before the 
    /// request fails.
	// Default:  5
	void				setRetries(unsigned int retries);
	unsigned int		getRetries() const
	{
		return mRetries;
	}

	/// Sets minimal delay before request retries. In microseconds.
	/// HttpPolicy will increase delay from min to max with each retry
	// Default: 1 000 000 mcs
	void				setMinBackoff(HttpTime delay);
	HttpTime			getMinBackoff() const
	{
		return mMinRetryBackoff;
	}

	/// Sets maximum delay before request retries. In microseconds.
	/// HttpPolicy will increase delay from min to max with each retry
	// Default:  5 000 000 mcs
	void				setMaxBackoff(HttpTime delay);
	HttpTime			getMaxBackoff() const
	{
		return mMaxRetryBackoff;
	}

	// Default:  true
	void				setUseRetryAfter(bool use_retry);
	bool				getUseRetryAfter() const
	{
		return mUseRetryAfter;
	}

    /// Instructs the LLCore::HTTPRequest to follow redirects 
	/// Default: false
	void				setFollowRedirects(bool follow_redirect);
	bool				getFollowRedirects() const
	{
		return mFollowRedirects;
	}

    /// Instructs the LLCore::HTTPRequest to verify that the exchanged security
    /// certificate is authentic. 
    /// Default: false
    void				setSSLVerifyPeer(bool verify);
	bool				getSSLVerifyPeer() const
	{
		return mVerifyPeer;
	}

    /// Instructs the LLCore::HTTPRequest to verify that the name in the 
    /// security certificate matches the name of the host contacted.
    /// Default: false
    void				setSSLVerifyHost(bool verify);
	bool	        	getSSLVerifyHost() const
	{
		return mVerifyHost;
	}

    /// Sets the time for DNS name caching in seconds.  Setting this value
    /// to 0 will disable name caching.  Setting this value to -1 causes the 
    /// name cache to never time out.
    /// Default: -1
	void				setDNSCacheTimeout(int timeout);
	int					getDNSCacheTimeout() const
	{
		return mDNSCacheTimeout;
	}

    /// Retrieve only the headers and status from the request. Setting this 
    /// to true implies setWantHeaders(true) as well.
    /// Default: false
    void                setHeadersOnly(bool nobody);
    bool                getHeadersOnly() const
    {
        return mNoBody;
    }
	
protected:
	bool				mWantHeaders;
	int					mTracing;
	unsigned int		mTimeout;
	unsigned int		mTransferTimeout;
	unsigned int		mRetries;
	HttpTime			mMinRetryBackoff;
	HttpTime			mMaxRetryBackoff;
	bool				mUseRetryAfter;
	bool				mFollowRedirects;
	bool				mVerifyPeer;
	bool        		mVerifyHost;
	int					mDNSCacheTimeout;
    bool                mNoBody;
}; // end class HttpOptions


}  // end namespace HttpOptions

#endif	// _LLCORE_HTTP_OPTIONS_H_