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_
|
