1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 #ifndef CEPH_RGW_REST_SWIFT_H
5 #define CEPH_RGW_REST_SWIFT_H
6 #define TIME_BUF_SIZE 128
8 #include <boost/optional.hpp>
9 #include <boost/utility/typed_in_place_factory.hpp>
13 #include "rgw_swift_auth.h"
14 #include "rgw_http_errors.h"
16 #include <boost/utility/string_ref.hpp>
18 class RGWGetObj_ObjStore_SWIFT : public RGWGetObj_ObjStore {
19 int custom_http_ret = 0;
21 RGWGetObj_ObjStore_SWIFT() {}
22 ~RGWGetObj_ObjStore_SWIFT() override {}
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;
29 void set_custom_http_response(const int http_ret) {
30 custom_http_ret = http_ret;
33 bool need_object_expiration() override {
38 class RGWListBuckets_ObjStore_SWIFT : public RGWListBuckets_ObjStore {
42 std::vector<RGWUserBuckets> reverse_buffer;
44 uint64_t get_default_max() const override {
49 RGWListBuckets_ObjStore_SWIFT()
51 wants_reversed(false) {
53 ~RGWListBuckets_ObjStore_SWIFT() override {}
55 int get_params() override;
56 void handle_listing_chunk(RGWUserBuckets&& buckets) override;
57 void send_response_begin(bool has_buckets) override;
58 void send_response_data(RGWUserBuckets& buckets) override;
59 void send_response_data_reversed(RGWUserBuckets& buckets);
60 void dump_bucket_entry(const RGWBucketEnt& obj);
61 void send_response_end() override;
63 bool should_get_stats() override { return need_stats; }
64 bool supports_account_metadata() override { return true; }
67 class RGWListBucket_ObjStore_SWIFT : public RGWListBucket_ObjStore {
70 RGWListBucket_ObjStore_SWIFT() {
73 ~RGWListBucket_ObjStore_SWIFT() override {}
75 int get_params() override;
76 void send_response() override;
77 bool need_container_stats() override { return true; }
80 class RGWStatAccount_ObjStore_SWIFT : public RGWStatAccount_ObjStore {
81 map<string, bufferlist> attrs;
83 RGWStatAccount_ObjStore_SWIFT() {
85 ~RGWStatAccount_ObjStore_SWIFT() override {}
87 void execute() override;
88 void send_response() override;
91 class RGWStatBucket_ObjStore_SWIFT : public RGWStatBucket_ObjStore {
93 RGWStatBucket_ObjStore_SWIFT() {}
94 ~RGWStatBucket_ObjStore_SWIFT() override {}
96 void send_response() override;
99 class RGWCreateBucket_ObjStore_SWIFT : public RGWCreateBucket_ObjStore {
101 bool need_metadata_upload() const override { return true; }
103 RGWCreateBucket_ObjStore_SWIFT() {}
104 ~RGWCreateBucket_ObjStore_SWIFT() override {}
106 int get_params() override;
107 void send_response() override;
110 class RGWDeleteBucket_ObjStore_SWIFT : public RGWDeleteBucket_ObjStore {
112 RGWDeleteBucket_ObjStore_SWIFT() {}
113 ~RGWDeleteBucket_ObjStore_SWIFT() override {}
115 void send_response() override;
118 class RGWPutObj_ObjStore_SWIFT : public RGWPutObj_ObjStore {
121 RGWPutObj_ObjStore_SWIFT() {}
122 ~RGWPutObj_ObjStore_SWIFT() override {}
124 int verify_permission() override;
125 int get_params() override;
126 void send_response() override;
129 class RGWPutMetadataAccount_ObjStore_SWIFT : public RGWPutMetadataAccount_ObjStore {
131 RGWPutMetadataAccount_ObjStore_SWIFT() {}
132 ~RGWPutMetadataAccount_ObjStore_SWIFT() override {}
134 int get_params() override;
135 void send_response() override;
138 class RGWPutMetadataBucket_ObjStore_SWIFT : public RGWPutMetadataBucket_ObjStore {
140 RGWPutMetadataBucket_ObjStore_SWIFT() {}
141 ~RGWPutMetadataBucket_ObjStore_SWIFT() override {}
143 int get_params() override;
144 void send_response() override;
147 class RGWPutMetadataObject_ObjStore_SWIFT : public RGWPutMetadataObject_ObjStore {
149 RGWPutMetadataObject_ObjStore_SWIFT() {}
150 ~RGWPutMetadataObject_ObjStore_SWIFT() override {}
152 int get_params() override;
153 void send_response() override;
154 bool need_object_expiration() override { return true; }
157 class RGWDeleteObj_ObjStore_SWIFT : public RGWDeleteObj_ObjStore {
159 RGWDeleteObj_ObjStore_SWIFT() {}
160 ~RGWDeleteObj_ObjStore_SWIFT() override {}
162 int verify_permission() override;
163 int get_params() override;
164 bool need_object_expiration() override { return true; }
165 void send_response() override;
168 class RGWCopyObj_ObjStore_SWIFT : public RGWCopyObj_ObjStore {
171 void dump_copy_info();
173 RGWCopyObj_ObjStore_SWIFT() : sent_header(false) {}
174 ~RGWCopyObj_ObjStore_SWIFT() override {}
176 int init_dest_policy() override;
177 int get_params() override;
178 void send_response() override;
179 void send_partial_response(off_t ofs) override;
182 class RGWGetACLs_ObjStore_SWIFT : public RGWGetACLs_ObjStore {
184 RGWGetACLs_ObjStore_SWIFT() {}
185 ~RGWGetACLs_ObjStore_SWIFT() override {}
187 void send_response() override {}
190 class RGWPutACLs_ObjStore_SWIFT : public RGWPutACLs_ObjStore {
192 RGWPutACLs_ObjStore_SWIFT() : RGWPutACLs_ObjStore() {}
193 ~RGWPutACLs_ObjStore_SWIFT() override {}
195 void send_response() override {}
198 class RGWOptionsCORS_ObjStore_SWIFT : public RGWOptionsCORS_ObjStore {
200 RGWOptionsCORS_ObjStore_SWIFT() {}
201 ~RGWOptionsCORS_ObjStore_SWIFT() override {}
203 void send_response() override;
206 class RGWBulkDelete_ObjStore_SWIFT : public RGWBulkDelete_ObjStore {
208 RGWBulkDelete_ObjStore_SWIFT() {}
209 ~RGWBulkDelete_ObjStore_SWIFT() override {}
211 int get_data(std::list<RGWBulkDelete::acct_path_t>& items,
212 bool * is_truncated) override;
213 void send_response() override;
216 class RGWBulkUploadOp_ObjStore_SWIFT : public RGWBulkUploadOp_ObjStore {
221 RGWBulkUploadOp_ObjStore_SWIFT()
225 ~RGWBulkUploadOp_ObjStore_SWIFT() = default;
227 std::unique_ptr<StreamGetter> create_stream() override;
228 void send_response() override;
231 class RGWInfo_ObjStore_SWIFT : public RGWInfo_ObjStore {
236 function<void (Formatter&, const md_config_t&, RGWRados&)> list_data;
239 static const vector<pair<string, struct info>> swift_info;
241 RGWInfo_ObjStore_SWIFT() {}
242 ~RGWInfo_ObjStore_SWIFT() override {}
244 void execute() override;
245 void send_response() override;
246 static void list_swift_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
247 static void list_tempauth_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
248 static void list_tempurl_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
249 static void list_slo_data(Formatter& formatter, const md_config_t& config, RGWRados& store);
250 static bool is_expired(const std::string& expires, CephContext* cct);
254 class RGWFormPost : public RGWPostObj_ObjStore {
255 std::string get_current_filename() const override;
256 std::string get_current_content_type() const override;
257 std::size_t get_max_file_size() /*const*/;
258 bool is_next_file_to_upload() override;
260 bool is_non_expired();
261 void get_owner_info(const req_state* s,
262 RGWUserInfo& owner_info) const;
264 parts_collection_t ctrl_parts;
265 boost::optional<post_form_part> current_data_part;
267 bool stream_done = false;
269 class SignatureHelper;
271 RGWFormPost() = default;
272 ~RGWFormPost() = default;
274 void init(RGWRados* store,
276 RGWHandler* dialect_handler) override;
278 int get_params() override;
279 int get_data(ceph::bufferlist& bl, bool& again) override;
280 void send_response() override;
282 static bool is_formpost_req(req_state* const s);
285 class RGWFormPost::SignatureHelper
288 static constexpr uint32_t output_size =
289 CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2 + 1;
291 unsigned char dest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE]; // 20
292 char dest_str[output_size];
295 SignatureHelper() = default;
297 const char* calc(const std::string& key,
298 const boost::string_ref& path_info,
299 const boost::string_ref& redirect,
300 const boost::string_ref& max_file_size,
301 const boost::string_ref& max_file_count,
302 const boost::string_ref& expires) {
303 using ceph::crypto::HMACSHA1;
304 using UCHARPTR = const unsigned char*;
306 HMACSHA1 hmac((UCHARPTR) key.data(), key.size());
308 hmac.Update((UCHARPTR) path_info.data(), path_info.size());
309 hmac.Update((UCHARPTR) "\n", 1);
311 hmac.Update((UCHARPTR) redirect.data(), redirect.size());
312 hmac.Update((UCHARPTR) "\n", 1);
314 hmac.Update((UCHARPTR) max_file_size.data(), max_file_size.size());
315 hmac.Update((UCHARPTR) "\n", 1);
317 hmac.Update((UCHARPTR) max_file_count.data(), max_file_count.size());
318 hmac.Update((UCHARPTR) "\n", 1);
320 hmac.Update((UCHARPTR) expires.data(), expires.size());
324 buf_to_hex((UCHARPTR) dest, sizeof(dest), dest_str);
329 const char* get_signature() const {
333 bool is_equal_to(const std::string& rhs) const {
334 /* never allow out-of-range exception */
335 if (rhs.size() < (output_size - 1)) {
338 return rhs.compare(0 /* pos */, output_size, dest_str) == 0;
341 }; /* RGWFormPost::SignatureHelper */
344 class RGWSwiftWebsiteHandler {
345 RGWRados* const store;
347 RGWHandler_REST* const handler;
349 bool is_web_mode() const;
350 bool can_be_website_req() const;
351 bool is_web_dir() const;
352 bool is_index_present(const std::string& index);
354 int serve_errordoc(int http_ret, std::string error_doc);
356 RGWOp* get_ws_redirect_op();
357 RGWOp* get_ws_index_op();
358 RGWOp* get_ws_listing_op();
360 RGWSwiftWebsiteHandler(RGWRados* const store,
362 RGWHandler_REST* const handler)
368 int error_handler(const int err_no,
369 std::string* const error_content);
370 int retarget_bucket(RGWOp* op, RGWOp** new_op);
371 int retarget_object(RGWOp* op, RGWOp** new_op);
375 class RGWHandler_REST_SWIFT : public RGWHandler_REST {
376 friend class RGWRESTMgr_SWIFT;
377 friend class RGWRESTMgr_SWIFT_Info;
379 const rgw::auth::Strategy& auth_strategy;
381 virtual bool is_acl_op() {
385 static int init_from_header(struct req_state* s,
386 const std::string& frontend_prefix);
388 RGWHandler_REST_SWIFT(const rgw::auth::Strategy& auth_strategy)
389 : auth_strategy(auth_strategy) {
391 ~RGWHandler_REST_SWIFT() override = default;
393 int validate_bucket_name(const string& bucket);
395 int init(RGWRados *store, struct req_state *s, rgw::io::BasicClient *cio) override;
396 int authorize() override;
397 int postauth_init() override;
399 RGWAccessControlPolicy *alloc_policy() { return nullptr; /* return new RGWAccessControlPolicy_SWIFT; */ }
400 void free_policy(RGWAccessControlPolicy *policy) { delete policy; }
403 class RGWHandler_REST_Service_SWIFT : public RGWHandler_REST_SWIFT {
405 RGWOp *op_get() override;
406 RGWOp *op_head() override;
407 RGWOp *op_put() override;
408 RGWOp *op_post() override;
409 RGWOp *op_delete() override;
411 using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
412 ~RGWHandler_REST_Service_SWIFT() override = default;
415 class RGWHandler_REST_Bucket_SWIFT : public RGWHandler_REST_SWIFT {
416 /* We need the boost::optional here only because of handler's late
417 * initialization (see the init() method). */
418 boost::optional<RGWSwiftWebsiteHandler> website_handler;
420 bool is_obj_update_op() override {
421 return s->op == OP_POST;
424 RGWOp *get_obj_op(bool get_data);
425 RGWOp *op_get() override;
426 RGWOp *op_head() override;
427 RGWOp *op_put() override;
428 RGWOp *op_delete() override;
429 RGWOp *op_post() override;
430 RGWOp *op_options() override;
432 using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
433 ~RGWHandler_REST_Bucket_SWIFT() override = default;
435 int error_handler(int err_no, std::string *error_content) override {
436 return website_handler->error_handler(err_no, error_content);
439 int retarget(RGWOp* op, RGWOp** new_op) override {
440 return website_handler->retarget_bucket(op, new_op);
443 int init(RGWRados* const store,
444 struct req_state* const s,
445 rgw::io::BasicClient* const cio) override {
446 website_handler = boost::in_place<RGWSwiftWebsiteHandler>(store, s, this);
447 return RGWHandler_REST_SWIFT::init(store, s, cio);
451 class RGWHandler_REST_Obj_SWIFT : public RGWHandler_REST_SWIFT {
452 /* We need the boost::optional here only because of handler's late
453 * initialization (see the init() method). */
454 boost::optional<RGWSwiftWebsiteHandler> website_handler;
456 bool is_obj_update_op() override {
457 return s->op == OP_POST;
460 RGWOp *get_obj_op(bool get_data);
461 RGWOp *op_get() override;
462 RGWOp *op_head() override;
463 RGWOp *op_put() override;
464 RGWOp *op_delete() override;
465 RGWOp *op_post() override;
466 RGWOp *op_copy() override;
467 RGWOp *op_options() override;
470 using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
471 ~RGWHandler_REST_Obj_SWIFT() override = default;
473 int error_handler(int err_no, std::string *error_content) override {
474 return website_handler->error_handler(err_no, error_content);
477 int retarget(RGWOp* op, RGWOp** new_op) override {
478 return website_handler->retarget_object(op, new_op);
481 int init(RGWRados* const store,
482 struct req_state* const s,
483 rgw::io::BasicClient* const cio) override {
484 website_handler = boost::in_place<RGWSwiftWebsiteHandler>(store, s, this);
485 return RGWHandler_REST_SWIFT::init(store, s, cio);
489 class RGWRESTMgr_SWIFT : public RGWRESTMgr {
491 RGWRESTMgr* get_resource_mgr_as_default(struct req_state* const s,
492 const std::string& uri,
493 std::string* const out_uri) override {
494 return this->get_resource_mgr(s, uri, out_uri);
498 RGWRESTMgr_SWIFT() = default;
499 ~RGWRESTMgr_SWIFT() override = default;
501 RGWHandler_REST *get_handler(struct req_state *s,
502 const rgw::auth::StrategyRegistry& auth_registry,
503 const std::string& frontend_prefix) override;
507 class RGWGetCrossDomainPolicy_ObjStore_SWIFT
508 : public RGWGetCrossDomainPolicy_ObjStore {
510 RGWGetCrossDomainPolicy_ObjStore_SWIFT() = default;
511 ~RGWGetCrossDomainPolicy_ObjStore_SWIFT() override = default;
513 void send_response() override;
516 class RGWGetHealthCheck_ObjStore_SWIFT
517 : public RGWGetHealthCheck_ObjStore {
519 RGWGetHealthCheck_ObjStore_SWIFT() = default;
520 ~RGWGetHealthCheck_ObjStore_SWIFT() override = default;
522 void send_response() override;
525 class RGWHandler_SWIFT_CrossDomain : public RGWHandler_REST {
527 RGWHandler_SWIFT_CrossDomain() = default;
528 ~RGWHandler_SWIFT_CrossDomain() override = default;
530 RGWOp *op_get() override {
531 return new RGWGetCrossDomainPolicy_ObjStore_SWIFT();
534 int init(RGWRados* const store,
535 struct req_state* const state,
536 rgw::io::BasicClient* const cio) override {
537 state->dialect = "swift";
538 state->formatter = new JSONFormatter;
539 state->format = RGW_FORMAT_JSON;
541 return RGWHandler::init(store, state, cio);
544 int authorize() override {
548 int postauth_init() override {
552 int read_permissions(RGWOp *) override {
556 virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
557 virtual void free_policy(RGWAccessControlPolicy *policy) {}
560 class RGWRESTMgr_SWIFT_CrossDomain : public RGWRESTMgr {
562 RGWRESTMgr *get_resource_mgr(struct req_state* const s,
563 const std::string& uri,
564 std::string* const out_uri) override {
569 RGWRESTMgr_SWIFT_CrossDomain() = default;
570 ~RGWRESTMgr_SWIFT_CrossDomain() override = default;
572 RGWHandler_REST* get_handler(struct req_state* const s,
573 const rgw::auth::StrategyRegistry&,
574 const std::string&) override {
575 s->prot_flags |= RGW_REST_SWIFT;
576 return new RGWHandler_SWIFT_CrossDomain;
581 class RGWHandler_SWIFT_HealthCheck : public RGWHandler_REST {
583 RGWHandler_SWIFT_HealthCheck() = default;
584 ~RGWHandler_SWIFT_HealthCheck() override = default;
586 RGWOp *op_get() override {
587 return new RGWGetHealthCheck_ObjStore_SWIFT();
590 int init(RGWRados* const store,
591 struct req_state* const state,
592 rgw::io::BasicClient* const cio) override {
593 state->dialect = "swift";
594 state->formatter = new JSONFormatter;
595 state->format = RGW_FORMAT_JSON;
597 return RGWHandler::init(store, state, cio);
600 int authorize() override {
604 int postauth_init() override {
608 int read_permissions(RGWOp *) override {
612 virtual RGWAccessControlPolicy *alloc_policy() { return nullptr; }
613 virtual void free_policy(RGWAccessControlPolicy *policy) {}
616 class RGWRESTMgr_SWIFT_HealthCheck : public RGWRESTMgr {
618 RGWRESTMgr *get_resource_mgr(struct req_state* const s,
619 const std::string& uri,
620 std::string* const out_uri) override {
625 RGWRESTMgr_SWIFT_HealthCheck() = default;
626 ~RGWRESTMgr_SWIFT_HealthCheck() override = default;
628 RGWHandler_REST* get_handler(struct req_state* const s,
629 const rgw::auth::StrategyRegistry&,
630 const std::string&) override {
631 s->prot_flags |= RGW_REST_SWIFT;
632 return new RGWHandler_SWIFT_HealthCheck;
637 class RGWHandler_REST_SWIFT_Info : public RGWHandler_REST_SWIFT {
639 using RGWHandler_REST_SWIFT::RGWHandler_REST_SWIFT;
640 ~RGWHandler_REST_SWIFT_Info() override = default;
642 RGWOp *op_get() override {
643 return new RGWInfo_ObjStore_SWIFT();
646 int init(RGWRados* const store,
647 struct req_state* const state,
648 rgw::io::BasicClient* const cio) override {
649 state->dialect = "swift";
650 state->formatter = new JSONFormatter;
651 state->format = RGW_FORMAT_JSON;
653 return RGWHandler::init(store, state, cio);
656 int authorize() override {
660 int postauth_init() override {
664 int read_permissions(RGWOp *) override {
669 class RGWRESTMgr_SWIFT_Info : public RGWRESTMgr {
671 RGWRESTMgr_SWIFT_Info() = default;
672 ~RGWRESTMgr_SWIFT_Info() override = default;
674 RGWHandler_REST *get_handler(struct req_state* s,
675 const rgw::auth::StrategyRegistry& auth_registry,
676 const std::string& frontend_prefix) override;