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
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
/**
* @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 boost::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;
}
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;
TransferStats::ptr_t mStats;
};
} // end namespace LLCore
#endif // _LLCORE_HTTP_RESPONSE_H_
|
