ceph/src/rgw/rgw_rest.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4
   5 #include <errno.h>
   6 #include <limits.h>
   7
   8 #include <boost/algorithm/string.hpp>
   9 #include "common/Formatter.h"
  10 #include "common/HTMLFormatter.h"
  11 #include "common/utf8.h"
  12 #include "include/str_list.h"
  13 #include "rgw_common.h"
  14 #include "rgw_rados.h"
  15 #include "rgw_formats.h"
  16 #include "rgw_op.h"
  17 #include "rgw_rest.h"
  18 #include "rgw_rest_swift.h"
  19 #include "rgw_rest_s3.h"
  20 #include "rgw_swift_auth.h"
  21 #include "rgw_cors_s3.h"
  22
  23 #include "rgw_client_io.h"
  24 #include "rgw_resolve.h"
  25
  26 #include <numeric>
  27
  28 #define dout_subsys ceph_subsys_rgw
  29
  30 struct rgw_http_status_code {
  31   int code;
  32   const char *name;
  33 };
  34
  35 const static struct rgw_http_status_code http_codes[] = {
  36   { 100, "Continue" },
  37   { 200, "OK" },
  38   { 201, "Created" },
  39   { 202, "Accepted" },
  40   { 204, "No Content" },
  41   { 205, "Reset Content" },
  42   { 206, "Partial Content" },
  43   { 207, "Multi Status" },
  44   { 208, "Already Reported" },
  45   { 300, "Multiple Choices" },
  46   { 301, "Moved Permanently" },
  47   { 302, "Found" },
  48   { 303, "See Other" },
  49   { 304, "Not Modified" },
  50   { 305, "User Proxy" },
  51   { 306, "Switch Proxy" },
  52   { 307, "Temporary Redirect" },
  53   { 308, "Permanent Redirect" },
  54   { 400, "Bad Request" },
  55   { 401, "Unauthorized" },
  56   { 402, "Payment Required" },
  57   { 403, "Forbidden" },
  58   { 404, "Not Found" },
  59   { 405, "Method Not Allowed" },
  60   { 406, "Not Acceptable" },
  61   { 407, "Proxy Authentication Required" },
  62   { 408, "Request Timeout" },
  63   { 409, "Conflict" },
  64   { 410, "Gone" },
  65   { 411, "Length Required" },
  66   { 412, "Precondition Failed" },
  67   { 413, "Request Entity Too Large" },
  68   { 414, "Request-URI Too Long" },
  69   { 415, "Unsupported Media Type" },
  70   { 416, "Requested Range Not Satisfiable" },
  71   { 417, "Expectation Failed" },
  72   { 422, "Unprocessable Entity" },
  73   { 500, "Internal Server Error" },
  74   { 501, "Not Implemented" },
  75   { 0, NULL },
  76 };
  77
  78 struct rgw_http_attr {
  79   const char *rgw_attr;
  80   const char *http_attr;
  81 };
  82
  83 /*
  84  * mapping between rgw object attrs and output http fields
  85  */
  86 static const struct rgw_http_attr base_rgw_to_http_attrs[] = {
  87   { RGW_ATTR_CONTENT_LANG,      "Content-Language" },
  88   { RGW_ATTR_EXPIRES,           "Expires" },
  89   { RGW_ATTR_CACHE_CONTROL,     "Cache-Control" },
  90   { RGW_ATTR_CONTENT_DISP,      "Content-Disposition" },
  91   { RGW_ATTR_CONTENT_ENC,       "Content-Encoding" },
  92   { RGW_ATTR_USER_MANIFEST,     "X-Object-Manifest" },
  93   { RGW_ATTR_X_ROBOTS_TAG ,     "X-Robots-Tag" },
  94   /* RGW_ATTR_AMZ_WEBSITE_REDIRECT_LOCATION header depends on access mode:
  95    * S3 endpoint: x-amz-website-redirect-location
  96    * S3Website endpoint: Location
  97    */
  98   { RGW_ATTR_AMZ_WEBSITE_REDIRECT_LOCATION, "x-amz-website-redirect-location" },
  99 };
 100
 101
 102 struct generic_attr {
 103   const char *http_header;
 104   const char *rgw_attr;
 105 };
 106
 107 /*
 108  * mapping between http env fields and rgw object attrs
 109  */
 110 static const struct generic_attr generic_attrs[] = {
 111   { "CONTENT_TYPE",             RGW_ATTR_CONTENT_TYPE },
 112   { "HTTP_CONTENT_LANGUAGE",    RGW_ATTR_CONTENT_LANG },
 113   { "HTTP_EXPIRES",             RGW_ATTR_EXPIRES },
 114   { "HTTP_CACHE_CONTROL",       RGW_ATTR_CACHE_CONTROL },
 115   { "HTTP_CONTENT_DISPOSITION", RGW_ATTR_CONTENT_DISP },
 116   { "HTTP_CONTENT_ENCODING",    RGW_ATTR_CONTENT_ENC },
 117   { "HTTP_X_ROBOTS_TAG",        RGW_ATTR_X_ROBOTS_TAG },
 118 };
 119
 120 map<string, string> rgw_to_http_attrs;
 121 static map<string, string> generic_attrs_map;
 122 map<int, const char *> http_status_names;
 123
 124 /*
 125  * make attrs look_like_this
 126  * converts dashes to underscores
 127  */
 128 string lowercase_underscore_http_attr(const string& orig)
 129 {
 130   const char *s = orig.c_str();
 131   char buf[orig.size() + 1];
 132   buf[orig.size()] = '\0';
 133
 134   for (size_t i = 0; i < orig.size(); ++i, ++s) {
 135     switch (*s) {
 136       case '-':
 137         buf[i] = '_';
 138         break;
 139       default:
 140         buf[i] = tolower(*s);
 141     }
 142   }
 143   return string(buf);
 144 }
 145
 146 /*
 147  * make attrs LOOK_LIKE_THIS
 148  * converts dashes to underscores
 149  */
 150 string uppercase_underscore_http_attr(const string& orig)
 151 {
 152   const char *s = orig.c_str();
 153   char buf[orig.size() + 1];
 154   buf[orig.size()] = '\0';
 155
 156   for (size_t i = 0; i < orig.size(); ++i, ++s) {
 157     switch (*s) {
 158       case '-':
 159         buf[i] = '_';
 160         break;
 161       default:
 162         buf[i] = toupper(*s);
 163     }
 164   }
 165   return string(buf);
 166 }
 167
 168 /*
 169  * make attrs look-like-this
 170  * converts underscores to dashes
 171  */
 172 string lowercase_dash_http_attr(const string& orig)
 173 {
 174   const char *s = orig.c_str();
 175   char buf[orig.size() + 1];
 176   buf[orig.size()] = '\0';
 177
 178   for (size_t i = 0; i < orig.size(); ++i, ++s) {
 179     switch (*s) {
 180       case '_':
 181         buf[i] = '-';
 182         break;
 183       default:
 184         buf[i] = tolower(*s);
 185     }
 186   }
 187   return string(buf);
 188 }
 189
 190 /*
 191  * make attrs Look-Like-This
 192  * converts underscores to dashes
 193  */
 194 string camelcase_dash_http_attr(const string& orig)
 195 {
 196   const char *s = orig.c_str();
 197   char buf[orig.size() + 1];
 198   buf[orig.size()] = '\0';
 199
 200   bool last_sep = true;
 201
 202   for (size_t i = 0; i < orig.size(); ++i, ++s) {
 203     switch (*s) {
 204       case '_':
 205       case '-':
 206         buf[i] = '-';
 207         last_sep = true;
 208         break;
 209       default:
 210         if (last_sep) {
 211           buf[i] = toupper(*s);
 212         } else {
 213           buf[i] = tolower(*s);
 214         }
 215         last_sep = false;
 216     }
 217   }
 218   return string(buf);
 219 }
 220
 221 /* avoid duplicate hostnames in hostnames lists */
 222 static set<string> hostnames_set;
 223 static set<string> hostnames_s3website_set;
 224
 225 void rgw_rest_init(CephContext *cct, RGWRados *store, RGWZoneGroup& zone_group)
 226 {
 227   store->init_host_id();
 228
 229   for (const auto& rgw2http : base_rgw_to_http_attrs)  {
 230     rgw_to_http_attrs[rgw2http.rgw_attr] = rgw2http.http_attr;
 231   }
 232
 233   for (const auto& http2rgw : generic_attrs) {
 234     generic_attrs_map[http2rgw.http_header] = http2rgw.rgw_attr;
 235   }
 236
 237   list<string> extended_http_attrs;
 238   get_str_list(cct->_conf->rgw_extended_http_attrs, extended_http_attrs);
 239
 240   list<string>::iterator iter;
 241   for (iter = extended_http_attrs.begin(); iter != extended_http_attrs.end(); ++iter) {
 242     string rgw_attr = RGW_ATTR_PREFIX;
 243     rgw_attr.append(lowercase_underscore_http_attr(*iter));
 244
 245     rgw_to_http_attrs[rgw_attr] = camelcase_dash_http_attr(*iter);
 246
 247     string http_header = "HTTP_";
 248     http_header.append(uppercase_underscore_http_attr(*iter));
 249
 250     generic_attrs_map[http_header] = rgw_attr;
 251   }
 252
 253   for (const struct rgw_http_status_code *h = http_codes; h->code; h++) {
 254     http_status_names[h->code] = h->name;
 255   }
 256
 257   hostnames_set.insert(cct->_conf->rgw_dns_name);
 258   hostnames_set.insert(zone_group.hostnames.begin(), zone_group.hostnames.end());
 259   hostnames_set.erase(""); // filter out empty hostnames
 260   ldout(cct, 20) << "RGW hostnames: " << hostnames_set << dendl;
 261   /* TODO: We should have a sanity check that no hostname matches the end of
 262    * any other hostname, otherwise we will get ambigious results from
 263    * rgw_find_host_in_domains.
 264    * Eg:
 265    * Hostnames: [A, B.A]
 266    * Inputs: [Z.A, X.B.A]
 267    * Z.A clearly splits to subdomain=Z, domain=Z
 268    * X.B.A ambigously splits to both {X, B.A} and {X.B, A}
 269    */
 270
 271   hostnames_s3website_set.insert(cct->_conf->rgw_dns_s3website_name);
 272   hostnames_s3website_set.insert(zone_group.hostnames_s3website.begin(), zone_group.hostnames_s3website.end());
 273   hostnames_s3website_set.erase(""); // filter out empty hostnames
 274   ldout(cct, 20) << "RGW S3website hostnames: " << hostnames_s3website_set << dendl;
 275   /* TODO: we should repeat the hostnames_set sanity check here
 276    * and ALSO decide about overlap, if any
 277    */
 278 }
 279
 280 static bool str_ends_with(const string& s, const string& suffix, size_t *pos)
 281 {
 282   size_t len = suffix.size();
 283   if (len > (size_t)s.size()) {
 284     return false;
 285   }
 286
 287   ssize_t p = s.size() - len;
 288   if (pos) {
 289     *pos = p;
 290   }
 291
 292   return s.compare(p, len, suffix) == 0;
 293 }
 294
 295 static bool rgw_find_host_in_domains(const string& host, string *domain, string *subdomain, set<string> valid_hostnames_set)
 296 {
 297   set<string>::iterator iter;
 298   /** TODO, Future optimization
 299    * store hostnames_set elements _reversed_, and look for a prefix match,
 300    * which is much faster than a suffix match.
 301    */
 302   for (iter = valid_hostnames_set.begin(); iter != valid_hostnames_set.end(); ++iter) {
 303     size_t pos;
 304     if (!str_ends_with(host, *iter, &pos))
 305       continue;
 306
 307     if (pos == 0) {
 308       *domain = host;
 309       subdomain->clear();
 310     } else {
 311       if (host[pos - 1] != '.') {
 312         continue;
 313       }
 314
 315       *domain = host.substr(pos);
 316       *subdomain = host.substr(0, pos - 1);
 317     }
 318     return true;
 319   }
 320   return false;
 321 }
 322
 323 static void dump_status(struct req_state *s, int status,
 324                         const char *status_name)
 325 {
 326   s->formatter->set_status(status, status_name);
 327   try {
 328     RESTFUL_IO(s)->send_status(status, status_name);
 329   } catch (rgw::io::Exception& e) {
 330     ldout(s->cct, 0) << "ERROR: s->cio->send_status() returned err="
 331                      << e.what() << dendl;
 332   }
 333 }
 334
 335 void rgw_flush_formatter_and_reset(struct req_state *s, Formatter *formatter)
 336 {
 337   std::ostringstream oss;
 338   formatter->output_footer();
 339   formatter->flush(oss);
 340   std::string outs(oss.str());
 341   if (!outs.empty() && s->op != OP_HEAD) {
 342     dump_body(s, outs);
 343   }
 344
 345   s->formatter->reset();
 346 }
 347
 348 void rgw_flush_formatter(struct req_state *s, Formatter *formatter)
 349 {
 350   std::ostringstream oss;
 351   formatter->flush(oss);
 352   std::string outs(oss.str());
 353   if (!outs.empty() && s->op != OP_HEAD) {
 354     dump_body(s, outs);
 355   }
 356 }
 357
 358 void dump_errno(int http_ret, string& out) {
 359   stringstream ss;
 360
 361   ss <<  http_ret << " " << http_status_names[http_ret];
 362   out = ss.str();
 363 }
 364
 365 void dump_errno(const struct rgw_err &err, string& out) {
 366   dump_errno(err.http_ret, out);
 367 }
 368
 369 void dump_errno(struct req_state *s)
 370 {
 371   dump_status(s, s->err.http_ret, http_status_names[s->err.http_ret]);
 372 }
 373
 374 void dump_errno(struct req_state *s, int http_ret)
 375 {
 376   dump_status(s, http_ret, http_status_names[http_ret]);
 377 }
 378
 379 void dump_header(struct req_state* const s,
 380                  const boost::string_ref& name,
 381                  const boost::string_ref& val)
 382 {
 383   try {
 384     RESTFUL_IO(s)->send_header(name, val);
 385   } catch (rgw::io::Exception& e) {
 386     ldout(s->cct, 0) << "ERROR: s->cio->send_header() returned err="
 387                      << e.what() << dendl;
 388   }
 389 }
 390
 391 static inline boost::string_ref get_sanitized_hdrval(ceph::buffer::list& raw)
 392 {
 393   /* std::string and thus boost::string_ref ARE OBLIGED to carry multiple
 394    * 0x00 and count them to the length of a string. We need to take that
 395    * into consideration and sanitize the size of a ceph::buffer::list used
 396    * to store metadata values (x-amz-meta-*, X-Container-Meta-*, etags).
 397    * Otherwise we might send 0x00 to clients. */
 398   const char* const data = raw.c_str();
 399   size_t len = raw.length();
 400
 401   if (len && data[len - 1] == '\0') {
 402     /* That's the case - the null byte has been included at the last position
 403      * of the bufferlist. We need to restore the proper string length we'll
 404      * pass to string_ref. */
 405     len--;
 406   }
 407
 408   return boost::string_ref(data, len);
 409 }
 410
 411 void dump_header(struct req_state* const s,
 412                  const boost::string_ref& name,
 413                  ceph::buffer::list& bl)
 414 {
 415   return dump_header(s, name, get_sanitized_hdrval(bl));
 416 }
 417
 418 void dump_header(struct req_state* const s,
 419                  const boost::string_ref& name,
 420                  const long long val)
 421 {
 422   char buf[32];
 423   const auto len = snprintf(buf, sizeof(buf), "%lld", val);
 424
 425   return dump_header(s, name, boost::string_ref(buf, len));
 426 }
 427
 428 void dump_header(struct req_state* const s,
 429                  const boost::string_ref& name,
 430                  const utime_t& ut)
 431 {
 432   char buf[32];
 433   const auto len = snprintf(buf, sizeof(buf), "%lld.%05d",
 434                             static_cast<long long>(ut.sec()),
 435                             static_cast<int>(ut.usec() / 10));
 436
 437   return dump_header(s, name, boost::string_ref(buf, len));
 438 }
 439
 440 void dump_content_length(struct req_state* const s, const uint64_t len)
 441 {
 442   try {
 443     RESTFUL_IO(s)->send_content_length(len);
 444   } catch (rgw::io::Exception& e) {
 445     ldout(s->cct, 0) << "ERROR: s->cio->send_content_length() returned err="
 446                      << e.what() << dendl;
 447   }
 448   dump_header(s, "Accept-Ranges", "bytes");
 449 }
 450
 451 static void dump_chunked_encoding(struct req_state* const s)
 452 {
 453   try {
 454     RESTFUL_IO(s)->send_chunked_transfer_encoding();
 455   } catch (rgw::io::Exception& e) {
 456     ldout(s->cct, 0) << "ERROR: RESTFUL_IO(s)->send_chunked_transfer_encoding()"
 457                      << " returned err=" << e.what() << dendl;
 458   }
 459 }
 460
 461 void dump_etag(struct req_state* const s,
 462                const boost::string_ref& etag,
 463                const bool quoted)
 464 {
 465   if (etag.empty()) {
 466     return;
 467   }
 468
 469   if (s->prot_flags & RGW_REST_SWIFT && ! quoted) {
 470     return dump_header(s, "etag", etag);
 471   } else {
 472     return dump_header_quoted(s, "ETag", etag);
 473   }
 474 }
 475
 476 void dump_etag(struct req_state* const s,
 477                ceph::buffer::list& bl_etag,
 478                const bool quoted)
 479 {
 480   return dump_etag(s, get_sanitized_hdrval(bl_etag), quoted);
 481 }
 482
 483 void dump_bucket_from_state(struct req_state *s)
 484 {
 485   if (g_conf->rgw_expose_bucket && ! s->bucket_name.empty()) {
 486     if (! s->bucket_tenant.empty()) {
 487       dump_header(s, "Bucket",
 488                   url_encode(s->bucket_tenant + "/" + s->bucket_name));
 489     } else {
 490       dump_header(s, "Bucket", url_encode(s->bucket_name));
 491     }
 492   }
 493 }
 494
 495 void dump_uri_from_state(struct req_state *s)
 496 {
 497   if (strcmp(s->info.request_uri.c_str(), "/") == 0) {
 498
 499     string location = "http://";
 500     string server = s->info.env->get("SERVER_NAME", "<SERVER_NAME>");
 501     location.append(server);
 502     location += "/";
 503     if (!s->bucket_name.empty()) {
 504       if (!s->bucket_tenant.empty()) {
 505         location += s->bucket_tenant;
 506         location += ":";
 507       }
 508       location += s->bucket_name;
 509       location += "/";
 510       if (!s->object.empty()) {
 511         location += s->object.name;
 512         dump_header(s, "Location", location);
 513       }
 514     }
 515   } else {
 516     dump_header_quoted(s, "Location", s->info.request_uri);
 517   }
 518 }
 519
 520 void dump_redirect(struct req_state * const s, const std::string& redirect)
 521 {
 522   return dump_header_if_nonempty(s, "Location", redirect);
 523 }
 524
 525 static size_t dump_time_header_impl(char (&timestr)[TIME_BUF_SIZE],
 526                                     const real_time t)
 527 {
 528   const utime_t ut(t);
 529   time_t secs = static_cast<time_t>(ut.sec());
 530
 531   struct tm result;
 532   const struct tm * const tmp = gmtime_r(&secs, &result);
 533   if (tmp == nullptr) {
 534     return 0;
 535   }
 536
 537   return strftime(timestr, sizeof(timestr),
 538                   "%a, %d %b %Y %H:%M:%S %Z", tmp);
 539 }
 540
 541 void dump_time_header(struct req_state *s, const char *name, real_time t)
 542 {
 543   char timestr[TIME_BUF_SIZE];
 544
 545   const size_t len = dump_time_header_impl(timestr, t);
 546   if (len == 0) {
 547     return;
 548   }
 549
 550   return dump_header(s, name, boost::string_ref(timestr, len));
 551 }
 552
 553 std::string dump_time_to_str(const real_time& t)
 554 {
 555   char timestr[TIME_BUF_SIZE];
 556   dump_time_header_impl(timestr, t);
 557
 558   return timestr;
 559 }
 560
 561
 562 void dump_last_modified(struct req_state *s, real_time t)
 563 {
 564   dump_time_header(s, "Last-Modified", t);
 565 }
 566
 567 void dump_epoch_header(struct req_state *s, const char *name, real_time t)
 568 {
 569   utime_t ut(t);
 570   char buf[65];
 571   const auto len = snprintf(buf, sizeof(buf), "%lld.%09lld",
 572                             (long long)ut.sec(),
 573                             (long long)ut.nsec());
 574
 575   return dump_header(s, name, boost::string_ref(buf, len));
 576 }
 577
 578 void dump_time(struct req_state *s, const char *name, real_time *t)
 579 {
 580   char buf[TIME_BUF_SIZE];
 581   rgw_to_iso8601(*t, buf, sizeof(buf));
 582
 583   s->formatter->dump_string(name, buf);
 584 }
 585
 586 void dump_owner(struct req_state *s, const rgw_user& id, string& name,
 587                 const char *section)
 588 {
 589   if (!section)
 590     section = "Owner";
 591   s->formatter->open_object_section(section);
 592   s->formatter->dump_string("ID", id.to_str());
 593   s->formatter->dump_string("DisplayName", name);
 594   s->formatter->close_section();
 595 }
 596
 597 void dump_access_control(struct req_state *s, const char *origin,
 598                          const char *meth,
 599                          const char *hdr, const char *exp_hdr,
 600                          uint32_t max_age) {
 601   if (origin && (origin[0] != '\0')) {
 602     dump_header(s, "Access-Control-Allow-Origin", origin);
 603     /* If the server specifies an origin host rather than "*",
 604      * then it must also include Origin in the Vary response header
 605      * to indicate to clients that server responses will differ
 606      * based on the value of the Origin request header.
 607      */
 608     if (strcmp(origin, "*") != 0) {
 609       dump_header(s, "Vary", "Origin");
 610     }
 611
 612     if (meth && (meth[0] != '\0')) {
 613       dump_header(s, "Access-Control-Allow-Methods", meth);
 614     }
 615     if (hdr && (hdr[0] != '\0')) {
 616       dump_header(s, "Access-Control-Allow-Headers", hdr);
 617     }
 618     if (exp_hdr && (exp_hdr[0] != '\0')) {
 619       dump_header(s, "Access-Control-Expose-Headers", exp_hdr);
 620     }
 621     if (max_age != CORS_MAX_AGE_INVALID) {
 622       dump_header(s, "Access-Control-Max-Age", max_age);
 623     }
 624   }
 625 }
 626
 627 void dump_access_control(req_state *s, RGWOp *op)
 628 {
 629   string origin;
 630   string method;
 631   string header;
 632   string exp_header;
 633   unsigned max_age = CORS_MAX_AGE_INVALID;
 634
 635   if (!op->generate_cors_headers(origin, method, header, exp_header, &max_age))
 636     return;
 637
 638   dump_access_control(s, origin.c_str(), method.c_str(), header.c_str(),
 639                       exp_header.c_str(), max_age);
 640 }
 641
 642 void dump_start(struct req_state *s)
 643 {
 644   if (!s->content_started) {
 645     s->formatter->output_header();
 646     s->content_started = true;
 647   }
 648 }
 649
 650 void dump_trans_id(req_state *s)
 651 {
 652   if (s->prot_flags & RGW_REST_SWIFT) {
 653     dump_header(s, "X-Trans-Id", s->trans_id);
 654     dump_header(s, "X-Openstack-Request-Id", s->trans_id);
 655   } else if (s->trans_id.length()) {
 656     dump_header(s, "x-amz-request-id", s->trans_id);
 657   }
 658 }
 659
 660 void end_header(struct req_state* s, RGWOp* op, const char *content_type,
 661                 const int64_t proposed_content_length, bool force_content_type,
 662                 bool force_no_error)
 663 {
 664   string ctype;
 665
 666   dump_trans_id(s);
 667
 668   if ((!s->is_err()) &&
 669       (s->bucket_info.owner != s->user->user_id) &&
 670       (s->bucket_info.requester_pays)) {
 671     dump_header(s, "x-amz-request-charged", "requester");
 672   }
 673
 674   if (op) {
 675     dump_access_control(s, op);
 676   }
 677
 678   if (s->prot_flags & RGW_REST_SWIFT && !content_type) {
 679     force_content_type = true;
 680   }
 681
 682   /* do not send content type if content length is zero
 683      and the content type was not set by the user */
 684   if (force_content_type ||
 685       (!content_type &&  s->formatter->get_len()  != 0) || s->is_err()){
 686     switch (s->format) {
 687     case RGW_FORMAT_XML:
 688       ctype = "application/xml";
 689       break;
 690     case RGW_FORMAT_JSON:
 691       ctype = "application/json";
 692       break;
 693     case RGW_FORMAT_HTML:
 694       ctype = "text/html";
 695       break;
 696     default:
 697       ctype = "text/plain";
 698       break;
 699     }
 700     if (s->prot_flags & RGW_REST_SWIFT)
 701       ctype.append("; charset=utf-8");
 702     content_type = ctype.c_str();
 703   }
 704   if (!force_no_error && s->is_err()) {
 705     dump_start(s);
 706     dump(s);
 707     dump_content_length(s, s->formatter->get_len());
 708   } else {
 709     if (proposed_content_length == CHUNKED_TRANSFER_ENCODING) {
 710       dump_chunked_encoding(s);
 711     } else if (proposed_content_length != NO_CONTENT_LENGTH) {
 712       dump_content_length(s, proposed_content_length);
 713     }
 714   }
 715
 716   if (content_type) {
 717     dump_header(s, "Content-Type", content_type);
 718   }
 719
 720   try {
 721     RESTFUL_IO(s)->complete_header();
 722   } catch (rgw::io::Exception& e) {
 723     ldout(s->cct, 0) << "ERROR: RESTFUL_IO(s)->complete_header() returned err="
 724                      << e.what() << dendl;
 725   }
 726
 727   ACCOUNTING_IO(s)->set_account(true);
 728   rgw_flush_formatter_and_reset(s, s->formatter);
 729 }
 730
 731 void abort_early(struct req_state *s, RGWOp* op, int err_no,
 732                 RGWHandler* handler)
 733 {
 734   string error_content("");
 735   if (!s->formatter) {
 736     s->formatter = new JSONFormatter;
 737     s->format = RGW_FORMAT_JSON;
 738   }
 739
 740   // op->error_handler is responsible for calling it's handler error_handler
 741   if (op != NULL) {
 742     int new_err_no;
 743     new_err_no = op->error_handler(err_no, &error_content);
 744     ldout(s->cct, 20) << "op->ERRORHANDLER: err_no=" << err_no
 745                       << " new_err_no=" << new_err_no << dendl;
 746     err_no = new_err_no;
 747   } else if (handler != NULL) {
 748     int new_err_no;
 749     new_err_no = handler->error_handler(err_no, &error_content);
 750     ldout(s->cct, 20) << "handler->ERRORHANDLER: err_no=" << err_no
 751                       << " new_err_no=" << new_err_no << dendl;
 752     err_no = new_err_no;
 753   }
 754
 755   // If the error handler(s) above dealt with it completely, they should have
 756   // returned 0. If non-zero, we need to continue here.
 757   if (err_no) {
 758     // Watch out, we might have a custom error state already set!
 759     if (!s->err.http_ret || s->err.http_ret == 200) {
 760       set_req_state_err(s, err_no);
 761     }
 762     dump_errno(s);
 763     dump_bucket_from_state(s);
 764     if (err_no == -ERR_PERMANENT_REDIRECT || err_no == -ERR_WEBSITE_REDIRECT) {
 765       string dest_uri;
 766       if (!s->redirect.empty()) {
 767         dest_uri = s->redirect;
 768       } else if (!s->zonegroup_endpoint.empty()) {
 769         dest_uri = s->zonegroup_endpoint;
 770         /*
 771          * reqest_uri is always start with slash, so we need to remove
 772          * the unnecessary slash at the end of dest_uri.
 773          */
 774         if (dest_uri[dest_uri.size() - 1] == '/') {
 775           dest_uri = dest_uri.substr(0, dest_uri.size() - 1);
 776         }
 777         dest_uri += s->info.request_uri;
 778         dest_uri += "?";
 779         dest_uri += s->info.request_params;
 780       }
 781
 782       if (!dest_uri.empty()) {
 783         dump_redirect(s, dest_uri);
 784       }
 785     }
 786
 787     if (!error_content.empty()) {
 788       /*
 789        * TODO we must add all error entries as headers here:
 790        * when having a working errordoc, then the s3 error fields are
 791        * rendered as HTTP headers, e.g.:
 792        *   x-amz-error-code: NoSuchKey
 793        *   x-amz-error-message: The specified key does not exist.
 794        *   x-amz-error-detail-Key: foo
 795        */
 796       end_header(s, op, NULL, error_content.size(), false, true);
 797       RESTFUL_IO(s)->send_body(error_content.c_str(), error_content.size());
 798     } else {
 799       end_header(s, op);
 800     }
 801   }
 802   perfcounter->inc(l_rgw_failed_req);
 803 }
 804
 805 void dump_continue(struct req_state * const s)
 806 {
 807   try {
 808     RESTFUL_IO(s)->send_100_continue();
 809   } catch (rgw::io::Exception& e) {
 810     ldout(s->cct, 0) << "ERROR: RESTFUL_IO(s)->send_100_continue() returned err="
 811                      << e.what() << dendl;
 812   }
 813 }
 814
 815 void dump_range(struct req_state* const s,
 816                 const uint64_t ofs,
 817                 const uint64_t end,
 818                 const uint64_t total)
 819 {
 820   /* dumping range into temp buffer first, as libfcgi will fail to digest
 821    * %lld */
 822   char range_buf[128];
 823   size_t len;
 824
 825   if (! total) {
 826     len = snprintf(range_buf, sizeof(range_buf), "bytes */%lld",
 827                    static_cast<long long>(total));
 828   } else {
 829     len = snprintf(range_buf, sizeof(range_buf), "bytes %lld-%lld/%lld",
 830                    static_cast<long long>(ofs),
 831                    static_cast<long long>(end),
 832                    static_cast<long long>(total));
 833   }
 834
 835   return dump_header(s, "Content-Range", boost::string_ref(range_buf, len));
 836 }
 837
 838
 839 int dump_body(struct req_state* const s,
 840               const char* const buf,
 841               const size_t len)
 842 {
 843   try {
 844     return RESTFUL_IO(s)->send_body(buf, len);
 845   } catch (rgw::io::Exception& e) {
 846     return -e.code().value();
 847   }
 848 }
 849
 850 int dump_body(struct req_state* const s, /* const */ ceph::buffer::list& bl)
 851 {
 852   return dump_body(s, bl.c_str(), bl.length());
 853 }
 854
 855 int dump_body(struct req_state* const s, const std::string& str)
 856 {
 857   return dump_body(s, str.c_str(), str.length());
 858 }
 859
 860 int recv_body(struct req_state* const s,
 861               char* const buf,
 862               const size_t max)
 863 {
 864   try {
 865     return RESTFUL_IO(s)->recv_body(buf, max);
 866   } catch (rgw::io::Exception& e) {
 867     return -e.code().value();
 868   }
 869 }
 870
 871 int RGWGetObj_ObjStore::get_params()
 872 {
 873   range_str = s->info.env->get("HTTP_RANGE");
 874   if_mod = s->info.env->get("HTTP_IF_MODIFIED_SINCE");
 875   if_unmod = s->info.env->get("HTTP_IF_UNMODIFIED_SINCE");
 876   if_match = s->info.env->get("HTTP_IF_MATCH");
 877   if_nomatch = s->info.env->get("HTTP_IF_NONE_MATCH");
 878
 879   if (s->system_request) {
 880     mod_zone_id = s->info.env->get_int("HTTP_DEST_ZONE_SHORT_ID", 0);
 881     mod_pg_ver = s->info.env->get_int("HTTP_DEST_PG_VER", 0);
 882     rgwx_stat = s->info.args.exists(RGW_SYS_PARAM_PREFIX "stat");
 883     get_data &= (!rgwx_stat);
 884   }
 885
 886   if (s->info.args.exists(GET_TORRENT)) {
 887     return torrent.get_params();
 888   }
 889   return 0;
 890 }
 891
 892 int RESTArgs::get_string(struct req_state *s, const string& name,
 893                          const string& def_val, string *val, bool *existed)
 894 {
 895   bool exists;
 896   *val = s->info.args.get(name, &exists);
 897
 898   if (existed)
 899     *existed = exists;
 900
 901   if (!exists) {
 902     *val = def_val;
 903     return 0;
 904   }
 905
 906   return 0;
 907 }
 908
 909 int RESTArgs::get_uint64(struct req_state *s, const string& name,
 910                          uint64_t def_val, uint64_t *val, bool *existed)
 911 {
 912   bool exists;
 913   string sval = s->info.args.get(name, &exists);
 914
 915   if (existed)
 916     *existed = exists;
 917
 918   if (!exists) {
 919     *val = def_val;
 920     return 0;
 921   }
 922
 923   int r = stringtoull(sval, val);
 924   if (r < 0)
 925     return r;
 926
 927   return 0;
 928 }
 929
 930 int RESTArgs::get_int64(struct req_state *s, const string& name,
 931                         int64_t def_val, int64_t *val, bool *existed)
 932 {
 933   bool exists;
 934   string sval = s->info.args.get(name, &exists);
 935
 936   if (existed)
 937     *existed = exists;
 938
 939   if (!exists) {
 940     *val = def_val;
 941     return 0;
 942   }
 943
 944   int r = stringtoll(sval, val);
 945   if (r < 0)
 946     return r;
 947
 948   return 0;
 949 }
 950
 951 int RESTArgs::get_uint32(struct req_state *s, const string& name,
 952                          uint32_t def_val, uint32_t *val, bool *existed)
 953 {
 954   bool exists;
 955   string sval = s->info.args.get(name, &exists);
 956
 957   if (existed)
 958     *existed = exists;
 959
 960   if (!exists) {
 961     *val = def_val;
 962     return 0;
 963   }
 964
 965   int r = stringtoul(sval, val);
 966   if (r < 0)
 967     return r;
 968
 969   return 0;
 970 }
 971
 972 int RESTArgs::get_int32(struct req_state *s, const string& name,
 973                         int32_t def_val, int32_t *val, bool *existed)
 974 {
 975   bool exists;
 976   string sval = s->info.args.get(name, &exists);
 977
 978   if (existed)
 979     *existed = exists;
 980
 981   if (!exists) {
 982     *val = def_val;
 983     return 0;
 984   }
 985
 986   int r = stringtol(sval, val);
 987   if (r < 0)
 988     return r;
 989
 990   return 0;
 991 }
 992
 993 int RESTArgs::get_time(struct req_state *s, const string& name,
 994                        const utime_t& def_val, utime_t *val, bool *existed)
 995 {
 996   bool exists;
 997   string sval = s->info.args.get(name, &exists);
 998
 999   if (existed)
1000     *existed = exists;
1001
1002   if (!exists) {
1003     *val = def_val;
1004     return 0;
1005   }
1006
1007   uint64_t epoch, nsec;
1008
1009   int r = utime_t::parse_date(sval, &epoch, &nsec);
1010   if (r < 0)
1011     return r;
1012
1013   *val = utime_t(epoch, nsec);
1014
1015   return 0;
1016 }
1017
1018 int RESTArgs::get_epoch(struct req_state *s, const string& name, uint64_t def_val, uint64_t *epoch, bool *existed)
1019 {
1020   bool exists;
1021   string date = s->info.args.get(name, &exists);
1022
1023   if (existed)
1024     *existed = exists;
1025
1026   if (!exists) {
1027     *epoch = def_val;
1028     return 0;
1029   }
1030
1031   int r = utime_t::parse_date(date, epoch, NULL);
1032   if (r < 0)
1033     return r;
1034
1035   return 0;
1036 }
1037
1038 int RESTArgs::get_bool(struct req_state *s, const string& name, bool def_val, bool *val, bool *existed)
1039 {
1040   bool exists;
1041   string sval = s->info.args.get(name, &exists);
1042
1043   if (existed)
1044     *existed = exists;
1045
1046   if (!exists) {
1047     *val = def_val;
1048     return 0;
1049   }
1050
1051   const char *str = sval.c_str();
1052
1053   if (sval.empty() ||
1054       strcasecmp(str, "true") == 0 ||
1055       sval.compare("1") == 0) {
1056     *val = true;
1057     return 0;
1058   }
1059
1060   if (strcasecmp(str, "false") != 0 &&
1061       sval.compare("0") != 0) {
1062     *val = def_val;
1063     return -EINVAL;
1064   }
1065
1066   *val = false;
1067   return 0;
1068 }
1069
1070
1071 void RGWRESTFlusher::do_start(int ret)
1072 {
1073   set_req_state_err(s, ret); /* no going back from here */
1074   dump_errno(s);
1075   dump_start(s);
1076   end_header(s, op);
1077   rgw_flush_formatter_and_reset(s, s->formatter);
1078 }
1079
1080 void RGWRESTFlusher::do_flush()
1081 {
1082   rgw_flush_formatter(s, s->formatter);
1083 }
1084
1085 int RGWPutObj_ObjStore::verify_params()
1086 {
1087   if (s->length) {
1088     off_t len = atoll(s->length);
1089     if (len > (off_t)(s->cct->_conf->rgw_max_put_size)) {
1090       return -ERR_TOO_LARGE;
1091     }
1092   }
1093
1094   return 0;
1095 }
1096
1097 int RGWPutObj_ObjStore::get_params()
1098 {
1099   /* start gettorrent */
1100   if (s->cct->_conf->rgw_torrent_flag)
1101   {
1102     int ret = 0;
1103     ret = torrent.get_params();
1104     ldout(s->cct, 5) << "NOTICE:  open produce torrent file " << dendl;
1105     if (ret < 0)
1106     {
1107       return ret;
1108     }
1109     torrent.set_info_name((s->object).name);
1110   }
1111   /* end gettorrent */
1112   supplied_md5_b64 = s->info.env->get("HTTP_CONTENT_MD5");
1113
1114   return 0;
1115 }
1116
1117 int RGWPutObj_ObjStore::get_data(bufferlist& bl)
1118 {
1119   size_t cl;
1120   uint64_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
1121   if (s->length) {
1122     cl = atoll(s->length) - ofs;
1123     if (cl > chunk_size)
1124       cl = chunk_size;
1125   } else {
1126     cl = chunk_size;
1127   }
1128
1129   int len = 0;
1130   {
1131     ACCOUNTING_IO(s)->set_account(true);
1132     bufferptr bp(cl);
1133
1134     const auto read_len  = recv_body(s, bp.c_str(), cl);
1135     if (read_len < 0) {
1136       return read_len;
1137     }
1138
1139     len = read_len;
1140     bl.append(bp, 0, len);
1141
1142     ACCOUNTING_IO(s)->set_account(false);
1143   }
1144
1145   if ((uint64_t)ofs + len > s->cct->_conf->rgw_max_put_size) {
1146     return -ERR_TOO_LARGE;
1147   }
1148
1149   if (!ofs)
1150     supplied_md5_b64 = s->info.env->get("HTTP_CONTENT_MD5");
1151
1152   return len;
1153 }
1154
1155
1156 /*
1157  * parses params in the format: 'first; param1=foo; param2=bar'
1158  */
1159 void RGWPostObj_ObjStore::parse_boundary_params(const std::string& params_str,
1160                                                 std::string& first,
1161                                                 std::map<std::string,
1162                                                 std::string>& params)
1163 {
1164   size_t pos = params_str.find(';');
1165   if (std::string::npos == pos) {
1166     first = rgw_trim_whitespace(params_str);
1167     return;
1168   }
1169
1170   first = rgw_trim_whitespace(params_str.substr(0, pos));
1171   pos++;
1172
1173   while (pos < params_str.size()) {
1174     size_t end = params_str.find(';', pos);
1175     if (std::string::npos == end) {
1176       end = params_str.size();
1177     }
1178
1179     std::string param = params_str.substr(pos, end - pos);
1180     size_t eqpos = param.find('=');
1181
1182     if (std::string::npos != eqpos) {
1183       std::string param_name = rgw_trim_whitespace(param.substr(0, eqpos));
1184       std::string val = rgw_trim_quotes(param.substr(eqpos + 1));
1185       params[std::move(param_name)] = std::move(val);
1186     } else {
1187       params[rgw_trim_whitespace(param)] = "";
1188     }
1189
1190     pos = end + 1;
1191   }
1192 }
1193
1194 int RGWPostObj_ObjStore::parse_part_field(const std::string& line,
1195                                           std::string& field_name,  /* out */
1196                                           post_part_field& field)   /* out */
1197 {
1198   size_t pos = line.find(':');
1199   if (pos == string::npos)
1200     return -EINVAL;
1201
1202   field_name = line.substr(0, pos);
1203   if (pos >= line.size() - 1)
1204     return 0;
1205
1206   parse_boundary_params(line.substr(pos + 1), field.val, field.params);
1207
1208   return 0;
1209 }
1210
1211 static bool is_crlf(const char *s)
1212 {
1213   return (*s == '\r' && *(s + 1) == '\n');
1214 }
1215
1216 /*
1217  * find the index of the boundary, if exists, or optionally the next end of line
1218  * also returns how many bytes to skip
1219  */
1220 static int index_of(ceph::bufferlist& bl,
1221                     uint64_t max_len,
1222                     const std::string& str,
1223                     const bool check_crlf,
1224                     bool& reached_boundary,
1225                     int& skip)
1226 {
1227   reached_boundary = false;
1228   skip = 0;
1229
1230   if (str.size() < 2) // we assume boundary is at least 2 chars (makes it easier with crlf checks)
1231     return -EINVAL;
1232
1233   if (bl.length() < str.size())
1234     return -1;
1235
1236   const char *buf = bl.c_str();
1237   const char *s = str.c_str();
1238
1239   if (max_len > bl.length())
1240     max_len = bl.length();
1241
1242   for (uint64_t i = 0; i < max_len; i++, buf++) {
1243     if (check_crlf &&
1244         i >= 1 &&
1245         is_crlf(buf - 1)) {
1246       return i + 1; // skip the crlf
1247     }
1248     if ((i < max_len - str.size() + 1) &&
1249         (buf[0] == s[0] && buf[1] == s[1]) &&
1250         (strncmp(buf, s, str.size()) == 0)) {
1251       reached_boundary = true;
1252       skip = str.size();
1253
1254       /* oh, great, now we need to swallow the preceding crlf
1255        * if exists
1256        */
1257       if ((i >= 2) &&
1258           is_crlf(buf - 2)) {
1259         i -= 2;
1260         skip += 2;
1261       }
1262       return i;
1263     }
1264   }
1265
1266   return -1;
1267 }
1268
1269 int RGWPostObj_ObjStore::read_with_boundary(ceph::bufferlist& bl,
1270                                             uint64_t max,
1271                                             const bool check_crlf,
1272                                             bool& reached_boundary,
1273                                             bool& done)
1274 {
1275   uint64_t cl = max + 2 + boundary.size();
1276
1277   if (max > in_data.length()) {
1278     uint64_t need_to_read = cl - in_data.length();
1279
1280     bufferptr bp(need_to_read);
1281
1282     const auto read_len = recv_body(s, bp.c_str(), need_to_read);
1283     if (read_len < 0) {
1284       return read_len;
1285     }
1286     in_data.append(bp, 0, read_len);
1287   }
1288
1289   done = false;
1290   int skip;
1291   const int index = index_of(in_data, cl, boundary, check_crlf,
1292                              reached_boundary, skip);
1293   if (index >= 0) {
1294     max = index;
1295   }
1296
1297   if (max > in_data.length()) {
1298     max = in_data.length();
1299   }
1300
1301   bl.substr_of(in_data, 0, max);
1302
1303   ceph::bufferlist new_read_data;
1304
1305   /*
1306    * now we need to skip boundary for next time, also skip any crlf, or
1307    * check to see if it's the last final boundary (marked with "--" at the end
1308    */
1309   if (reached_boundary) {
1310     int left = in_data.length() - max;
1311     if (left < skip + 2) {
1312       int need = skip + 2 - left;
1313       bufferptr boundary_bp(need);
1314       const int r = recv_body(s, boundary_bp.c_str(), need);
1315       if (r < 0) {
1316         return r;
1317       }
1318       in_data.append(boundary_bp);
1319     }
1320     max += skip; // skip boundary for next time
1321     if (in_data.length() >= max + 2) {
1322       const char *data = in_data.c_str();
1323       if (is_crlf(data + max)) {
1324         max += 2;
1325       } else {
1326         if (*(data + max) == '-' &&
1327             *(data + max + 1) == '-') {
1328           done = true;
1329           max += 2;
1330         }
1331       }
1332     }
1333   }
1334
1335   new_read_data.substr_of(in_data, max, in_data.length() - max);
1336   in_data = new_read_data;
1337
1338   return 0;
1339 }
1340
1341 int RGWPostObj_ObjStore::read_line(ceph::bufferlist& bl,
1342                                    const uint64_t max,
1343                                    bool& reached_boundary,
1344                                    bool& done)
1345 {
1346   return read_with_boundary(bl, max, true, reached_boundary, done);
1347 }
1348
1349 int RGWPostObj_ObjStore::read_data(ceph::bufferlist& bl,
1350                                    const uint64_t max,
1351                                    bool& reached_boundary,
1352                                    bool& done)
1353 {
1354   return read_with_boundary(bl, max, false, reached_boundary, done);
1355 }
1356
1357
1358 int RGWPostObj_ObjStore::read_form_part_header(struct post_form_part* const part,
1359                                                bool& done)
1360 {
1361   bufferlist bl;
1362   bool reached_boundary;
1363   uint64_t chunk_size = s->cct->_conf->rgw_max_chunk_size;
1364   int r = read_line(bl, chunk_size, reached_boundary, done);
1365   if (r < 0) {
1366     return r;
1367   }
1368
1369   if (done) {
1370     return 0;
1371   }
1372
1373   if (reached_boundary) { // skip the first boundary
1374     r = read_line(bl, chunk_size, reached_boundary, done);
1375     if (r < 0) {
1376       return r;
1377     } else if (done) {
1378       return 0;
1379     }
1380   }
1381
1382   while (true) {
1383   /*
1384    * iterate through fields
1385    */
1386     std::string line = rgw_trim_whitespace(string(bl.c_str(), bl.length()));
1387
1388     if (line.empty()) {
1389       break;
1390     }
1391
1392     struct post_part_field field;
1393
1394     string field_name;
1395     r = parse_part_field(line, field_name, field);
1396     if (r < 0) {
1397       return r;
1398     }
1399
1400     part->fields[field_name] = field;
1401
1402     if (stringcasecmp(field_name, "Content-Disposition") == 0) {
1403       part->name = field.params["name"];
1404     }
1405
1406     if (reached_boundary) {
1407       break;
1408     }
1409
1410     r = read_line(bl, chunk_size, reached_boundary, done);
1411   }
1412
1413   return 0;
1414 }
1415
1416 bool RGWPostObj_ObjStore::part_str(parts_collection_t& parts,
1417                                    const std::string& name,
1418                                    std::string* val)
1419 {
1420   const auto iter = parts.find(name);
1421   if (std::end(parts) == iter) {
1422     return false;
1423   }
1424
1425   ceph::bufferlist& data = iter->second.data;
1426   std::string str = string(data.c_str(), data.length());
1427   *val = rgw_trim_whitespace(str);
1428   return true;
1429 }
1430
1431 std::string RGWPostObj_ObjStore::get_part_str(parts_collection_t& parts,
1432                                               const std::string& name,
1433                                               const std::string& def_val)
1434 {
1435   std::string val;
1436
1437   if (part_str(parts, name, &val)) {
1438     return val;
1439   } else {
1440     return rgw_trim_whitespace(def_val);
1441   }
1442 }
1443
1444 bool RGWPostObj_ObjStore::part_bl(parts_collection_t& parts,
1445                                   const std::string& name,
1446                                   ceph::bufferlist* pbl)
1447 {
1448   const auto iter = parts.find(name);
1449   if (std::end(parts) == iter) {
1450     return false;
1451   }
1452
1453   *pbl = iter->second.data;
1454   return true;
1455 }
1456
1457 int RGWPostObj_ObjStore::verify_params()
1458 {
1459   /*  check that we have enough memory to store the object
1460   note that this test isn't exact and may fail unintentionally
1461   for large requests is */
1462   if (!s->length) {
1463     return -ERR_LENGTH_REQUIRED;
1464   }
1465   off_t len = atoll(s->length);
1466   if (len > (off_t)(s->cct->_conf->rgw_max_put_size)) {
1467     return -ERR_TOO_LARGE;
1468   }
1469
1470   supplied_md5_b64 = s->info.env->get("HTTP_CONTENT_MD5");
1471
1472   return 0;
1473 }
1474
1475 int RGWPostObj_ObjStore::get_params()
1476 {
1477   if (s->expect_cont) {
1478     /* OK, here it really gets ugly. With POST, the params are embedded in the
1479      * request body, so we need to continue before being able to actually look
1480      * at them. This diverts from the usual request flow. */
1481     dump_continue(s);
1482     s->expect_cont = false;
1483   }
1484
1485   std::string req_content_type_str = s->info.env->get("CONTENT_TYPE", "");
1486   std::string req_content_type;
1487   std::map<std::string, std::string> params;
1488   parse_boundary_params(req_content_type_str, req_content_type, params);
1489
1490   if (req_content_type.compare("multipart/form-data") != 0) {
1491     err_msg = "Request Content-Type is not multipart/form-data";
1492     return -EINVAL;
1493   }
1494
1495   if (s->cct->_conf->subsys.should_gather(ceph_subsys_rgw, 20)) {
1496     ldout(s->cct, 20) << "request content_type_str="
1497                       << req_content_type_str << dendl;
1498     ldout(s->cct, 20) << "request content_type params:" << dendl;
1499
1500     for (const auto& pair : params) {
1501       ldout(s->cct, 20) << " " << pair.first << " -> " << pair.second
1502                         << dendl;
1503     }
1504   }
1505
1506   const auto iter = params.find("boundary");
1507   if (std::end(params) == iter) {
1508     err_msg = "Missing multipart boundary specification";
1509     return -EINVAL;
1510   }
1511
1512   /* Create the boundary. */
1513   boundary = "--";
1514   boundary.append(iter->second);
1515
1516   return 0;
1517 }
1518
1519
1520 int RGWPutACLs_ObjStore::get_params()
1521 {
1522   const auto max_size = s->cct->_conf->rgw_max_put_param_size;
1523   op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
1524   return op_ret;
1525 }
1526
1527 int RGWPutLC_ObjStore::get_params()
1528 {
1529   const auto max_size = s->cct->_conf->rgw_max_put_param_size;
1530   op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
1531   return op_ret;
1532 }
1533
1534 static int read_all_chunked_input(req_state *s, char **pdata, int *plen, const uint64_t max_read)
1535 {
1536 #define READ_CHUNK 4096
1537 #define MAX_READ_CHUNK (128 * 1024)
1538   int need_to_read = READ_CHUNK;
1539   int total = need_to_read;
1540   char *data = (char *)malloc(total + 1);
1541   if (!data)
1542     return -ENOMEM;
1543
1544   int read_len = 0, len = 0;
1545   do {
1546     read_len = recv_body(s, data + len, need_to_read);
1547     if (read_len < 0) {
1548       free(data);
1549       return read_len;
1550     }
1551
1552     len += read_len;
1553
1554     if (read_len == need_to_read) {
1555       if (need_to_read < MAX_READ_CHUNK)
1556         need_to_read *= 2;
1557
1558       if ((unsigned)total > max_read) {
1559         free(data);
1560         return -ERANGE;
1561       }
1562       total += need_to_read;
1563
1564       void *p = realloc(data, total + 1);
1565       if (!p) {
1566         free(data);
1567         return -ENOMEM;
1568       }
1569       data = (char *)p;
1570     } else {
1571       break;
1572     }
1573
1574   } while (true);
1575   data[len] = '\0';
1576
1577   *pdata = data;
1578   *plen = len;
1579
1580   return 0;
1581 }
1582
1583 int rgw_rest_read_all_input(struct req_state *s, char **pdata, int *plen,
1584                             const uint64_t max_len, const bool allow_chunked)
1585 {
1586   size_t cl = 0;
1587   int len = 0;
1588   char *data = NULL;
1589
1590   if (s->length)
1591     cl = atoll(s->length);
1592   else if (!allow_chunked)
1593     return -ERR_LENGTH_REQUIRED;
1594
1595   if (cl) {
1596     if (cl > (size_t)max_len) {
1597       return -ERANGE;
1598     }
1599     data = (char *)malloc(cl + 1);
1600     if (!data) {
1601       return -ENOMEM;
1602     }
1603     len = recv_body(s, data, cl);
1604     if (len < 0) {
1605       free(data);
1606       return len;
1607     }
1608     data[len] = '\0';
1609   } else if (allow_chunked && !s->length) {
1610     const char *encoding = s->info.env->get("HTTP_TRANSFER_ENCODING");
1611     if (!encoding || strcmp(encoding, "chunked") != 0)
1612       return -ERR_LENGTH_REQUIRED;
1613
1614     int ret = read_all_chunked_input(s, &data, &len, max_len);
1615     if (ret < 0)
1616       return ret;
1617   }
1618
1619   *plen = len;
1620   *pdata = data;
1621
1622   return 0;
1623 }
1624
1625 int RGWCompleteMultipart_ObjStore::get_params()
1626 {
1627   upload_id = s->info.args.get("uploadId");
1628
1629   if (upload_id.empty()) {
1630     op_ret = -ENOTSUP;
1631     return op_ret;
1632   }
1633
1634 #define COMPLETE_MULTIPART_MAX_LEN (1024 * 1024) /* api defines max 10,000 parts, this should be enough */
1635   op_ret = rgw_rest_read_all_input(s, &data, &len, COMPLETE_MULTIPART_MAX_LEN);
1636   if (op_ret < 0)
1637     return op_ret;
1638
1639   return 0;
1640 }
1641
1642 int RGWListMultipart_ObjStore::get_params()
1643 {
1644   upload_id = s->info.args.get("uploadId");
1645
1646   if (upload_id.empty()) {
1647     op_ret = -ENOTSUP;
1648   }
1649   string marker_str = s->info.args.get("part-number-marker");
1650
1651   if (!marker_str.empty()) {
1652     string err;
1653     marker = strict_strtol(marker_str.c_str(), 10, &err);
1654     if (!err.empty()) {
1655       ldout(s->cct, 20) << "bad marker: "  << marker << dendl;
1656       op_ret = -EINVAL;
1657       return op_ret;
1658     }
1659   }
1660
1661   string str = s->info.args.get("max-parts");
1662   if (!str.empty())
1663     max_parts = atoi(str.c_str());
1664
1665   return op_ret;
1666 }
1667
1668 int RGWListBucketMultiparts_ObjStore::get_params()
1669 {
1670   delimiter = s->info.args.get("delimiter");
1671   prefix = s->info.args.get("prefix");
1672   string str = s->info.args.get("max-uploads");
1673   if (!str.empty())
1674     max_uploads = atoi(str.c_str());
1675   else
1676     max_uploads = default_max;
1677
1678   string key_marker = s->info.args.get("key-marker");
1679   string upload_id_marker = s->info.args.get("upload-id-marker");
1680   if (!key_marker.empty())
1681     marker.init(key_marker, upload_id_marker);
1682
1683   return 0;
1684 }
1685
1686 int RGWDeleteMultiObj_ObjStore::get_params()
1687 {
1688
1689   if (s->bucket_name.empty()) {
1690     op_ret = -EINVAL;
1691     return op_ret;
1692   }
1693
1694   // everything is probably fine, set the bucket
1695   bucket = s->bucket;
1696
1697   const auto max_size = s->cct->_conf->rgw_max_put_param_size;
1698   op_ret = rgw_rest_read_all_input(s, &data, &len, max_size, false);
1699   return op_ret;
1700 }
1701
1702
1703 void RGWRESTOp::send_response()
1704 {
1705   if (!flusher.did_start()) {
1706     set_req_state_err(s, http_ret);
1707     dump_errno(s);
1708     end_header(s, this);
1709   }
1710   flusher.flush();
1711 }
1712
1713 int RGWRESTOp::verify_permission()
1714 {
1715   return check_caps(s->user->caps);
1716 }
1717
1718 RGWOp* RGWHandler_REST::get_op(RGWRados* store)
1719 {
1720   RGWOp *op;
1721   switch (s->op) {
1722    case OP_GET:
1723      op = op_get();
1724      break;
1725    case OP_PUT:
1726      op = op_put();
1727      break;
1728    case OP_DELETE:
1729      op = op_delete();
1730      break;
1731    case OP_HEAD:
1732      op = op_head();
1733      break;
1734    case OP_POST:
1735      op = op_post();
1736      break;
1737    case OP_COPY:
1738      op = op_copy();
1739      break;
1740    case OP_OPTIONS:
1741      op = op_options();
1742      break;
1743    default:
1744      return NULL;
1745   }
1746
1747   if (op) {
1748     op->init(store, s, this);
1749   }
1750   return op;
1751 } /* get_op */
1752
1753 void RGWHandler_REST::put_op(RGWOp* op)
1754 {
1755   delete op;
1756 } /* put_op */
1757
1758 int RGWHandler_REST::allocate_formatter(struct req_state *s,
1759                                         int default_type,
1760                                         bool configurable)
1761 {
1762   s->format = default_type;
1763   if (configurable) {
1764     string format_str = s->info.args.get("format");
1765     if (format_str.compare("xml") == 0) {
1766       s->format = RGW_FORMAT_XML;
1767     } else if (format_str.compare("json") == 0) {
1768       s->format = RGW_FORMAT_JSON;
1769     } else if (format_str.compare("html") == 0) {
1770       s->format = RGW_FORMAT_HTML;
1771     } else {
1772       const char *accept = s->info.env->get("HTTP_ACCEPT");
1773       if (accept) {
1774         char format_buf[64];
1775         unsigned int i = 0;
1776         for (; i < sizeof(format_buf) - 1 && accept[i] && accept[i] != ';'; ++i) {
1777           format_buf[i] = accept[i];
1778         }
1779         format_buf[i] = 0;
1780         if ((strcmp(format_buf, "text/xml") == 0) || (strcmp(format_buf, "application/xml") == 0)) {
1781           s->format = RGW_FORMAT_XML;
1782         } else if (strcmp(format_buf, "application/json") == 0) {
1783           s->format = RGW_FORMAT_JSON;
1784         } else if (strcmp(format_buf, "text/html") == 0) {
1785           s->format = RGW_FORMAT_HTML;
1786         }
1787       }
1788     }
1789   }
1790
1791   const string& mm = s->info.args.get("multipart-manifest");
1792   const bool multipart_delete = (mm.compare("delete") == 0);
1793   const bool swift_bulkupload = s->prot_flags & RGW_REST_SWIFT &&
1794                                 s->info.args.exists("extract-archive");
1795   switch (s->format) {
1796     case RGW_FORMAT_PLAIN:
1797       {
1798         const bool use_kv_syntax = s->info.args.exists("bulk-delete") ||
1799                                    multipart_delete || swift_bulkupload;
1800         s->formatter = new RGWFormatter_Plain(use_kv_syntax);
1801         break;
1802       }
1803     case RGW_FORMAT_XML:
1804       {
1805         const bool lowercase_underscore = s->info.args.exists("bulk-delete") ||
1806                                           multipart_delete || swift_bulkupload;
1807
1808         s->formatter = new XMLFormatter(false, lowercase_underscore);
1809         break;
1810       }
1811     case RGW_FORMAT_JSON:
1812       s->formatter = new JSONFormatter(false);
1813       break;
1814     case RGW_FORMAT_HTML:
1815       s->formatter = new HTMLFormatter(s->prot_flags & RGW_REST_WEBSITE);
1816       break;
1817     default:
1818       return -EINVAL;
1819
1820   };
1821   //s->formatter->reset(); // All formatters should reset on create already
1822
1823   return 0;
1824 }
1825
1826 // This function enforces Amazon's spec for bucket names.
1827 // (The requirements, not the recommendations.)
1828 int RGWHandler_REST::validate_bucket_name(const string& bucket)
1829 {
1830   int len = bucket.size();
1831   if (len < 3) {
1832     if (len == 0) {
1833       // This request doesn't specify a bucket at all
1834       return 0;
1835     }
1836     // Name too short
1837     return -ERR_INVALID_BUCKET_NAME;
1838   }
1839   else if (len > MAX_BUCKET_NAME_LEN) {
1840     // Name too long
1841     return -ERR_INVALID_BUCKET_NAME;
1842   }
1843
1844   return 0;
1845 }
1846
1847 // "The name for a key is a sequence of Unicode characters whose UTF-8 encoding
1848 // is at most 1024 bytes long."
1849 // However, we can still have control characters and other nasties in there.
1850 // Just as long as they're utf-8 nasties.
1851 int RGWHandler_REST::validate_object_name(const string& object)
1852 {
1853   int len = object.size();
1854   if (len > MAX_OBJ_NAME_LEN) {
1855     // Name too long
1856     return -ERR_INVALID_OBJECT_NAME;
1857   }
1858
1859   if (check_utf8(object.c_str(), len)) {
1860     // Object names must be valid UTF-8.
1861     return -ERR_INVALID_OBJECT_NAME;
1862   }
1863   return 0;
1864 }
1865
1866 static http_op op_from_method(const char *method)
1867 {
1868   if (!method)
1869     return OP_UNKNOWN;
1870   if (strcmp(method, "GET") == 0)
1871     return OP_GET;
1872   if (strcmp(method, "PUT") == 0)
1873     return OP_PUT;
1874   if (strcmp(method, "DELETE") == 0)
1875     return OP_DELETE;
1876   if (strcmp(method, "HEAD") == 0)
1877     return OP_HEAD;
1878   if (strcmp(method, "POST") == 0)
1879     return OP_POST;
1880   if (strcmp(method, "COPY") == 0)
1881     return OP_COPY;
1882   if (strcmp(method, "OPTIONS") == 0)
1883     return OP_OPTIONS;
1884
1885   return OP_UNKNOWN;
1886 }
1887
1888 int RGWHandler_REST::init_permissions(RGWOp* op)
1889 {
1890   if (op->get_type() == RGW_OP_CREATE_BUCKET)
1891     return 0;
1892
1893   return do_init_permissions();
1894 }
1895
1896 int RGWHandler_REST::read_permissions(RGWOp* op_obj)
1897 {
1898   bool only_bucket = false;
1899
1900   switch (s->op) {
1901   case OP_HEAD:
1902   case OP_GET:
1903     only_bucket = false;
1904     break;
1905   case OP_PUT:
1906   case OP_POST:
1907   case OP_COPY:
1908     /* is it a 'multi-object delete' request? */
1909     if (s->info.args.exists("delete")) {
1910       only_bucket = true;
1911       break;
1912     }
1913     if (is_obj_update_op()) {
1914       only_bucket = false;
1915       break;
1916     }
1917     /* is it a 'create bucket' request? */
1918     if (op_obj->get_type() == RGW_OP_CREATE_BUCKET)
1919       return 0;
1920     only_bucket = true;
1921     break;
1922   case OP_DELETE:
1923     if (!s->info.args.exists("tagging")){
1924       only_bucket = true;
1925     }
1926     break;
1927   case OP_OPTIONS:
1928     only_bucket = true;
1929     break;
1930   default:
1931     return -EINVAL;
1932   }
1933
1934   return do_read_permissions(op_obj, only_bucket);
1935 }
1936
1937 void RGWRESTMgr::register_resource(string resource, RGWRESTMgr *mgr)
1938 {
1939   string r = "/";
1940   r.append(resource);
1941
1942   /* do we have a resource manager registered for this entry point? */
1943   map<string, RGWRESTMgr *>::iterator iter = resource_mgrs.find(r);
1944   if (iter != resource_mgrs.end()) {
1945     delete iter->second;
1946   }
1947   resource_mgrs[r] = mgr;
1948   resources_by_size.insert(pair<size_t, string>(r.size(), r));
1949
1950   /* now build default resource managers for the path (instead of nested entry points)
1951    * e.g., if the entry point is /auth/v1.0/ then we'd want to create a default
1952    * manager for /auth/
1953    */
1954
1955   size_t pos = r.find('/', 1);
1956
1957   while (pos != r.size() - 1 && pos != string::npos) {
1958     string s = r.substr(0, pos);
1959
1960     iter = resource_mgrs.find(s);
1961     if (iter == resource_mgrs.end()) { /* only register it if one does not exist */
1962       resource_mgrs[s] = new RGWRESTMgr; /* a default do-nothing manager */
1963       resources_by_size.insert(pair<size_t, string>(s.size(), s));
1964     }
1965
1966     pos = r.find('/', pos + 1);
1967   }
1968 }
1969
1970 void RGWRESTMgr::register_default_mgr(RGWRESTMgr *mgr)
1971 {
1972   delete default_mgr;
1973   default_mgr = mgr;
1974 }
1975
1976 RGWRESTMgr* RGWRESTMgr::get_resource_mgr(struct req_state* const s,
1977                                          const std::string& uri,
1978                                          std::string* const out_uri)
1979 {
1980   *out_uri = uri;
1981
1982   multimap<size_t, string>::reverse_iterator iter;
1983
1984   for (iter = resources_by_size.rbegin(); iter != resources_by_size.rend(); ++iter) {
1985     string& resource = iter->second;
1986     if (uri.compare(0, iter->first, resource) == 0 &&
1987         (uri.size() == iter->first ||
1988          uri[iter->first] == '/')) {
1989       std::string suffix = uri.substr(iter->first);
1990       return resource_mgrs[resource]->get_resource_mgr(s, suffix, out_uri);
1991     }
1992   }
1993
1994   if (default_mgr) {
1995     return default_mgr->get_resource_mgr_as_default(s, uri, out_uri);
1996   }
1997
1998   return this;
1999 }
2000
2001 void RGWREST::register_x_headers(const string& s_headers)
2002 {
2003   std::vector<std::string> hdrs = get_str_vec(s_headers);
2004   for (auto& hdr : hdrs) {
2005     boost::algorithm::to_upper(hdr); // XXX
2006     (void) x_headers.insert(hdr);
2007   }
2008 }
2009
2010 RGWRESTMgr::~RGWRESTMgr()
2011 {
2012   map<string, RGWRESTMgr *>::iterator iter;
2013   for (iter = resource_mgrs.begin(); iter != resource_mgrs.end(); ++iter) {
2014     delete iter->second;
2015   }
2016   delete default_mgr;
2017 }
2018
2019 int64_t parse_content_length(const char *content_length)
2020 {
2021   int64_t len = -1;
2022
2023   if (*content_length == '\0') {
2024     len = 0;
2025   } else {
2026     string err;
2027     len = strict_strtoll(content_length, 10, &err);
2028     if (!err.empty()) {
2029       len = -1;
2030     }
2031   }
2032
2033   return len;
2034 }
2035
2036 int RGWREST::preprocess(struct req_state *s, rgw::io::BasicClient* cio)
2037 {
2038   req_info& info = s->info;
2039
2040   /* save the request uri used to hash on the client side. request_uri may suffer
2041      modifications as part of the bucket encoding in the subdomain calling format.
2042      request_uri_aws4 will be used under aws4 auth */
2043   s->info.request_uri_aws4 = s->info.request_uri;
2044
2045   s->cio = cio;
2046
2047   // We need to know if this RGW instance is running the s3website API with a
2048   // higher priority than regular S3 API, or possibly in place of the regular
2049   // S3 API.
2050   // Map the listing of rgw_enable_apis in REVERSE order, so that items near
2051   // the front of the list have a higher number assigned (and -1 for items not in the list).
2052   list<string> apis;
2053   get_str_list(g_conf->rgw_enable_apis, apis);
2054   int api_priority_s3 = -1;
2055   int api_priority_s3website = -1;
2056   auto api_s3website_priority_rawpos = std::find(apis.begin(), apis.end(), "s3website");
2057   auto api_s3_priority_rawpos = std::find(apis.begin(), apis.end(), "s3");
2058   if (api_s3_priority_rawpos != apis.end()) {
2059     api_priority_s3 = apis.size() - std::distance(apis.begin(), api_s3_priority_rawpos);
2060   }
2061   if (api_s3website_priority_rawpos != apis.end()) {
2062     api_priority_s3website = apis.size() - std::distance(apis.begin(), api_s3website_priority_rawpos);
2063   }
2064   ldout(s->cct, 10) << "rgw api priority: s3=" << api_priority_s3 << " s3website=" << api_priority_s3website << dendl;
2065   bool s3website_enabled = api_priority_s3website >= 0;
2066
2067   if (info.host.size()) {
2068     ssize_t pos = info.host.find(':');
2069     if (pos >= 0) {
2070       info.host = info.host.substr(0, pos);
2071     }
2072     ldout(s->cct, 10) << "host=" << info.host << dendl;
2073     string domain;
2074     string subdomain;
2075     bool in_hosted_domain_s3website = false;
2076     bool in_hosted_domain = rgw_find_host_in_domains(info.host, &domain, &subdomain, hostnames_set);
2077
2078     string s3website_domain;
2079     string s3website_subdomain;
2080
2081     if (s3website_enabled) {
2082       in_hosted_domain_s3website = rgw_find_host_in_domains(info.host, &s3website_domain, &s3website_subdomain, hostnames_s3website_set);
2083       if (in_hosted_domain_s3website) {
2084         in_hosted_domain = true; // TODO: should hostnames be a strict superset of hostnames_s3website?
2085         domain = s3website_domain;
2086         subdomain = s3website_subdomain;
2087       }
2088     }
2089
2090     ldout(s->cct, 20)
2091       << "subdomain=" << subdomain
2092       << " domain=" << domain
2093       << " in_hosted_domain=" << in_hosted_domain
2094       << " in_hosted_domain_s3website=" << in_hosted_domain_s3website
2095       << dendl;
2096
2097     if (g_conf->rgw_resolve_cname
2098         && !in_hosted_domain
2099         && !in_hosted_domain_s3website) {
2100       string cname;
2101       bool found;
2102       int r = rgw_resolver->resolve_cname(info.host, cname, &found);
2103       if (r < 0) {
2104         ldout(s->cct, 0)
2105           << "WARNING: rgw_resolver->resolve_cname() returned r=" << r
2106           << dendl;
2107       }
2108
2109       if (found) {
2110         ldout(s->cct, 5) << "resolved host cname " << info.host << " -> "
2111                          << cname << dendl;
2112         in_hosted_domain =
2113           rgw_find_host_in_domains(cname, &domain, &subdomain, hostnames_set);
2114
2115         if (s3website_enabled
2116             && !in_hosted_domain_s3website) {
2117           in_hosted_domain_s3website =
2118             rgw_find_host_in_domains(cname, &s3website_domain,
2119                                      &s3website_subdomain,
2120                                      hostnames_s3website_set);
2121           if (in_hosted_domain_s3website) {
2122             in_hosted_domain = true; // TODO: should hostnames be a
2123                                      // strict superset of hostnames_s3website?
2124             domain = s3website_domain;
2125             subdomain = s3website_subdomain;
2126           }
2127         }
2128
2129         ldout(s->cct, 20)
2130           << "subdomain=" << subdomain
2131           << " domain=" << domain
2132           << " in_hosted_domain=" << in_hosted_domain
2133           << " in_hosted_domain_s3website=" << in_hosted_domain_s3website
2134           << dendl;
2135       }
2136     }
2137
2138     // Handle A/CNAME records that point to the RGW storage, but do match the
2139     // CNAME test above, per issue http://tracker.ceph.com/issues/15975
2140     // If BOTH domain & subdomain variables are empty, then none of the above
2141     // cases matched anything, and we should fall back to using the Host header
2142     // directly as the bucket name.
2143     // As additional checks:
2144     // - if the Host header is an IP, we're using path-style access without DNS
2145     // - Also check that the Host header is a valid bucket name before using it.
2146     // - Don't enable virtual hosting if no hostnames are configured
2147     if (subdomain.empty()
2148         && (domain.empty() || domain != info.host)
2149         && !looks_like_ip_address(info.host.c_str())
2150         && RGWHandler_REST::validate_bucket_name(info.host) == 0
2151         && !(hostnames_set.empty() && hostnames_s3website_set.empty())) {
2152       subdomain.append(info.host);
2153       in_hosted_domain = 1;
2154     }
2155
2156     if (s3website_enabled && api_priority_s3website > api_priority_s3) {
2157       in_hosted_domain_s3website = 1;
2158     }
2159
2160     if (in_hosted_domain_s3website) {
2161       s->prot_flags |= RGW_REST_WEBSITE;
2162     }
2163
2164
2165     if (in_hosted_domain && !subdomain.empty()) {
2166       string encoded_bucket = "/";
2167       encoded_bucket.append(subdomain);
2168       if (s->info.request_uri[0] != '/')
2169         encoded_bucket.append("/");
2170       encoded_bucket.append(s->info.request_uri);
2171       s->info.request_uri = encoded_bucket;
2172     }
2173
2174     if (!domain.empty()) {
2175       s->info.domain = domain;
2176     }
2177
2178     ldout(s->cct, 20)
2179       << "final domain/bucket"
2180       << " subdomain=" << subdomain
2181       << " domain=" << domain
2182       << " in_hosted_domain=" << in_hosted_domain
2183       << " in_hosted_domain_s3website=" << in_hosted_domain_s3website
2184       << " s->info.domain=" << s->info.domain
2185       << " s->info.request_uri=" << s->info.request_uri
2186       << dendl;
2187   }
2188
2189   if (s->info.domain.empty()) {
2190     s->info.domain = s->cct->_conf->rgw_dns_name;
2191   }
2192
2193   s->decoded_uri = url_decode(s->info.request_uri);
2194   /* Validate for being free of the '\0' buried in the middle of the string. */
2195   if (std::strlen(s->decoded_uri.c_str()) != s->decoded_uri.length()) {
2196     return -ERR_ZERO_IN_URL;
2197   }
2198
2199   /* FastCGI specification, section 6.3
2200    * http://www.fastcgi.com/devkit/doc/fcgi-spec.html#S6.3
2201    * ===
2202    * The Authorizer application receives HTTP request information from the Web
2203    * server on the FCGI_PARAMS stream, in the same format as a Responder. The
2204    * Web server does not send CONTENT_LENGTH, PATH_INFO, PATH_TRANSLATED, and
2205    * SCRIPT_NAME headers.
2206    * ===
2207    * Ergo if we are in Authorizer role, we MUST look at HTTP_CONTENT_LENGTH
2208    * instead of CONTENT_LENGTH for the Content-Length.
2209    *
2210    * There is one slight wrinkle in this, and that's older versions of
2211    * nginx/lighttpd/apache setting BOTH headers. As a result, we have to check
2212    * both headers and can't always simply pick A or B.
2213    */
2214   const char* content_length = info.env->get("CONTENT_LENGTH");
2215   const char* http_content_length = info.env->get("HTTP_CONTENT_LENGTH");
2216   if (!http_content_length != !content_length) {
2217     /* Easy case: one or the other is missing */
2218     s->length = (content_length ? content_length : http_content_length);
2219   } else if (s->cct->_conf->rgw_content_length_compat &&
2220              content_length && http_content_length) {
2221     /* Hard case: Both are set, we have to disambiguate */
2222     int64_t content_length_i, http_content_length_i;
2223
2224     content_length_i = parse_content_length(content_length);
2225     http_content_length_i = parse_content_length(http_content_length);
2226
2227     // Now check them:
2228     if (http_content_length_i < 0) {
2229       // HTTP_CONTENT_LENGTH is invalid, ignore it
2230     } else if (content_length_i < 0) {
2231       // CONTENT_LENGTH is invalid, and HTTP_CONTENT_LENGTH is valid
2232       // Swap entries
2233       content_length = http_content_length;
2234     } else {
2235       // both CONTENT_LENGTH and HTTP_CONTENT_LENGTH are valid
2236       // Let's pick the larger size
2237       if (content_length_i < http_content_length_i) {
2238         // prefer the larger value
2239         content_length = http_content_length;
2240       }
2241     }
2242     s->length = content_length;
2243     // End of: else if (s->cct->_conf->rgw_content_length_compat &&
2244     //   content_length &&
2245     // http_content_length)
2246   } else {
2247     /* no content length was defined */
2248     s->length = NULL;
2249   }
2250
2251   if (s->length) {
2252     if (*s->length == '\0') {
2253       s->content_length = 0;
2254     } else {
2255       string err;
2256       s->content_length = strict_strtoll(s->length, 10, &err);
2257       if (!err.empty()) {
2258         ldout(s->cct, 10) << "bad content length, aborting" << dendl;
2259         return -EINVAL;
2260       }
2261     }
2262   }
2263
2264   if (s->content_length < 0) {
2265     ldout(s->cct, 10) << "negative content length, aborting" << dendl;
2266     return -EINVAL;
2267   }
2268
2269   map<string, string>::iterator giter;
2270   for (giter = generic_attrs_map.begin(); giter != generic_attrs_map.end();
2271        ++giter) {
2272     const char *env = info.env->get(giter->first.c_str());
2273     if (env) {
2274       s->generic_attrs[giter->second] = env;
2275     }
2276   }
2277
2278   if (g_conf->rgw_print_continue) {
2279     const char *expect = info.env->get("HTTP_EXPECT");
2280     s->expect_cont = (expect && !strcasecmp(expect, "100-continue"));
2281   }
2282   s->op = op_from_method(info.method);
2283
2284   info.init_meta_info(&s->has_bad_meta);
2285
2286   return 0;
2287 }
2288
2289 RGWHandler_REST* RGWREST::get_handler(
2290   RGWRados * const store,
2291   struct req_state* const s,
2292   const rgw::auth::StrategyRegistry& auth_registry,
2293   const std::string& frontend_prefix,
2294   RGWRestfulIO* const rio,
2295   RGWRESTMgr** const pmgr,
2296   int* const init_error
2297 ) {
2298   *init_error = preprocess(s, rio);
2299   if (*init_error < 0) {
2300     return nullptr;
2301   }
2302
2303   RGWRESTMgr *m = mgr.get_manager(s, frontend_prefix, s->decoded_uri,
2304                                   &s->relative_uri);
2305   if (! m) {
2306     *init_error = -ERR_METHOD_NOT_ALLOWED;
2307     return nullptr;
2308   }
2309
2310   if (pmgr) {
2311     *pmgr = m;
2312   }
2313
2314   RGWHandler_REST* handler = m->get_handler(s, auth_registry, frontend_prefix);
2315   if (! handler) {
2316     *init_error = -ERR_METHOD_NOT_ALLOWED;
2317     return NULL;
2318   }
2319   *init_error = handler->init(store, s, rio);
2320   if (*init_error < 0) {
2321     m->put_handler(handler);
2322     return nullptr;
2323   }
2324
2325   return handler;
2326 } /* get stream handler */