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