Debian Codegraph @

src/core/ContentProvider.cpp

raw
1 /*
2 * This File is part of Davix, The IO library for HTTP based protocols
3 * Copyright (C) CERN 2019
4 * Author: Georgios Bitzes <[email protected]>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include "ContentProvider.hpp"
23 #include <fcntl.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <sstream>
27
28 #define SSTR(message) static_cast<std::ostringstream&>(std::ostringstream().flush() << message).str()
29
30 namespace Davix {
31
32 //------------------------------------------------------------------------------
33 // Empty constructor
34 //------------------------------------------------------------------------------
35 ContentProvider::ContentProvider() {
36 _errc = 0;
37 }
38
39 //------------------------------------------------------------------------------
40 // Is the object ok?
41 //------------------------------------------------------------------------------
42 bool ContentProvider::ok() const {
43 return (_errc == 0);
44 }
45
46 //------------------------------------------------------------------------------
47 // Has there been an error?
48 //------------------------------------------------------------------------------
49 int ContentProvider::getErrc() const {
50 return _errc;
51 }
52
53 //------------------------------------------------------------------------------
54 // Get error message
55 //------------------------------------------------------------------------------
56 std::string ContentProvider::getError() const {
57 return _errMsg;
58 }
59
60 //------------------------------------------------------------------------------
61 // Constructor
62 //------------------------------------------------------------------------------
63 BufferContentProvider::BufferContentProvider(const char* buf, size_t count)
64 : _buffer(buf), _count(count), _pos(0) {}
65
66 //------------------------------------------------------------------------------
67 // pullBytes implementation.
68 //------------------------------------------------------------------------------
69 ssize_t BufferContentProvider::pullBytes(char* target, size_t requestedBytes) {
70 if(_pos >= _count) {
71 // EOF
72 return 0;
73 }
74
75 size_t bytesToGive = requestedBytes;
76 if(_pos + bytesToGive > _count) {
77 // Asked for more bytes than we have, just give all remaining ones
78 bytesToGive = _count - _pos;
79 }
80
81 ::memcpy(target, _buffer + _pos, bytesToGive);
82 _pos += bytesToGive;
83 return bytesToGive;
84 }
85
86 //------------------------------------------------------------------------------
87 // Rewind implementation.
88 //------------------------------------------------------------------------------
89 bool BufferContentProvider::rewind() {
90 _pos = 0;
91 return true;
92 }
93
94 //------------------------------------------------------------------------------
95 // getSize implementation.
96 //------------------------------------------------------------------------------
97 ssize_t BufferContentProvider::getSize() {
98 return _count;
99 }
100
101 //------------------------------------------------------------------------------
102 // Constructor
103 //------------------------------------------------------------------------------
104 OwnedBufferContentProvider::OwnedBufferContentProvider(const char* buf, size_t count)
105 : _provider(NULL, 0) {
106
107 _contents.resize(count);
108 ::memcpy( (void*) _contents.data(), buf, count);
109 _provider = BufferContentProvider(_contents.c_str(), _contents.size());
110 }
111
112 //----------------------------------------------------------------------------
113 // Constructor
114 //----------------------------------------------------------------------------
115 OwnedBufferContentProvider::OwnedBufferContentProvider(const std::string &str)
116 : _provider(NULL, 0) {
117
118 _contents = str;
119 _provider = BufferContentProvider(_contents.c_str(), _contents.size());
120 }
121
122 //------------------------------------------------------------------------------
123 // pullBytes implementation.
124 //------------------------------------------------------------------------------
125 ssize_t OwnedBufferContentProvider::pullBytes(char* target, size_t requestedBytes) {
126 return _provider.pullBytes(target, requestedBytes);
127 }
128
129 //------------------------------------------------------------------------------
130 // Rewind implementation.
131 //------------------------------------------------------------------------------
132 bool OwnedBufferContentProvider::rewind() {
133 return _provider.rewind();
134 }
135
136 //------------------------------------------------------------------------------
137 // getSize implementation.
138 //------------------------------------------------------------------------------
139 ssize_t OwnedBufferContentProvider::getSize() {
140 return _provider.getSize();
141 }
142
143 //------------------------------------------------------------------------------
144 // FdContentProvider constructor
145 //------------------------------------------------------------------------------
146 FdContentProvider::FdContentProvider(int fd, off_t offset, size_t maxLen)
147 : _fd(fd), _offset(offset), _target_len(maxLen) {
148
149 _fd_size = ::lseek(_fd, 0, SEEK_END);
150
151 if(_offset >= _fd_size) {
152 _errc = ERANGE;
153 _errMsg = SSTR("Invalid offset (" << offset << ") given, fd contains only " << _fd_size << " bytes");
154 return;
155 }
156
157 if(_target_len == 0) {
158 _target_len = _fd_size - _offset;
159 }
160 else {
161 _target_len = std::min<ssize_t>( (ssize_t) _target_len, (ssize_t) _fd_size - _offset);
162 }
163
164 if(_fd_size == -1) {
165 _errc = errno;
166 _errMsg = strerror(_errc);
167 }
168 else {
169 rewind();
170 }
171 }
172
173 //------------------------------------------------------------------------------
174 // pullBytes implementation.
175 //------------------------------------------------------------------------------
176 ssize_t FdContentProvider::pullBytes(char* target, size_t requestedBytes) {
177 if(!ok()) {
178 return - _errc;
179 }
180
181 if(eof) {
182 return 0;
183 }
184
185 if(requestedBytes > _target_len - _bytes_provided) {
186 requestedBytes = _target_len - _bytes_provided;
187 }
188
189 while(true) {
190 ssize_t retval = ::read(_fd, target, requestedBytes);
191
192 if(retval >= 0) {
193 // No errors
194 _bytes_provided += retval;
195 return retval;
196 }
197 else if(retval == -1 && errno == EINTR) {
198 // Interrupted by a signal... retry...
199 continue;
200 }
201 else {
202 // Error
203 _errc = errno;
204 _errMsg = strerror(_errc);
205 return - _errc;
206 }
207 }
208 }
209
210 //------------------------------------------------------------------------------
211 // Rewind implementation.
212 //------------------------------------------------------------------------------
213 bool FdContentProvider::rewind() {
214 if(!ok()) {
215 return false;
216 }
217
218 _bytes_provided = 0;
219 eof = false;
220
221 off_t retval = ::lseek(_fd, _offset, SEEK_SET);
222 if(retval == -1) {
223 _errc = errno;
224 _errMsg = strerror(_errc);
225 return false;
226 }
227
228 return true;
229 }
230
231 //------------------------------------------------------------------------------
232 // getSize implementation.
233 //------------------------------------------------------------------------------
234 ssize_t FdContentProvider::getSize() {
235 return _target_len;
236 }
237
238 //------------------------------------------------------------------------------
239 // Constructor
240 //------------------------------------------------------------------------------
241 CallbackContentProvider::CallbackContentProvider(HttpBodyProvider provider, dav_size_t len,
242 void *udata) : _provider(provider), _len(len), _udata(udata) {}
243
244 //----------------------------------------------------------------------------
245 // Constructor
246 //----------------------------------------------------------------------------
247 CallbackContentProvider::CallbackContentProvider(DataProviderFun provider, dav_size_t len)
248 : _providerFun(provider), _len(len) {}
249
250 //------------------------------------------------------------------------------
251 // pullBytes implementation.
252 //------------------------------------------------------------------------------
253 ssize_t CallbackContentProvider::pullBytes(char* target, size_t requestedBytes) {
254 if(!ok()) {
255 return - _errc;
256 }
257
258 if(requestedBytes == 0) {
259 return 0;
260 }
261
262 ssize_t retval;
263 if(_providerFun) {
264 retval = _providerFun(target, requestedBytes);
265 }
266 else {
267 retval = _provider(_udata, target, requestedBytes);
268 }
269
270 if(retval < 0) {
271 _errc = -retval;
272 _errMsg = strerror(_errc);
273 return -_errc;
274 }
275
276 return retval;
277 }
278
279 //------------------------------------------------------------------------------
280 // Rewind implementation.
281 //------------------------------------------------------------------------------
282 bool CallbackContentProvider::rewind() {
283 if(!ok()) {
284 return false;
285 }
286
287 if(_providerFun) {
288 _providerFun(NULL, 0);
289 }
290 else {
291 _provider(_udata, NULL, 0);
292 }
293
294 return true;
295 }
296
297 //------------------------------------------------------------------------------
298 // getSize implementation.
299 //------------------------------------------------------------------------------
300 ssize_t CallbackContentProvider::getSize() {
301 return _len;
302 }
303
304 }