ceph/src/rgw/rgw_rest_swift.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPH_RGW_REST_SWIFT_H
   5 #define CEPH_RGW_REST_SWIFT_H
   6 #define TIME_BUF_SIZE 128
   7
   8 #include <boost/optional.hpp>
   9 #include <boost/utility/typed_in_place_factory.hpp>
  10
  11 #include "rgw_op.h"
  12 #include "rgw_rest.h"
  13 #include "rgw_swift_auth.h"
  14 #include "rgw_http_errors.h"
  15
  16 #include <boost/utility/string_ref.hpp>
  17
  18 class RGWGetObj_ObjStore_SWIFT : public RGWGetObj_ObjStore {
  19   int custom_http_ret = 0;
  20 public:
  21   RGWGetObj_ObjStore_SWIFT() {}
  22   ~RGWGetObj_ObjStore_SWIFT() override {}
  23
  24   int verify_permission() override;
  25   int get_params() override;
  26   int send_response_data_error() override;
  27   int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
  28
  29   void set_custom_http_response(const int http_ret) {
  30     custom_http_ret = http_ret;
  31   }
  32
  33   bool need_object_expiration() override {
  34     return true;
  35   }
  36 };
  37
  38 class RGWListBuckets_ObjStore_SWIFT : public RGWListBuckets_ObjStore {
  39   bool need_stats;
  40   std::string prefix;
  41
  42   uint64_t get_default_max() const override {
  43     return 0;
  44   }
  45 public:
  46   RGWListBuckets_ObjStore_SWIFT() : need_stats(true) {}
  47   ~RGWListBuckets_ObjStore_SWIFT() override {}
  48
  49   int get_params() override;
  50   void send_response_begin(bool has_buckets) override;
  51   void send_response_data(RGWUserBuckets& buckets) override;
  52   void send_response_end() override;
  53
  54   bool should_get_stats() override { return need_stats; }
  55   bool supports_account_metadata() override { return true; }
  56 };
  57
  58 class RGWListBucket_ObjStore_SWIFT : public RGWListBucket_ObjStore {
  59   string path;
  60 public:
  61   RGWListBucket_ObjStore_SWIFT() {
  62     default_max = 10000;
  63   }
  64   ~RGWListBucket_ObjStore_SWIFT() override {}
  65
  66   int get_params() override;
  67   void send_response() override;
  68   bool need_container_stats() override { return true; }
  69 };
  70
  71 class RGWStatAccount_ObjStore_SWIFT : public RGWStatAccount_ObjStore {
  72   map<string, bufferlist> attrs;
  73 public:
  74   RGWStatAccount_ObjStore_SWIFT() {
  75   }
  76   ~RGWStatAccount_ObjStore_SWIFT() override {}
  77
  78   void execute() override;
  79   void send_response() override;
  80 };
  81
  82 class RGWStatBucket_ObjStore_SWIFT : public RGWStatBucket_ObjStore {
  83 public:
  84   RGWStatBucket_ObjStore_SWIFT() {}
  85   ~RGWStatBucket_ObjStore_SWIFT() override {}
  86
  87   void send_response() override;
  88 };
  89
  90 class RGWCreateBucket_ObjStore_SWIFT : public RGWCreateBucket_ObjStore {
  91 protected:
  92   bool need_metadata_upload() const override { return true; }
  93 public:
  94   RGWCreateBucket_ObjStore_SWIFT() {}
  95   ~RGWCreateBucket_ObjStore_SWIFT() override {}
  96
  97   int get_params() override;
  98   void send_response() override;
  99 };
 100
 101 class RGWDeleteBucket_ObjStore_SWIFT : public RGWDeleteBucket_ObjStore {
 102 public:
 103   RGWDeleteBucket_ObjStore_SWIFT() {}
 104   ~RGWDeleteBucket_ObjStore_SWIFT() override {}
 105
 106   void send_response() override;
 107 };
 108
 109 class RGWPutObj_ObjStore_SWIFT : public RGWPutObj_ObjStore {
 110   string lo_etag;
 111 public:
 112   RGWPutObj_ObjStore_SWIFT() {}
 113   ~RGWPutObj_ObjStore_SWIFT() override {}
 114
 115   int verify_permission() override;
 116   int get_params() override;
 117   void send_response() override;
 118 };
 119
 120 class RGWPutMetadataAccount_ObjStore_SWIFT : public RGWPutMetadataAccount_ObjStore {
 121 public:
 122   RGWPutMetadataAccount_ObjStore_SWIFT() {}
 123   ~RGWPutMetadataAccount_ObjStore_SWIFT() override {}
 124
 125   int get_params() override;
 126   void send_response() override;
 127 };
 128
 129 class RGWPutMetadataBucket_ObjStore_SWIFT : public RGWPutMetadataBucket_ObjStore {
 130 public:
 131   RGWPutMetadataBucket_ObjStore_SWIFT() {}
 132   ~RGWPutMetadataBucket_ObjStore_SWIFT() override {}
 133
 134   int get_params() override;
 135   void send_response() override;
 136 };
 137
 138 class RGWPutMetadataObject_ObjStore_SWIFT : public RGWPutMetadataObject_ObjStore {
 139 public:
 140   RGWPutMetadataObject_ObjStore_SWIFT() {}
 141   ~RGWPutMetadataObject_ObjStore_SWIFT() override {}
 142
 143   int get_params() override;
 144   void send_response() override;
 145   bool need_object_expiration() override { return true; }
 146 };
 147
 148 class RGWDeleteObj_ObjStore_SWIFT : public RGWDeleteObj_ObjStore {
 149 public:
 150   RGWDeleteObj_ObjStore_SWIFT() {}
 151   ~RGWDeleteObj_ObjStore_SWIFT() override {}
 152
 153   int verify_permission() override;
 154   int get_params() override;
 155   bool need_object_expiration() override { return true; }
 156   void send_response() override;
 157 };
 158
 159 class RGWCopyObj_ObjStore_SWIFT : public RGWCopyObj_ObjStore {
 160   bool sent_header;
 161 protected:
 162   void dump_copy_info();
 163 public:
 164   RGWCopyObj_ObjStore_SWIFT() : sent_header(false) {}
 165   ~RGWCopyObj_ObjStore_SWIFT() override {}
 166
 167   int init_dest_policy() override;
 168   int get_params() override;
 169   void send_response() override;
 170   void send_partial_response(off_t ofs) override;
 171 };
 172
 173 class RGWGetACLs_ObjStore_SWIFT : public RGWGetACLs_ObjStore {
 174 public:
 175   RGWGetACLs_ObjStore_SWIFT() {}
 176   ~RGWGetACLs_ObjStore_SWIFT() override {}
 177
 178   void send_response() override {}
 179 };
 180
 181 class RGWPutACLs_ObjStore_SWIFT : public RGWPutACLs_ObjStore {
 182 public:
 183   RGWPutACLs_ObjStore_SWIFT() : RGWPutACLs_ObjStore() {}
 184   ~RGWPutACLs_ObjStore_SWIFT() override {}
 185
 186   void send_response() override {}
 187 };
 188
 189 class RGWOptionsCORS_ObjStore_SWIFT : public RGWOptionsCORS_ObjStore {
 190 public:
 191   RGWOptionsCORS_ObjStore_SWIFT() {}
 192   ~RGWOptionsCORS_ObjStore_SWIFT() override {}
 193
 194   void send_response() override;
 195 };
 196
 197 class RGWBulkDelete_ObjStore_SWIFT : public RGWBulkDelete_ObjStore {
 198 public:
 199   RGWBulkDelete_ObjStore_SWIFT() {}
 200   ~RGWBulkDelete_ObjStore_SWIFT() override {}
 201
 202   int get_data(std::list<RGWBulkDelete::acct_path_t>& items,
 203                bool * is_truncated) override;
 204   void send_response() override;
 205 };
 206
 207 class RGWBulkUploadOp_ObjStore_SWIFT : public RGWBulkUploadOp_ObjStore {
 208   size_t conlen;
 209   size_t curpos;
 210
 211 public:
 212   RGWBulkUploadOp_ObjStore_SWIFT()
 213     : conlen(0),
 214       curpos(0) {
 215   }
 216   ~RGWBulkUploadOp_ObjStore_SWIFT() = default;
 217
 218   std::unique_ptr<StreamGetter> create_stream() override;
 219   void send_response() override;
 220 };
 221
 222 class RGWInfo_ObjStore_SWIFT : public RGWInfo_ObjStore {
 223 protected:
 224   struct info
 225   {
 226     bool is_admin_info;
 227     function<void (Formatter&, const md_config_t&, RGWRados&)> list_data;
 228   };
 229
 230   static const vector<pair<string, struct info>> swift_info;
 231 public:
 232   RGWInfo_ObjStore_SWIFT() {}
 233   ~RGWInfo_ObjStore_SWIFT() override {}
 234
 235   void execute() override;
 236   void send_response() override;
 237   static void list_swift_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
 238   static void list_tempauth_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
 239   static void list_tempurl_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
 240   static void list_slo_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
 241   static bool is_expired(const std::string& expires, CephContext* cct);
 242 };
 243
 244
 245 class RGWFormPost : public RGWPostObj_ObjStore {
 246   std::string get_current_filename() const override;
 247   std::string get_current_content_type() const override;
 248   std::size_t get_max_file_size() /*const*/;
 249   bool is_next_file_to_upload() override;
 250   bool is_integral();
 251   bool is_non_expired();
 252   void get_owner_info(const req_state* s,
 253                       RGWUserInfo& owner_info) const;
 254
 255   parts_collection_t ctrl_parts;
 256   boost::optional<post_form_part> current_data_part;
 257   std::string prefix;
 258   bool stream_done = false;
 259
 260   class SignatureHelper;
 261 public:
 262   RGWFormPost() = default;
 263   ~RGWFormPost() = default;
 264
 265   void init(RGWRados* store,
 266             req_state* s,
 267             RGWHandler* dialect_handler) override;
 268
 269   int get_params() override;
 270   int get_data(ceph::bufferlist& bl, bool& again) override;
 271   void send_response() override;
 272
 273   static bool is_formpost_req(req_state* const s);
 274 };
 275
 276 class RGWFormPost::SignatureHelper
 277 {
 278 private:
 279   static constexpr uint32_t output_size =
 280     CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2 + 1;
 281
 282   unsigned char dest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE]; // 20
 283   char dest_str[output_size];
 284
 285 public:
 286   SignatureHelper() = default;
 287
 288   const char* calc(const std::string& key,
 289                    const boost::string_ref& path_info,
 290                    const boost::string_ref& redirect,
 291                    const boost::string_ref& max_file_size,
 292                    const boost::string_ref& max_file_count,
 293                    const boost::string_ref& expires) {
 294     using ceph::crypto::HMACSHA1;
 295     using UCHARPTR = const unsigned char*;
 296
 297     HMACSHA1 hmac((UCHARPTR) key.data(), key.size());
 298
 299     hmac.Update((UCHARPTR) path_info.data(), path_info.size());
 300     hmac.Update((UCHARPTR) "\n", 1);
 301
 302     hmac.Update((UCHARPTR) redirect.data(), redirect.size());
 303     hmac.Update((UCHARPTR) "\n", 1);
 304
 305     hmac.Update((UCHARPTR) max_file_size.data(), max_file_size.size());
 306     hmac.Update((UCHARPTR) "\n", 1);
 307
 308     hmac.Update((UCHARPTR) max_file_count.data(), max_file_count.size());
 309     hmac.Update((UCHARPTR) "\n", 1);
 310
 311     hmac.Update((UCHARPTR) expires.data(), expires.size());
 312
 313     hmac.Final(dest);
 314
 315     buf_to_hex((UCHARPTR) dest, sizeof(dest), dest_str);
 316
 317     return dest_str;
 318   }
 319
 320   const char* get_signature() const {
 321     return dest_str;
 322   }
 323
 324   bool is_equal_to(const std::string& rhs) const {
 325     /* never allow out-of-range exception */
 326     if (rhs.size() < (output_size - 1)) {
 327       return false;
 328     }
 329     return rhs.compare(0 /* pos */,  output_size, dest_str) == 0;
 330   }
 331
 332 }; /* RGWFormPost::SignatureHelper */
 333
 334
 335 class RGWSwiftWebsiteHandler {
 336   RGWRados* const store;
 337   req_state* const s;
 338   RGWHandler_REST* const handler;
 339
 340   bool is_web_mode() const;
 341   bool can_be_website_req() const;
 342   bool is_web_dir() const;
 343   bool is_index_present(const std::string& index);
 344
 345   int serve_errordoc(int http_ret, std::string error_doc);
 346
 347   RGWOp* get_ws_redirect_op();
 348   RGWOp* get_ws_index_op();
 349   RGWOp* get_ws_listing_op();
 350 public:
 351   RGWSwiftWebsiteHandler(RGWRados* const store,
 352                          req_state* const s,
 353                          RGWHandler_REST* const handler)
 354     : store(store),
 355       s(s),
 356       handler(handler) {
 357   }
 358
 359   int error_handler(const int err_no,
 360                     std::string* const error_content);
 361   int retarget_bucket(RGWOp* op, RGWOp** new_op);
 362   int retarget_object(RGWOp* op, RGWOp** new_op);
 363 };
 364
 365
 366 class RGWHandler_REST_SWIFT : public RGWHandler_REST {
 367   friend class RGWRESTMgr_SWIFT;
 368   friend class RGWRESTMgr_SWIFT_Info;
 369 protected:
 370   const rgw::auth::Strategy& auth_strategy;
 371
 372   virtual bool is_acl_op() {
 373     return false;
 374   }
 375
 376   static int init_from_header(struct req_state* s,
 377                               const std::string& frontend_prefix);
 378 public:
 379   RGWHandler_REST_SWIFT(const rgw::auth::Strategy& auth_strategy)
 380     : auth_strategy(auth_strategy) {
 381   }
 382   ~RGWHandler_REST_SWIFT() override = default;
 383
 384   static int validate_bucket_name(const string& bucket);
 385
 386   int init(RGWRados *store, struct req_state *s, rgw::io::BasicClient *cio) override;
 387   int authorize() override;
 388   int postauth_init() override;
 389
 390   RGWAccessControlPolicy *alloc_policy() { return nullptr; /* return new RGWAccessControlPolicy_SWIFT; */ }
 391   void free_policy(RGWAccessControlPolicy *policy) { delete policy; }
 392 };
 393
 394 class RGWHandler_REST_Service_SWIFT : public RGWHandler_REST_SWIFT {
 395 protected:
 396   RGWOp *op_get() override;
 397   RGWOp *op_head() override;
 398   RGWOp *op_put() override;
 399   RGWOp *op_post() override;
 400   RGWOp *op_delete() override;
 401 public:
 402   using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
 403   ~RGWHandler_REST_Service_SWIFT() override = default;
 404 };
 405
 406 class RGWHandler_REST_Bucket_SWIFT : public RGWHandler_REST_SWIFT {
 407   /* We need the boost::optional here only because of handler's late
 408    * initialization (see the init() method). */
 409   boost::optional<RGWSwiftWebsiteHandler> website_handler;
 410 protected:
 411   bool is_obj_update_op() override {
 412     return s->op == OP_POST;
 413   }
 414
 415   RGWOp *get_obj_op(bool get_data);
 416   RGWOp *op_get() override;
 417   RGWOp *op_head() override;
 418   RGWOp *op_put() override;
 419   RGWOp *op_delete() override;
 420   RGWOp *op_post() override;
 421   RGWOp *op_options() override;
 422 public:
 423   using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
 424   ~RGWHandler_REST_Bucket_SWIFT() override = default;
 425
 426   int error_handler(int err_no, std::string *error_content) override {
 427     return website_handler->error_handler(err_no, error_content);
 428   }
 429
 430   int retarget(RGWOp* op, RGWOp** new_op) override {
 431     return website_handler->retarget_bucket(op, new_op);
 432   }
 433
 434   int init(RGWRados* const store,
 435            struct req_state* const s,
 436            rgw::io::BasicClient* const cio) override {
 437     website_handler = boost::in_place<RGWSwiftWebsiteHandler>(store, s, this);
 438     return RGWHandler_REST_SWIFT::init(store, s, cio);
 439   }
 440 };
 441
 442 class RGWHandler_REST_Obj_SWIFT : public RGWHandler_REST_SWIFT {
 443   /* We need the boost::optional here only because of handler's late
 444    * initialization (see the init() method). */
 445   boost::optional<RGWSwiftWebsiteHandler> website_handler;
 446 protected:
 447   bool is_obj_update_op() override {
 448     return s->op == OP_POST;
 449   }
 450
 451   RGWOp *get_obj_op(bool get_data);
 452   RGWOp *op_get() override;
 453   RGWOp *op_head() override;
 454   RGWOp *op_put() override;
 455   RGWOp *op_delete() override;
 456   RGWOp *op_post() override;
 457   RGWOp *op_copy() override;
 458   RGWOp *op_options() override;
 459
 460 public:
 461   using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
 462   ~RGWHandler_REST_Obj_SWIFT() override = default;
 463
 464   int error_handler(int err_no, std::string *error_content) override {
 465     return website_handler->error_handler(err_no, error_content);
 466   }
 467
 468   int retarget(RGWOp* op, RGWOp** new_op) override {
 469     return website_handler->retarget_object(op, new_op);
 470   }
 471
 472   int init(RGWRados* const store,
 473            struct req_state* const s,
 474            rgw::io::BasicClient* const cio) override {
 475     website_handler = boost::in_place<RGWSwiftWebsiteHandler>(store, s, this);
 476     return RGWHandler_REST_SWIFT::init(store, s, cio);
 477   }
 478 };
 479
 480 class RGWRESTMgr_SWIFT : public RGWRESTMgr {
 481 protected:
 482   RGWRESTMgr* get_resource_mgr_as_default(struct req_state* const s,
 483                                           const std::string& uri,
 484                                           std::string* const out_uri) override {
 485     return this->get_resource_mgr(s, uri, out_uri);
 486   }
 487
 488 public:
 489   RGWRESTMgr_SWIFT() = default;
 490   ~RGWRESTMgr_SWIFT() override = default;
 491
 492   RGWHandler_REST *get_handler(struct req_state *s,
 493                                const rgw::auth::StrategyRegistry& auth_registry,
 494                                const std::string& frontend_prefix) override;
 495 };
 496
 497
 498 class  RGWGetCrossDomainPolicy_ObjStore_SWIFT
 499   : public RGWGetCrossDomainPolicy_ObjStore {
 500 public:
 501   RGWGetCrossDomainPolicy_ObjStore_SWIFT() = default;
 502   ~RGWGetCrossDomainPolicy_ObjStore_SWIFT() override = default;
 503
 504   void send_response() override;
 505 };
 506
 507 class  RGWGetHealthCheck_ObjStore_SWIFT
 508   : public RGWGetHealthCheck_ObjStore {
 509 public:
 510   RGWGetHealthCheck_ObjStore_SWIFT() = default;
 511   ~RGWGetHealthCheck_ObjStore_SWIFT() override = default;
 512
 513   void send_response() override;
 514 };
 515
 516 class RGWHandler_SWIFT_CrossDomain : public RGWHandler_REST {
 517 public:
 518   RGWHandler_SWIFT_CrossDomain() = default;
 519   ~RGWHandler_SWIFT_CrossDomain() override = default;
 520
 521   RGWOp *op_get() override {
 522     return new RGWGetCrossDomainPolicy_ObjStore_SWIFT();
 523   }
 524
 525   int init(RGWRados* const store,
 526            struct req_state* const state,
 527            rgw::io::BasicClient* const cio) override {
 528     state->dialect = "swift";
 529     state->formatter = new JSONFormatter;
 530     state->format = RGW_FORMAT_JSON;
 531
 532     return RGWHandler::init(store, state, cio);
 533   }
 534
 535   int authorize() override {
 536     return 0;
 537   }
 538
 539   int postauth_init() override {
 540     return 0;
 541   }
 542
 543   int read_permissions(RGWOp *) override {
 544     return 0;
 545   }
 546
 547   virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
 548   virtual void free_policy(RGWAccessControlPolicy *policy) {}
 549 };
 550
 551 class RGWRESTMgr_SWIFT_CrossDomain : public RGWRESTMgr {
 552 protected:
 553   RGWRESTMgr *get_resource_mgr(struct req_state* const s,
 554                                const std::string& uri,
 555                                std::string* const out_uri) override {
 556     return this;
 557   }
 558
 559 public:
 560   RGWRESTMgr_SWIFT_CrossDomain() = default;
 561   ~RGWRESTMgr_SWIFT_CrossDomain() override = default;
 562
 563   RGWHandler_REST* get_handler(struct req_state* const s,
 564                                const rgw::auth::StrategyRegistry&,
 565                                const std::string&) override {
 566     s->prot_flags |= RGW_REST_SWIFT;
 567     return new RGWHandler_SWIFT_CrossDomain;
 568   }
 569 };
 570
 571
 572 class RGWHandler_SWIFT_HealthCheck : public RGWHandler_REST {
 573 public:
 574   RGWHandler_SWIFT_HealthCheck() = default;
 575   ~RGWHandler_SWIFT_HealthCheck() override = default;
 576
 577   RGWOp *op_get() override {
 578     return new RGWGetHealthCheck_ObjStore_SWIFT();
 579   }
 580
 581   int init(RGWRados* const store,
 582            struct req_state* const state,
 583            rgw::io::BasicClient* const cio) override {
 584     state->dialect = "swift";
 585     state->formatter = new JSONFormatter;
 586     state->format = RGW_FORMAT_JSON;
 587
 588     return RGWHandler::init(store, state, cio);
 589   }
 590
 591   int authorize() override {
 592     return 0;
 593   }
 594
 595   int postauth_init() override {
 596     return 0;
 597   }
 598
 599   int read_permissions(RGWOp *) override {
 600     return 0;
 601   }
 602
 603   virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
 604   virtual void free_policy(RGWAccessControlPolicy *policy) {}
 605 };
 606
 607 class RGWRESTMgr_SWIFT_HealthCheck : public RGWRESTMgr {
 608 protected:
 609   RGWRESTMgr *get_resource_mgr(struct req_state* const s,
 610                                const std::string& uri,
 611                                std::string* const out_uri) override {
 612     return this;
 613   }
 614
 615 public:
 616   RGWRESTMgr_SWIFT_HealthCheck() = default;
 617   ~RGWRESTMgr_SWIFT_HealthCheck() override = default;
 618
 619   RGWHandler_REST* get_handler(struct req_state* const s,
 620                                const rgw::auth::StrategyRegistry&,
 621                                const std::string&) override {
 622     s->prot_flags |= RGW_REST_SWIFT;
 623     return new RGWHandler_SWIFT_HealthCheck;
 624   }
 625 };
 626
 627
 628 class RGWHandler_REST_SWIFT_Info : public RGWHandler_REST_SWIFT {
 629 public:
 630   using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
 631   ~RGWHandler_REST_SWIFT_Info() override = default;
 632
 633   RGWOp *op_get() override {
 634     return new RGWInfo_ObjStore_SWIFT();
 635   }
 636
 637   int init(RGWRados* const store,
 638            struct req_state* const state,
 639            rgw::io::BasicClient* const cio) override {
 640     state->dialect = "swift";
 641     state->formatter = new JSONFormatter;
 642     state->format = RGW_FORMAT_JSON;
 643
 644     return RGWHandler::init(store, state, cio);
 645   }
 646
 647   int authorize() override {
 648     return 0;
 649   }
 650
 651   int postauth_init() override {
 652     return 0;
 653   }
 654
 655   int read_permissions(RGWOp *) override {
 656     return 0;
 657   }
 658 };
 659
 660 class RGWRESTMgr_SWIFT_Info : public RGWRESTMgr {
 661 public:
 662   RGWRESTMgr_SWIFT_Info() = default;
 663   ~RGWRESTMgr_SWIFT_Info() override = default;
 664
 665   RGWHandler_REST *get_handler(struct req_state* s,
 666                                const rgw::auth::StrategyRegistry& auth_registry,
 667                                const std::string& frontend_prefix) override;
 668 };
 669
 670 #endif