Debian Codegraph @

src/request/httprequest.cpp

raw
1 /*
2 * This File is part of Davix, The IO library for HTTP based protocols
3 * Copyright (C) CERN 2013
4 * Author: Adrien Devresse <[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 <davix_internal.hpp>
23
24 #include <neon/neonrequest.hpp>
25 #include <davix_context_internal.hpp>
26 #include <request/httprequest.hpp>
27
28 namespace Davix {
29
30 //------------------------------------------------------------------------------
31 // TODO: Explain why the distinction between
32 // NEONRequest / NeonRequest / BackendRequest is necessary (ABI compatibility)
33 //------------------------------------------------------------------------------
34 class NEONRequest {
35 public:
36 NEONRequest(BackendRequest *req) : _req(req) {}
37
38 virtual ~NEONRequest() {
39 delete _req;
40 }
41
42 BackendRequest* get() {
43 return _req;
44 }
45
46 private:
47 BackendRequest* _req;
48 };
49
50 typedef NEONRequest WrappedBackendRequest;
51
52 template <typename...> struct WhichType;
53
54
55 static WrappedBackendRequest* createBackendRequest(HttpRequest* req, Context & context, const Uri & uri) {
56 BoundHooks boundHooks;
57
58 RequestPreSendHook presendHook = context.getHook<RequestPreSendHook>();
59 RequestPreReceHook prereceiveHook = context.getHook<RequestPreReceHook>();
60
61 using std::placeholders::_1;
62 using std::placeholders::_2 ;
63 using std::placeholders::_3;
64
65 if(presendHook) {
66 boundHooks.presendHook = std::bind(presendHook, std::ref(*req), _1);
67 }
68
69 if(prereceiveHook) {
70 boundHooks.prereceiveHook = std::bind(prereceiveHook, std::ref(*req), _1, _2, _3);
71 }
72
73 return new WrappedBackendRequest(new NeonRequest(boundHooks, context, uri));
74 }
75
76 /////////////////////////////////////////////////////////////////////////
77 /////////////////////////////////////////////////////////////////////////
78
79 HttpRequest::HttpRequest(WrappedBackendRequest* req) {
80 std::cerr << "Usage of HttpRequest::HttpRequest(NEONRequest* req) is deprecated!" << std::endl;
81 }
82
83 HttpRequest::HttpRequest(Context & context, const Uri & uri, DavixError** err) :
84 d_ptr(createBackendRequest(this, context, uri)) {
85
86 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_HTTP, "Create HttpRequest for {}", uri.getString());
87 if(uri.getStatus() != StatusCode::OK){
88 DavixError::setupError(err, davix_scope_http_request(), StatusCode::UriParsingError, fmt::format(" {} is not a valid HTTP or Webdav URL", uri));
89 }
90 }
91
92 HttpRequest::HttpRequest(Context & context, const std::string & url, DavixError** err) {
93 Uri uri(url);
94 d_ptr = createBackendRequest(this, context, uri);
95 if(uri.getStatus() != StatusCode::OK){
96 DavixError::setupError(err, davix_scope_http_request(), StatusCode::UriParsingError, fmt::format(" {} is not a valid HTTP or Webdav URL", uri));
97 }
98 }
99
100 HttpRequest::~HttpRequest()
101 {
102 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CORE, "Destroy HttpRequest");
103 delete d_ptr;
104 }
105
106 void HttpRequest::setRequestMethod(const std::string &request_str){
107 d_ptr->get()->setRequestMethod(request_str);
108 }
109
110
111 void HttpRequest::addHeaderField(const std::string &field, const std::string &value){
112 d_ptr->get()->addHeaderField(field, value);
113 }
114
115 void HttpRequest::setParameters(const RequestParams &p){
116 d_ptr->get()->setParameters(p);
117 }
118
119 void HttpRequest::setRequestBody(const std::string &body){
120 d_ptr->get()->setRequestBody(body);
121 }
122
123 void HttpRequest::setRequestBody(const void *buffer, dav_size_t len_buff){
124 d_ptr->get()->setRequestBody(buffer, len_buff);
125 }
126
127 void HttpRequest::setRequestBody(int fd, dav_off_t offset, dav_size_t len){
128 d_ptr->get()->setRequestBody(fd, offset, len);
129 }
130
131 void HttpRequest::setRequestBody(HttpBodyProvider provider, dav_size_t len, void* udata){
132 d_ptr->get()->setRequestBody(provider, len, udata);
133 }
134
135 void HttpRequest::setRequestBody(ContentProvider &provider) {
136 d_ptr->get()->setRequestBody(provider);
137 }
138
139 int HttpRequest::getRequestCode(){
140 return d_ptr->get()->getRequestCode();
141 }
142
143 int HttpRequest::executeRequest(DavixError **err){
144 TRY_DAVIX{
145 runPreRunHook();
146 return d_ptr->get()->executeRequest(err);
147 }CATCH_DAVIX(err)
148 return -1;
149 }
150
151 int HttpRequest::beginRequest(DavixError **err){
152 TRY_DAVIX{
153 // triggers Hooks
154 runPreRunHook();
155 return d_ptr->get()->beginRequest(err);
156 }CATCH_DAVIX(err)
157 return -1;
158 }
159
160 dav_ssize_t HttpRequest::readBlock(char *buffer, dav_size_t max_size, DavixError **err){
161 TRY_DAVIX{
162 return d_ptr->get()->readBlock(buffer, max_size, err);
163 }CATCH_DAVIX(err)
164 return -1;
165 }
166
167 dav_ssize_t HttpRequest::readBlock(std::vector<char> & buffer, dav_size_t max_size, DavixError **err){
168 dav_ssize_t ret=-1, v_size = (dav_ssize_t) buffer.size();
169 TRY_DAVIX{
170
171 buffer.resize(v_size + max_size);
172 ret = readBlock(((char*) &buffer[0])+ v_size, max_size, err);
173 buffer.resize(v_size + ( (ret > 0)?ret:0));
174 }CATCH_DAVIX(err)
175 return ret;
176 }
177
178 dav_ssize_t HttpRequest::readSegment(char* buffer, dav_size_t max_size, DavixError** err){
179 return d_ptr->get()->readSegment(buffer, max_size, false, err);
180 }
181
182 dav_ssize_t HttpRequest::readLine(char *buffer, dav_size_t max_size, DavixError **err){
183 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CORE, "Davix::Request::readLine want to read a line of max {} chars", max_size);
184 dav_ssize_t ret= -1;
185 TRY_DAVIX{
186 if( (ret = d_ptr->get()->readLine(buffer, max_size, err)) >= 0){
187 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CORE, "Davix::Request::readLine got {} chars", ret);
188 DAVIX_SLOG(DAVIX_LOG_TRACE, DAVIX_LOG_CORE, "Davix::Request::readLine content\n[[{}]]\n", std::string(buffer, ret));
189 }
190 }CATCH_DAVIX(err)
191 return ret;
192 }
193
194 void HttpRequest::discardBody(DavixError** err){
195 char buffer[1024];
196 dav_ssize_t read;
197 TRY_DAVIX{
198 do {
199 read = d_ptr->get()->readSegment(buffer, sizeof(buffer), false, err);
200 } while (read > 0 && *err == NULL);
201 }CATCH_DAVIX(err)
202 }
203
204 dav_ssize_t HttpRequest::readToFd(int fd, DavixError** err){
205 TRY_DAVIX{
206 return d_ptr->get()->readToFd(fd, 0, err);
207 }CATCH_DAVIX(err)
208 return -1;
209 }
210
211
212 dav_ssize_t HttpRequest::readToFd(int fd, dav_size_t read_size, DavixError** err){
213 TRY_DAVIX{
214 return d_ptr->get()->readToFd(fd, read_size, err);
215 }CATCH_DAVIX(err)
216 return -1;
217 }
218
219 int HttpRequest::endRequest(DavixError **err){
220 TRY_DAVIX{
221 return d_ptr->get()->endRequest(err);
222 }CATCH_DAVIX(err)
223 return -1;
224 }
225
226
227 void HttpRequest::clearAnswerContent(){
228 d_ptr->get()->clearAnswerContent();
229 }
230
231 bool HttpRequest::getAnswerHeader(const std::string &header_name, std::string &value) const{
232 return d_ptr->get()->getAnswerHeader(header_name, value);
233 }
234
235 size_t HttpRequest::getAnswerHeaders( HeaderVec & vec_headers) const{
236 return d_ptr->get()->getAnswerHeaders(vec_headers);
237 }
238
239 const char* HttpRequest::getAnswerContent(){
240 return d_ptr->get()->getAnswerContent();
241 }
242
243 std::vector<char> & HttpRequest::getAnswerContentVec(){
244 return d_ptr->get()->getAnswerContentVec();
245 }
246
247
248 /// get content length
249 dav_ssize_t HttpRequest::getAnswerSize() const{
250 return d_ptr->get()->getAnswerSize();
251 }
252
253 time_t HttpRequest::getLastModified() const{
254 return d_ptr->get()->getLastModified();
255 }
256
257
258 HttpCacheToken* HttpRequest::extractCacheToken()const{
259 return NULL;
260 }
261
262 void HttpRequest::useCacheToken(const HttpCacheToken *token){
263 (void) token;
264 }
265
266 /// set a HttpRequest flag
267 void HttpRequest::setFlag(const RequestFlag::RequestFlag flag, bool value){
268 d_ptr->get()->setFlag(flag, value);
269 }
270
271 /// get a HttpRequest flag value
272 bool HttpRequest::getFlag(const RequestFlag::RequestFlag flag){
273 return d_ptr->get()->getFlag(flag);
274 }
275
276 void HttpRequest::runPreRunHook(){
277 // triggers Hooks
278 RequestPreRunHook hook = d_ptr->get()->getContext().getHook<RequestPreRunHook>();
279
280 if(hook){
281 hook(d_ptr->get()->getParameters(), *this, *(d_ptr->get()->getOriginalUri()));
282 }
283 }
284
285
286 ///////////////////////////////////////////////////
287 ///// Simplified request GET
288 ////////////////////////////////////////////////////
289
290 GetRequest::GetRequest(Context & context, const Uri & uri, DavixError** err) :
291 HttpRequest(context, uri, err)
292 {
293
294 }
295
296
297 ///////////////////////////////////////////////////
298 ///// Simplified request PUT
299 ////////////////////////////////////////////////////
300
301 PutRequest::PutRequest(Context & context, const Uri & uri, DavixError** err) :
302 HttpRequest(context, uri, err)
303 {
304 setRequestMethod("PUT");
305 setFlag(RequestFlag::SupportContinue100, true);
306 setFlag(RequestFlag::IdempotentRequest, false);
307 }
308
309 ///////////////////////////////////////////////////
310 ///// Simplified request POST
311 ////////////////////////////////////////////////////
312
313 PostRequest::PostRequest(Context & context, const Uri & uri, DavixError** err) :
314 HttpRequest(context, uri, err)
315 {
316 setRequestMethod("POST");
317 setFlag(RequestFlag::IdempotentRequest, false);
318 }
319
320 ///////////////////////////////////////////////////
321 ///// Simplified request HEAD
322 ////////////////////////////////////////////////////
323
324 HeadRequest::HeadRequest(Context & context, const Uri & uri, DavixError** err) :
325 HttpRequest(context, uri, err)
326 {
327 setRequestMethod("HEAD");
328 }
329
330
331 ///////////////////////////////////////////////////
332 ///// Simplified request DELETE
333 ////////////////////////////////////////////////////
334
335 DeleteRequest::DeleteRequest(Context & context, const Uri & uri, DavixError** err) :
336 HttpRequest(context, uri, err)
337 {
338 setFlag(RequestFlag::IdempotentRequest, false);
339 setRequestMethod("DELETE");
340 }
341
342 ///////////////////////////////////////////////////
343 ///// Simplified request PROPFIND
344 ////////////////////////////////////////////////////
345
346 PropfindRequest::PropfindRequest(Context & context, const Uri & uri, DavixError** err) :
347 HttpRequest(context, uri, err)
348 {
349 setRequestMethod("PROPFIND");
350 }
351
352
353 void httpcodeToDavixError(int code, const std::string &scope, const std::string & end_message, StatusCode::Code & dav_code, std::string & err_msg){
354 std::string str_msg = "Status Ok";
355 switch (code) {
356 case 200: /* OK */
357 case 201: /* Created */
358 case 202: /* Accepted */
359 case 203: /* Non-Authoritative Information */
360 case 204: /* No Content */
361 case 206: /* partial content*/
362 case 205: /* Reset Content */
363 case 207: /* Multi-Status */
364 case 304: /* Not Modified */
365 dav_code = StatusCode::OK;
366 str_msg = "Success";
367 break;
368 case 401: /* Unauthorized */
369 case 402: /* Payment Required */
370 case 407: /* Proxy Authentication Required */
371 dav_code = StatusCode::AuthenticationError;
372 str_msg = "Authentication Error";
373 break;
374 case 303: /* See Other */
375 case 404: /* Not Found */
376 case 410: /* Gone */
377 dav_code = StatusCode::FileNotFound;
378 str_msg = "File not found";
379 break;
380 case 408: /* Request Timeout */
381 case 504: /* Gateway Timeout */
382 dav_code = StatusCode::OperationTimeout;
383 str_msg = "Operation timeout";
384 break;
385 case 409:
386 if (scope == davix_scope_mkdir_str()){
387 dav_code = StatusCode::FileNotFound;
388 str_msg = "Conflict, File not Found";
389 } else{
390 dav_code = StatusCode::FileExist;
391 str_msg = "Conflict, File Exist";
392 }
393 break;
394 case 423: /* Locked */
395 case 403: /* Forbidden */
396 dav_code = StatusCode::PermissionRefused;
397 str_msg = "Permission refused";
398 break;
399 break;
400 case 405: /* Method Not Allowed */
401 if (scope == davix_scope_mkdir_str()){
402 dav_code = StatusCode::FileExist;
403 str_msg = "Method Not Allowed, File Exist";
404 } else{
405 dav_code = StatusCode::PermissionRefused; // Technically is a EPERM
406 str_msg = "Method Not Allowed, Permission refused";
407 }
408 break;
409 case 400: /* Bad Request */
410 case 411: /* Length Required */
411 case 412: /* Precondition Failed */
412 case 414: /* Request-URI Too Long */
413 case 415: /* Unsupported Media Type */
414 case 424: /* Failed Dependency */
415 case 501: /* Not Implemented */
416 case 413: /* Request Entity Too Large */
417 dav_code = StatusCode::ConnectionProblem;
418 str_msg = "Server Error";
419 break;
420 case 507: /* Insufficient Storage */
421 dav_code = StatusCode::InsufficientStorage;
422 str_msg = "Insufficient Storage";
423 break;
424 case 301: /* Moved Permanently */
425 case 300: /* Multiple Choices */
426 case 302: /* Found */
427 dav_code = StatusCode::RedirectionNeeded;
428 str_msg = "Redirection requested, transparent redirection disabled";
429 break;
430 case 305: /* Use Proxy */
431 case 306: /* (Unused) */
432 case 307: /* Temporary Redirect */
433 case 406: /* Not Acceptable */
434 case 416: /* Requested Range Not Satisfiable */
435 case 417: /* Expectation Failed */
436 case 422: /* Unprocessable Entity */
437 case 500: /* Internal Server Error */
438 case 502: /* Bad Gateway */
439 case 503: /* Service Unavailable */
440 case 505: /* HTTP Version Not Supported */
441 default:
442 dav_code = StatusCode::UnknownError;
443 std::ostringstream ss;
444 ss << "Unexpected server error: " << code;
445 str_msg = ss.str().c_str();
446 break;
447 }
448
449 err_msg.assign(fmt::format("HTTP {} : {} {}", code, str_msg, end_message));
450 }
451
452 void httpcodeToDavixError(int code, const std::string & scope, const std::string & end_message, DavixError** err){
453 StatusCode::Code davix_code;
454 std::string err_msg;
455 httpcodeToDavixError(code, scope, end_message, davix_code, err_msg);
456 DavixError::setupError(err, scope, davix_code, err_msg);
457 }
458
459
460 void httpcodeToDavixException(int code, const std::string & scope, const std::string & end_message){
461 StatusCode::Code davix_code;
462 std::string err_msg;
463 httpcodeToDavixError(code, scope, end_message, davix_code, err_msg);
464 throw DavixException(scope, davix_code, err_msg);
465 }
466
467 bool httpcodeIsValid(int code)
468 {
469 switch (code) {
470 case 200: /* OK */
471 case 201: /* Created */
472 case 202: /* Accepted */
473 case 203: /* Non-Authoritative Information */
474 case 204: /* No Content */
475 case 206: /* partial content */
476 case 205: /* Reset Content */
477 case 207: /* Multi-Status */
478 case 304: /* Not Modified */
479 return true;
480 default:
481 return false;
482 }
483 }
484
485
486 } // namespace Davix