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
|
/**
* @file httpresponse.h
* @brief Public-facing declarations for the HttpResponse class
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2012, 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 "_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
/// and return from the handler callback. Instances are refcounted
/// and callers can bump the count and retain the object as needed.
///
/// 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:
/// 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;
}
/// 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 * getHeaders() const
{
return mHeaders;
}
/// Behaves like @see setResponse() but for header data.
void setHeaders(HttpHeaders * 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.
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;
}
protected:
// Response data here
HttpStatus mStatus;
unsigned int mReplyOffset;
unsigned int mReplyLength;
unsigned int mReplyFullLength;
BufferArray * mBufferArray;
HttpHeaders * mHeaders;
std::string mContentType;
};
} // end namespace LLCore
#endif // _LLCORE_HTTP_RESPONSE_H_
|
